rcu.c File Reference

Go to the source code of this file.

Data Structures
struct	int_field_ctx_t
	Context for integer field updates in RCU updater callback. More...
struct	bool_field_ctx_t
	Context for boolean field updates in RCU updater callback. More...
struct	string_field_ctx_t
	Context for string field updates in RCU updater callback. More...
struct	double_field_ctx_t
	Context for double field updates in RCU updater callback. More...

Macros
#define	MAX_DEFERRED_FREES   64
	Deferred free list for old options structs.

Functions
	__attribute__ ((constructor))
	Constructor to initialize fork handlers at startup.
asciichat_error_t	options_state_init (void)
asciichat_error_t	options_state_set (const options_t *opts)
void	options_state_destroy (void)
void	options_cleanup_schema (void)
const options_t *	options_get (void)
asciichat_error_t	options_set_int (const char *field_name, int value)
asciichat_error_t	options_set_bool (const char *field_name, bool value)
asciichat_error_t	options_set_string (const char *field_name, const char *value)
asciichat_error_t	options_set_double (const char *field_name, double value)

Macro Definition Documentation

MAX_DEFERRED_FREES

#define MAX_DEFERRED_FREES   64

Deferred free list for old options structs.

We can't immediately free old structs because readers might still be using them. Simple strategy: Keep old pointers in a list, free them at shutdown.

Future improvements:

• Hazard pointers: Track which structs readers are using
• Epoch-based reclamation: Free after grace period
• Reference counting: Free when no readers

Current approach: Never free until shutdown (acceptable for rare updates)

Definition at line 132 of file rcu.c.

Function Documentation

__attribute__()

__attribute__

(

(constructor)

)

Constructor to initialize fork handlers at startup.

This is called before main() by the linker, ensuring fork handlers are registered early.

Definition at line 208 of file rcu.c.

                                                                                  {
  // Register the child handler that will be called after fork() in the child process
  pthread_atfork(NULL, NULL, options_rcu_atfork_child);
}

options_cleanup_schema()

void options_cleanup_schema

(

void

)

Definition at line 343 of file rcu.c.

                                  {
  config_schema_destroy();
}

References config_schema_destroy().

Referenced by main().

options_get()

const options_t * options_get

(

void

)

Definition at line 347 of file rcu.c.

                                   {
  // Lock-free read with acquire semantics
  // Guarantees we see all writes made before the pointer was published
  options_t *current = atomic_load_explicit(&g_options, memory_order_acquire);
 
  // If options not yet published, return safe static default instead of crashing
  // This allows atexit handlers to safely call GET_OPTION() during cleanup
  if (!current) {
    // Return static default - safe for atexit handlers to read
    return (const options_t *)&g_default_options;
  }
 
  return current;
}

Referenced by acds_main(), client_crypto_init(), client_main(), discovery_session_process(), log_set_terminal_output(), main(), nat_detect_quality(), server_crypto_handshake(), session_settings_from_options(), and threaded_send_terminal_size_with_auto_detect().

options_set_bool()

asciichat_error_t options_set_bool	(	const char *	field_name,
		bool	value
	)

Definition at line 562 of file rcu.c.

                                                                       {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Validate field exists
  if (strcmp(field_name, "no_compress") != 0 && strcmp(field_name, "encode_audio") != 0 &&
      strcmp(field_name, "flip_x") != 0 && strcmp(field_name, "flip_y") != 0 &&
      strcmp(field_name, "test_pattern") != 0 && strcmp(field_name, "no_audio_mixer") != 0 &&
      strcmp(field_name, "show_capabilities") != 0 && strcmp(field_name, "force_utf8") != 0 &&
      strcmp(field_name, "audio_enabled") != 0 && strcmp(field_name, "audio_analysis_enabled") != 0 &&
      strcmp(field_name, "audio_no_playback") != 0 && strcmp(field_name, "stretch") != 0 &&
      strcmp(field_name, "snapshot_mode") != 0 && strcmp(field_name, "strip_ansi") != 0 &&
      strcmp(field_name, "quiet") != 0 && strcmp(field_name, "encrypt_enabled") != 0 &&
      strcmp(field_name, "no_encrypt") != 0 && strcmp(field_name, "discovery") != 0 &&
      strcmp(field_name, "discovery_expose_ip") != 0 && strcmp(field_name, "discovery_insecure") != 0 &&
      strcmp(field_name, "webrtc") != 0 && strcmp(field_name, "lan_discovery") != 0 &&
      strcmp(field_name, "no_mdns_advertise") != 0 && strcmp(field_name, "prefer_webrtc") != 0 &&
      strcmp(field_name, "no_webrtc") != 0 && strcmp(field_name, "webrtc_skip_stun") != 0 &&
      strcmp(field_name, "webrtc_disable_turn") != 0 && strcmp(field_name, "enable_upnp") != 0 &&
      strcmp(field_name, "require_server_identity") != 0 && strcmp(field_name, "require_client_identity") != 0 &&
      strcmp(field_name, "require_server_verify") != 0 && strcmp(field_name, "require_client_verify") != 0 &&
      strcmp(field_name, "palette_custom_set") != 0 && strcmp(field_name, "media_loop") != 0 &&
      strcmp(field_name, "media_from_stdin") != 0 && strcmp(field_name, "auto_width") != 0 &&
      strcmp(field_name, "auto_height") != 0 && strcmp(field_name, "splash") != 0 &&
      strcmp(field_name, "status_screen") != 0 && strcmp(field_name, "matrix_rain") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown boolean field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  bool_field_ctx_t ctx = {.field_name = field_name, .value = value};
  return options_update(bool_field_updater, &ctx);
}

References bool_field_ctx_t::field_name.

Referenced by client_main(), session_handle_keyboard_input(), set_flip_x(), and set_matrix_rain().

options_set_double()

asciichat_error_t options_set_double	(	const char *	field_name,
		double	value
	)

Definition at line 695 of file rcu.c.

                                                                           {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Normalize option names to internal field names
  const char *internal_name = field_name;
  if (strcmp(field_name, "microphone-volume") == 0 || strcmp(field_name, "ivolume") == 0) {
    internal_name = "microphone_sensitivity";
  } else if (strcmp(field_name, "speakers-volume") == 0 || strcmp(field_name, "volume") == 0) {
    internal_name = "speakers_volume";
  }
 
  if (strcmp(internal_name, "snapshot_delay") != 0 && strcmp(internal_name, "microphone_sensitivity") != 0 &&
      strcmp(internal_name, "speakers_volume") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown double field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  double_field_ctx_t ctx = {.field_name = internal_name, .value = value};
  return options_update(double_field_updater, &ctx);
}

References double_field_ctx_t::field_name.

Referenced by session_handle_keyboard_input().

options_set_int()

asciichat_error_t options_set_int	(	const char *	field_name,
		int	value
	)

Definition at line 449 of file rcu.c.

                                                                     {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  if (strcmp(field_name, "width") != 0 && strcmp(field_name, "height") != 0 && strcmp(field_name, "max_clients") != 0 &&
      strcmp(field_name, "compression_level") != 0 && strcmp(field_name, "reconnect_attempts") != 0 &&
      strcmp(field_name, "microphone_index") != 0 && strcmp(field_name, "speakers_index") != 0 &&
      strcmp(field_name, "discovery_port") != 0 && strcmp(field_name, "port") != 0 && strcmp(field_name, "fps") != 0 &&
      strcmp(field_name, "color_mode") != 0 && strcmp(field_name, "color_filter") != 0 &&
      strcmp(field_name, "render_mode") != 0 && strcmp(field_name, "log_level") != 0 &&
      strcmp(field_name, "palette_type") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown integer field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  int_field_ctx_t ctx = {.field_name = field_name, .value = value};
  return options_update(int_field_updater, &ctx);
}

References int_field_ctx_t::field_name.

Referenced by session_handle_keyboard_input(), session_settings_apply_to_options(), set_color_filter(), set_color_mode(), set_height(), set_palette(), set_render_mode(), set_target_fps(), and set_width().

options_set_string()

asciichat_error_t options_set_string	(	const char *	field_name,
		const char *	value
	)

Definition at line 647 of file rcu.c.

                                                                                {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  if (!value) {
    SET_ERRNO(ERROR_INVALID_PARAM, "value is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Validate field exists
  if (strcmp(field_name, "address") != 0 && strcmp(field_name, "address6") != 0 &&
      strcmp(field_name, "encrypt_key") != 0 && strcmp(field_name, "password") != 0 &&
      strcmp(field_name, "encrypt_keyfile") != 0 && strcmp(field_name, "server_key") != 0 &&
      strcmp(field_name, "client_keys") != 0 && strcmp(field_name, "discovery_server") != 0 &&
      strcmp(field_name, "discovery_service_key") != 0 && strcmp(field_name, "discovery_database_path") != 0 &&
      strcmp(field_name, "log_file") != 0 && strcmp(field_name, "media_file") != 0 &&
      strcmp(field_name, "palette_custom") != 0 && strcmp(field_name, "stun_servers") != 0 &&
      strcmp(field_name, "turn_servers") != 0 && strcmp(field_name, "turn_username") != 0 &&
      strcmp(field_name, "turn_credential") != 0 && strcmp(field_name, "turn_secret") != 0 &&
      strcmp(field_name, "session_string") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown string field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  string_field_ctx_t ctx = {.field_name = field_name, .value = value};
  return options_update(string_field_updater, &ctx);
}

References string_field_ctx_t::field_name.

Referenced by set_palette_chars().

options_state_destroy()

void options_state_destroy

(

void

)

Definition at line 309 of file rcu.c.

                                 {
  // Check and clear initialization flag under lock
  static_mutex_lock(&g_options_init_mutex);
  if (!g_options_initialized) {
    static_mutex_unlock(&g_options_init_mutex);
    return;
  }
  g_options_initialized = false; // Clear flag first to prevent new operations
  static_mutex_unlock(&g_options_init_mutex);
 
  // Get current options pointer
  options_t *current = atomic_load_explicit(&g_options, memory_order_acquire);
 
  // Clear the atomic pointer (prevent further reads)
  atomic_store_explicit(&g_options, NULL, memory_order_release);
 
  // Free current struct
  SAFE_FREE(current);
 
  // Free all deferred structs
  deferred_free_all();
 
  // Cleanup schema (frees all dynamically allocated config strings)
  config_schema_destroy();
 
  // Destroy dynamically created mutexes
  // NOTE: Do NOT destroy g_options_init_mutex - it's statically initialized
  // and needs to persist across shutdown/init cycles (especially in tests)
  mutex_destroy(&g_options_write_mutex);
  mutex_destroy(&g_deferred_free_mutex);
 
  log_debug("Options state shutdown complete");
}

References config_schema_destroy(), and mutex_destroy().

Referenced by asciichat_shared_destroy(), client_cleanup(), main(), mirror_cleanup(), and server_main().

options_state_init()

asciichat_error_t options_state_init

(

void

)

Definition at line 218 of file rcu.c.

                                           {
  // Detect fork: after fork(), child process must reinitialize mutexes BEFORE locking
  // The inherited mutex is in an inconsistent state and can cause deadlocks/signals
  // We must reset it before calling static_mutex_lock
  pid_t current_pid = platform_get_pid();
  if ((g_options_initialized || g_init_pid != -1) && g_init_pid != current_pid) {
// We're in a forked child - reset the static mutex state before using it
// On POSIX, set initialized=0 so static_mutex_lock will reinitialize it
// On Windows, the InterlockedCompareExchange logic handles this automatically
#ifndef _WIN32
    g_options_init_mutex.initialized = 0; // Force reinitialization on next lock
#else
    g_options_init_mutex.initialized = 0; // Same approach for Windows
#endif
    log_debug("Detected fork in options_state_init (parent PID %d, child PID %d) - resetting mutex", g_init_pid,
              current_pid);
    g_options_initialized = false;
    g_init_pid = current_pid; // Set to current PID so we know we're initialized in this process
  }
 
  static_mutex_lock(&g_options_init_mutex);
 
  // Check if already initialized in this process
  if (g_options_initialized && g_init_pid == current_pid) {
    // Already initialized in this process
    static_mutex_unlock(&g_options_init_mutex);
    log_warn("Options state already initialized");
    return ASCIICHAT_OK;
  }
 
  // Initialize write mutex
  if (mutex_init(&g_options_write_mutex) != 0) {
    static_mutex_unlock(&g_options_init_mutex);
    return SET_ERRNO(ERROR_THREAD, "Failed to initialize options write mutex");
  }
 
  // Initialize deferred free mutex
  if (mutex_init(&g_deferred_free_mutex) != 0) {
    mutex_destroy(&g_options_write_mutex);
    static_mutex_unlock(&g_options_init_mutex);
    return SET_ERRNO(ERROR_THREAD, "Failed to initialize deferred free mutex");
  }
 
  // Allocate initial options struct (will be populated later by options_state_populate_from_globals)
  options_t *initial_opts = SAFE_MALLOC(sizeof(options_t), options_t *);
  if (!initial_opts) {
    mutex_destroy(&g_options_write_mutex);
    mutex_destroy(&g_deferred_free_mutex);
    static_mutex_unlock(&g_options_init_mutex);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate initial options struct");
  }
 
  // Initialize all defaults using options_t_new()
  *initial_opts = options_t_new();
 
  // Publish initial struct (release semantics - make all fields visible to readers)
  atomic_store_explicit(&g_options, initial_opts, memory_order_release);
 
  g_options_initialized = true;
  g_init_pid = current_pid; // Record PID to detect fork later
  static_mutex_unlock(&g_options_init_mutex);
  log_dev("Options state initialized with RCU pattern (PID %d)", current_pid);
 
  return ASCIICHAT_OK;
}

References mutex_destroy(), mutex_init(), options_t_new(), and platform_get_pid().

Referenced by __attribute__(), and options_init().

options_state_set()

asciichat_error_t options_state_set

(

const options_t *

opts

)

Definition at line 284 of file rcu.c.

                                                           {
  if (!opts) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "opts is NULL");
  }
 
  // Check initialization flag under lock to prevent TOCTOU race
  static_mutex_lock(&g_options_init_mutex);
  if (!g_options_initialized) {
    static_mutex_unlock(&g_options_init_mutex);
    return SET_ERRNO(ERROR_INVALID_STATE, "Options state not initialized (call options_state_init first)");
  }
  static_mutex_unlock(&g_options_init_mutex);
 
  // Get current struct (should be the initial zero-initialized one during startup)
  options_t *current = atomic_load_explicit(&g_options, memory_order_acquire);
 
  // Copy provided options into current struct
  // Note: No need for RCU update here since this is called during initialization
  // before any reader threads exist
  memcpy(current, opts, sizeof(options_t));
 
  log_debug("Options state set from parsed struct");
  return ASCIICHAT_OK;
}

Referenced by config_load_and_apply(), and options_init().