rcu.c File Reference

Go to the source code of this file.

Data Structures
struct	dimensions_update_ctx

Macros
#define	MAX_DEFERRED_FREES   64

Functions
asciichat_error_t	options_state_init (void)
	Initialize RCU options system.
asciichat_error_t	options_state_set (const options_t *opts)
	Set options from a parsed options struct.
void	options_state_shutdown (void)
	Shutdown RCU options system.
const options_t *	options_get (void)
	Get current options (lock-free read)
asciichat_error_t	options_update (void(*updater)(options_t *, void *), void *context)
	Update options using copy-on-write (thread-safe)
asciichat_error_t	options_set_dimensions (unsigned short int width, unsigned short int height)
	Update terminal dimensions.
asciichat_error_t	options_set_color_mode (terminal_color_mode_t mode)
	Update color mode.
asciichat_error_t	options_set_render_mode (render_mode_t mode)
	Update render mode.
asciichat_error_t	options_set_log_level (log_level_t level)
	Update log level.

Macro Definition Documentation

MAX_DEFERRED_FREES

#define MAX_DEFERRED_FREES   64

Function Documentation

options_state_init()

asciichat_error_t options_state_init

(

void

)

Initialize RCU options system.

Must be called once at program startup before any threads access options. Allocates initial options struct and sets up atomic pointer.

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 117 of file rcu.c.

                                           {
  if (g_options_initialized) {
    log_warn("Options state already initialized");
    return ASCIICHAT_OK;
  }
 
  // Initialize write mutex
  if (mutex_init(&g_options_write_mutex) != 0) {
    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);
    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);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate initial options struct");
  }
 
  // Zero-initialize (all fields start at 0/false/NULL)
  memset(initial_opts, 0, sizeof(*initial_opts));
 
  // Set non-zero defaults using defines from options.h
  // These match the documented defaults in --help output
 
  // Network defaults
  SAFE_STRNCPY(initial_opts->port, OPT_PORT_DEFAULT, sizeof(initial_opts->port));
  SAFE_STRNCPY(initial_opts->address, OPT_ADDRESS_DEFAULT, sizeof(initial_opts->address));
  SAFE_STRNCPY(initial_opts->address6, OPT_ADDRESS6_DEFAULT, sizeof(initial_opts->address6));
 
  // Server defaults
  initial_opts->max_clients = OPT_MAX_CLIENTS_DEFAULT;
  initial_opts->compression_level = OPT_COMPRESSION_LEVEL_DEFAULT;
 
  // Client defaults
  initial_opts->webcam_index = OPT_WEBCAM_INDEX_DEFAULT;
  initial_opts->microphone_index = OPT_MICROPHONE_INDEX_DEFAULT;
  initial_opts->speakers_index = OPT_SPEAKERS_INDEX_DEFAULT;
  initial_opts->snapshot_delay = SNAPSHOT_DELAY_DEFAULT;
  initial_opts->reconnect_attempts = OPT_RECONNECT_ATTEMPTS_DEFAULT;
 
  // Color and rendering defaults (using zero values which are the correct defaults)
  initial_opts->color_mode = COLOR_MODE_AUTO; // -1
 
  // 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;
  log_debug("Options state initialized with RCU pattern");
 
  return ASCIICHAT_OK;
}

References options_state::address, options_state::address6, ASCIICHAT_OK, options_state::color_mode, COLOR_MODE_AUTO, options_state::compression_level, ERROR_MEMORY, ERROR_THREAD, log_debug, log_warn, options_state::max_clients, options_state::microphone_index, mutex_destroy(), mutex_init(), OPT_ADDRESS6_DEFAULT, OPT_ADDRESS_DEFAULT, OPT_COMPRESSION_LEVEL_DEFAULT, OPT_MAX_CLIENTS_DEFAULT, OPT_MICROPHONE_INDEX_DEFAULT, OPT_PORT_DEFAULT, OPT_RECONNECT_ATTEMPTS_DEFAULT, OPT_SPEAKERS_INDEX_DEFAULT, OPT_WEBCAM_INDEX_DEFAULT, options_state::port, options_state::reconnect_attempts, SAFE_MALLOC, SAFE_STRNCPY, SET_ERRNO, options_state::snapshot_delay, SNAPSHOT_DELAY_DEFAULT, options_state::speakers_index, and options_state::webcam_index.

Referenced by __attribute__(), and options_init().

options_state_set()

asciichat_error_t options_state_set

(

const options_t *

opts

)

Set options from a parsed options struct.

Called by options_init() after parsing to publish the options struct to RCU. This atomically replaces the current options with the provided struct.

Parameters

opts	Pointer to options struct to publish (will be copied)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 176 of file rcu.c.

                                                           {
  if (!opts) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "opts is NULL");
  }
 
  if (!g_options_initialized) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Options state not initialized (call options_state_init first)");
  }
 
  // 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;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, log_debug, and SET_ERRNO.

Referenced by options_init().

options_state_shutdown()

void options_state_shutdown

(

void

)

Shutdown RCU options system.

Frees the current options struct and cleans up resources. Should be called at program shutdown after all threads have exited.

Definition at line 197 of file rcu.c.

                                  {
  if (!g_options_initialized) {
    return;
  }
 
  // 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();
 
  // Destroy mutexes
  mutex_destroy(&g_options_write_mutex);
  mutex_destroy(&g_deferred_free_mutex);
 
  g_options_initialized = false;
  log_debug("Options state shutdown complete");
}

References log_debug, mutex_destroy(), and SAFE_FREE.

Referenced by asciichat_shared_init(), and server_main().