lifecycle.h File Reference

Lock-free module lifecycle state machine using pure stdatomic. More...

Go to the source code of this file.

Data Structures
struct	lifecycle_t

Macros
#define	LIFECYCLE_INIT
	Static initializer for module-global lifecycle variables (no sync primitive)
#define	LIFECYCLE_INIT_MUTEX(m)
	Static initializer for lifecycle with mutex.
#define	LIFECYCLE_INIT_RWLOCK(r)
	Static initializer for lifecycle with rwlock.

Enumerations
enum	lifecycle_state_t {   LIFECYCLE_UNINITIALIZED = 0 , LIFECYCLE_INITIALIZING = 1 , LIFECYCLE_INITIALIZED = 2 , LIFECYCLE_DEAD = 3 ,   LIFECYCLE_DESTROYING = 4 }
enum	lifecycle_sync_type_t { LIFECYCLE_SYNC_NONE = 0 , LIFECYCLE_SYNC_MUTEX = 1 , LIFECYCLE_SYNC_RWLOCK = 2 }

Functions
bool	lifecycle_init (lifecycle_t *lc, const char *name)
bool	lifecycle_init_once (lifecycle_t *lc)
void	lifecycle_init_commit (lifecycle_t *lc)
void	lifecycle_init_abort (lifecycle_t *lc)
bool	lifecycle_shutdown (lifecycle_t *lc)
bool	lifecycle_shutdown_forever (lifecycle_t *lc)
bool	lifecycle_is_initialized (const lifecycle_t *lc)
bool	lifecycle_is_dead (const lifecycle_t *lc)
bool	lifecycle_reset (lifecycle_t *lc)
bool	lifecycle_destroy_once (lifecycle_t *lc)
void	lifecycle_destroy_commit (lifecycle_t *lc)

Detailed Description

Lock-free module lifecycle state machine using pure stdatomic.

Provides a standardized API for module-level init/shutdown synchronization across all modules. Uses a 4-state machine (UNINITIALIZED, INITIALIZING, INITIALIZED, DEAD) to coordinate concurrent initialization and permanent shutdown with zero mutex overhead.

Typical usage (concurrent init): static lifecycle_t g_module_lc = LIFECYCLE_INIT;

bool module_init(void) { if (!lifecycle_init_once(&g_module_lc)) return false; // do actual init work if (init_failed) { lifecycle_init_abort(&g_module_lc); // allow retry return false; } lifecycle_init_commit(&g_module_lc); // mark ready return true; }

Typical usage (non-concurrent, single-threaded startup): if (!lifecycle_init(&g_module_lc)) return false; // already initialized // do actual init work

Definition in file lifecycle.h.

Macro Definition Documentation

LIFECYCLE_INIT

#define LIFECYCLE_INIT

Value:

  {                                                                                                                    \
    .state = {.impl = LIFECYCLE_UNINITIALIZED}, .sync_type = LIFECYCLE_SYNC_NONE, .sync = {0}                          \
  }

Static initializer for module-global lifecycle variables (no sync primitive)

Definition at line 68 of file lifecycle.h.

  {                                                                                                                    \
    .state = {.impl = LIFECYCLE_UNINITIALIZED}, .sync_type = LIFECYCLE_SYNC_NONE, .sync = {0}                          \
  }

LIFECYCLE_INIT_MUTEX

#define LIFECYCLE_INIT_MUTEX

(

m

)

Value:

  {                                                                                                                    \
    .state = {.impl = LIFECYCLE_UNINITIALIZED}, .sync_type = LIFECYCLE_SYNC_MUTEX, .sync = {.mutex = (m) }             \
  }

Static initializer for lifecycle with mutex.

Definition at line 74 of file lifecycle.h.

  {                                                                                                                    \
    .state = {.impl = LIFECYCLE_UNINITIALIZED}, .sync_type = LIFECYCLE_SYNC_MUTEX, .sync = {.mutex = (m) }             \
  }

LIFECYCLE_INIT_RWLOCK

#define LIFECYCLE_INIT_RWLOCK

(

r

)

Value:

  {                                                                                                                    \
    .state = {.impl = LIFECYCLE_UNINITIALIZED}, .sync_type = LIFECYCLE_SYNC_RWLOCK, .sync = {.rwlock = (r) }           \
  }

Static initializer for lifecycle with rwlock.

Definition at line 80 of file lifecycle.h.

  {                                                                                                                    \
    .state = {.impl = LIFECYCLE_UNINITIALIZED}, .sync_type = LIFECYCLE_SYNC_RWLOCK, .sync = {.rwlock = (r) }           \
  }

Enumeration Type Documentation

lifecycle_state_t

enum lifecycle_state_t

Enumerator
LIFECYCLE_UNINITIALIZED	Not yet initialized (zero = default)
LIFECYCLE_INITIALIZING	init_once winner in progress; losers spin
LIFECYCLE_INITIALIZED	Ready to use.
LIFECYCLE_DEAD	Permanently shut down; no re-init.
LIFECYCLE_DESTROYING	destroy_once winner in progress; losers skip

Definition at line 40 of file lifecycle.h.

             {
  LIFECYCLE_UNINITIALIZED = 0, 
  LIFECYCLE_INITIALIZING = 1,  
  LIFECYCLE_INITIALIZED = 2,   
  LIFECYCLE_DEAD = 3,          
  LIFECYCLE_DESTROYING = 4,    
} lifecycle_state_t;

lifecycle_sync_type_t

enum lifecycle_sync_type_t

Enumerator
LIFECYCLE_SYNC_NONE	No sync primitive.
LIFECYCLE_SYNC_MUTEX	Contains mutex_t pointer.
LIFECYCLE_SYNC_RWLOCK	Contains rwlock_t pointer.

Definition at line 48 of file lifecycle.h.

             {
  LIFECYCLE_SYNC_NONE = 0,   
  LIFECYCLE_SYNC_MUTEX = 1,  
  LIFECYCLE_SYNC_RWLOCK = 2, 
} lifecycle_sync_type_t;

Function Documentation

lifecycle_destroy_commit()

void lifecycle_destroy_commit

(

lifecycle_t *

lc

)

Commit successful destruction: DESTROYING → UNINITIALIZED. Call this after lifecycle_destroy_once() returns true and destroy work completes.

Parameters

lc	lifecycle state

Returns the module to UNINITIALIZED state, allowing future re-initialization.

Definition at line 236 of file lifecycle.c.

                                               {
  if (lc == NULL) {
    log_dev("[lifecycle] destroy_commit: NULL lifecycle pointer");
    return;
  }
  log_dev("[lifecycle] destroy_commit: transitioning DESTROYING → UNINITIALIZED");
  atomic_store_u64(&lc->state, LIFECYCLE_UNINITIALIZED);
}

References atomic_store_u64(), LIFECYCLE_UNINITIALIZED, log_dev, and lifecycle_t::state.

Referenced by audio_stop_thread().

lifecycle_destroy_once()

bool lifecycle_destroy_once

(

lifecycle_t *

lc

)

Lock-free concurrent destruction: CAS INITIALIZED → DESTROYING.

Winner receives true and must complete the two-phase sequence:

1. Do actual destroy work
2. Call lifecycle_destroy_commit() on completion

Losing callers return false and should skip cleanup work. Once destruction begins, no further operations are possible until the winner completes.

Parameters

lc	lifecycle state

Returns

true if THIS caller won the destroy race and should do work

false if not INITIALIZED, already being destroyed, or in DEAD state

Safe for concurrent callers. Exactly one caller gets true (the CAS winner). Prevents double-join and other double-cleanup issues when multiple threads call cleanup functions concurrently.

Definition at line 193 of file lifecycle.c.

                                             {
  if (lc == NULL) {
    log_dev("[lifecycle] destroy_once: NULL lifecycle pointer");
    return false;
  }
 
  uint64_t expected = LIFECYCLE_INITIALIZED;
  if (!atomic_cas_u64(&lc->state, &expected, LIFECYCLE_DESTROYING)) {
    // If not initialized, nothing to destroy
    if (expected == LIFECYCLE_UNINITIALIZED) {
      log_dev("[lifecycle] destroy_once: already uninitialized, nothing to destroy");
      return false;
    }
 
    // If dead, never allow destruction (already permanently shut down)
    if (expected == LIFECYCLE_DEAD) {
      log_dev("[lifecycle] destroy_once: module is dead, no destruction allowed");
      return false;
    }
 
    // If already destroying, don't duplicate work (return false, let first destroyer finish)
    if (expected == LIFECYCLE_DESTROYING) {
      log_dev("[lifecycle] destroy_once: already destroying, skipping (first destroyer has priority)");
      return false;
    }
 
    // If initializing, skip destruction (init may still be in progress)
    if (expected == LIFECYCLE_INITIALIZING) {
      log_dev("[lifecycle] destroy_once: still initializing, skipping destruction");
      return false;
    }
 
    // Unexpected state
    log_dev("[lifecycle] destroy_once: unexpected state: %d", expected);
    return false;
  }
 
  // Winner: state is now LIFECYCLE_DESTROYING
  // Caller must call lifecycle_destroy_commit()
  log_dev("[lifecycle] destroy_once: won CAS, transitioned to DESTROYING");
  return true;
}

References atomic_cas_u64(), LIFECYCLE_DEAD, LIFECYCLE_DESTROYING, LIFECYCLE_INITIALIZED, LIFECYCLE_INITIALIZING, LIFECYCLE_UNINITIALIZED, log_dev, and lifecycle_t::state.

Referenced by audio_stop_thread().

lifecycle_init()

bool lifecycle_init	(	lifecycle_t *	lc,
		const char *	name
	)

CAS-based initialization: UNINIT → INITIALIZED.

Parameters

lc	lifecycle state (may include sync_type and sync pointer)
name	name tag for any sync primitive (for debugging), or NULL if no sync

Returns

true if THIS caller won the race and should do init work

false if already INITIALIZED, INITIALIZING, or DEAD

Suitable for single-threaded startup or contexts where the caller guarantees serialization. If lc->sync_type != SYNC_NONE, initializes the sync primitive.

Definition at line 26 of file lifecycle.c.

                                                       {
  if (lc == NULL) {
    lifecycle_log_dev("[lifecycle] init: NULL lifecycle pointer");
    return false;
  }
  uint64_t expected = LIFECYCLE_UNINITIALIZED;
  if (!atomic_cas_u64(&lc->state, &expected, LIFECYCLE_INITIALIZED)) {
    lifecycle_log_dev("[lifecycle] init: %s already initialized (current state: %llu)", name ? name : "<unnamed>",
                      expected);
    return false; // Already initialized or in INITIALIZING/DEAD state
  }
 
  /* Winner: initialize sync primitive if configured */
  if (lc->sync_type == LIFECYCLE_SYNC_MUTEX && lc->sync.mutex != NULL) {
    lifecycle_log_dev("[lifecycle] init: %s initializing mutex", name ? name : "<unnamed>");
    mutex_init(lc->sync.mutex, name);
  } else if (lc->sync_type == LIFECYCLE_SYNC_RWLOCK && lc->sync.rwlock != NULL) {
    lifecycle_log_dev("[lifecycle] init: %s initializing rwlock", name ? name : "<unnamed>");
    rwlock_init(lc->sync.rwlock, name);
  } else {
    lifecycle_log_dev("[lifecycle] init: %s initialized (no sync primitive)", name ? name : "<unnamed>");
  }
 
  return true;
}

References atomic_cas_int(), atomic_cas_u64(), LIFECYCLE_INITIALIZED, lifecycle_log_dev, LIFECYCLE_SYNC_MUTEX, LIFECYCLE_SYNC_RWLOCK, LIFECYCLE_UNINITIALIZED, lifecycle_t::mutex, mutex_init(), lifecycle_t::rwlock, rwlock_init(), lifecycle_t::state, lifecycle_t::sync, and lifecycle_t::sync_type.

Referenced by ansi_fast_init_16color(), ansi_fast_init_256color(), asciichat_error_stats_get(), asciichat_error_stats_init(), asciichat_error_stats_record(), asciichat_pcre2_singleton_compile(), asciichat_pcre2_singleton_get_code(), audio_sender_init(), audio_stop_thread(), buffer_pool_init_global(), client_crypto_init(), colorscheme_init(), init_default_luminance_palette(), log_init(), log_search_init(), named_init(), options_state_init(), stats_init(), symbol_cache_init(), and timer_system_init().

lifecycle_init_abort()

void lifecycle_init_abort

(

lifecycle_t *

lc

)

Abort failed initialization: INITIALIZING → UNINITIALIZED. Call this if lifecycle_init_once() returns true but init work fails.

Parameters

lc	lifecycle state

Allows the next caller to retry initialization. Wakes spinners.

Definition at line 99 of file lifecycle.c.

                                           {
  if (lc == NULL) {
    lifecycle_log_dev("[lifecycle] init_abort: NULL lifecycle pointer");
    return;
  }
  lifecycle_log_dev("[lifecycle] init_abort: transitioning INITIALIZING → UNINITIALIZED (retry allowed)");
  atomic_store_u64(&lc->state, LIFECYCLE_UNINITIALIZED);
}

References atomic_store_int(), atomic_store_u64(), lifecycle_log_dev, LIFECYCLE_UNINITIALIZED, and lifecycle_t::state.

Referenced by audio_client_init(), and symbol_cache_init().

lifecycle_init_commit()

void lifecycle_init_commit

(

lifecycle_t *

lc

)

Commit successful initialization: INITIALIZING → INITIALIZED. Call this after lifecycle_init_once() returns true and init work succeeds.

Parameters

lc	lifecycle state

Wakes all spinners waiting in lifecycle_init_once(). Must be called by the lifecycle_init_once() winner after successful init work.

Definition at line 90 of file lifecycle.c.

                                            {
  if (lc == NULL) {
    lifecycle_log_dev("[lifecycle] init_commit: NULL lifecycle pointer");
    return;
  }
  lifecycle_log_dev("[lifecycle] init_commit: transitioning INITIALIZING → INITIALIZED");
  atomic_store_u64(&lc->state, LIFECYCLE_INITIALIZED);
}

References atomic_store_int(), atomic_store_u64(), LIFECYCLE_INITIALIZED, lifecycle_log_dev, and lifecycle_t::state.

Referenced by asciichat_instr_coverage_enabled(), asciichat_instr_runtime_get(), asciichat_pcre2_singleton_get_code(), audio_client_init(), log_search_init(), named_init(), splash_set_update_notification(), update_banner_has_update(), and update_banner_set_result().

lifecycle_init_once()

bool lifecycle_init_once

(

lifecycle_t *

lc

)

Lock-free concurrent initialization: CAS UNINIT → INITIALIZING.

Winner receives true and must complete the two-phase sequence:

1. Do actual init work
2. Call lifecycle_init_commit() on success or lifecycle_init_abort() on failure

Losing callers spin on the transient INITIALIZING state until the winner commits, then return false without doing work.

Parameters

lc	lifecycle state

Returns

true if THIS caller won the init race and should do work

false if init already happened (or is in progress) or module is DEAD

Safe for concurrent callers. Exactly one caller gets true (the CAS winner). Other concurrent callers spin until the winner moves to INITIALIZED or DEAD.

Definition at line 52 of file lifecycle.c.

                                          {
  if (lc == NULL) {
    lifecycle_log_dev("[lifecycle] init_once: NULL lifecycle pointer");
    return false;
  }
 
  uint64_t expected = LIFECYCLE_UNINITIALIZED;
  if (!atomic_cas_u64(&lc->state, &expected, LIFECYCLE_INITIALIZING)) {
    // If already initialized, just return false (no work needed)
    if (expected == LIFECYCLE_INITIALIZED) {
      lifecycle_log_dev("[lifecycle] init_once: already initialized");
      return false;
    }
 
    // If dead, never allow re-init
    if (expected == LIFECYCLE_DEAD) {
      lifecycle_log_dev("[lifecycle] init_once: module is dead, no re-init allowed");
      return false;
    }
 
    // If initializing, don't spin (caller may be retrying or it may complete asynchronously)
    // Just return false to indicate this thread doesn't need to do init work
    if (expected == LIFECYCLE_INITIALIZING) {
      lifecycle_log_dev("[lifecycle] init_once: already initializing, skipping (will resolve asynchronously)");
      return false;
    }
 
    // Unexpected state
    lifecycle_log_dev("[lifecycle] init_once: unexpected state: %d", expected);
    return false;
  }
 
  // Winner: state is now LIFECYCLE_INITIALIZING
  // Caller must call lifecycle_init_commit() or lifecycle_init_abort()
  lifecycle_log_dev("[lifecycle] init_once: won CAS, transitioned to INITIALIZING");
  return true;
}

References atomic_cas_int(), atomic_cas_u64(), LIFECYCLE_DEAD, LIFECYCLE_INITIALIZED, LIFECYCLE_INITIALIZING, lifecycle_log_dev, LIFECYCLE_UNINITIALIZED, and lifecycle_t::state.

Referenced by asciichat_instr_coverage_enabled(), asciichat_instr_runtime_get(), audio_client_init(), log_search_init(), splash_set_update_notification(), update_banner_has_update(), and update_banner_set_result().

lifecycle_is_dead()

bool lifecycle_is_dead

(

const lifecycle_t *

lc

)

Query: is module in DEAD state?

Parameters

lc	lifecycle state

Returns

true if state == LIFECYCLE_DEAD

Load-only, no side effects. Safe to call from any thread.

Definition at line 161 of file lifecycle.c.

                                              {
  if (lc == NULL)
    return false;
  return atomic_load_u64(&lc->state) == LIFECYCLE_DEAD;
}

References atomic_load_u64(), LIFECYCLE_DEAD, and lifecycle_t::state.

lifecycle_is_initialized()

bool lifecycle_is_initialized

(

const lifecycle_t *

lc

)

Query: is module in INITIALIZED state?

Parameters

lc	lifecycle state

Returns

true if state == LIFECYCLE_INITIALIZED

Load-only, no side effects. Safe to call from any thread.

Definition at line 155 of file lifecycle.c.

                                                     {
  if (lc == NULL)
    return false;
  return atomic_load_u64(&lc->state) == LIFECYCLE_INITIALIZED;
}

References atomic_load_u64(), LIFECYCLE_INITIALIZED, and lifecycle_t::state.

Referenced by asciichat_error_stats_get(), asciichat_error_stats_print(), asciichat_error_stats_record(), asciichat_error_stats_reset(), asciichat_instr_coverage_enabled(), asciichat_instr_runtime_get(), asciichat_pcre2_singleton_get_code(), audio_client_init(), audio_sender_cleanup(), audio_sender_finalize(), audio_stop_thread(), client_crypto_handshake(), colorscheme_destroy(), colorscheme_get_active_scheme(), colorscheme_init(), colorscheme_set_active_scheme(), crypto_client_initiate_rekey(), crypto_client_is_ready(), crypto_client_process_rekey_request(), crypto_client_process_rekey_response(), crypto_client_send_rekey_complete(), crypto_client_send_rekey_response(), crypto_client_should_rekey(), log_file_msg(), log_init(), log_init_colors(), log_msg(), log_plain_msg(), log_plain_stderr_msg(), log_plain_stderr_nonewline_msg(), log_plain_stdout_msg(), log_server_stats(), log_terminal_msg(), named_describe(), named_get(), named_get_fd(), named_get_fd_format_spec(), named_get_format_spec(), named_get_packet_type(), named_get_packet_type_format_spec(), named_get_type(), named_init(), named_register(), named_register_fd(), named_register_fmt(), named_register_packet_type(), named_registry_for_each(), named_unregister(), options_state_destroy(), options_state_init(), options_state_set(), platform_is_binary_in_path(), simd_caches_destroy_all(), symbol_cache_insert(), symbol_cache_lookup(), symbol_cache_resolve_batch(), timer_is_initialized(), timer_start(), timer_stop(), timer_system_destroy(), timer_system_init(), and webrtc_create_peer_connection().

lifecycle_reset()

bool lifecycle_reset

(

lifecycle_t *

lc

)

Reset initialized module: INITIALIZED → UNINITIALIZED.

Parameters

lc	lifecycle state (may include sync_type and sync pointer)

Returns

true if THIS caller should do reset work

false if not INITIALIZED or in DEAD state

Allows re-initialization after reset (like shutdown, but keeps sync primitives). If lc->sync_type != SYNC_NONE, destroys the sync primitive (will be recreated on next init). Used for modules that support reset/reinit cycles (e.g., client crypto reconnect).

Definition at line 167 of file lifecycle.c.

                                      {
  if (lc == NULL) {
    log_dev("[lifecycle] reset: NULL lifecycle pointer");
    return false;
  }
 
  uint64_t expected = LIFECYCLE_INITIALIZED;
  if (!atomic_cas_u64(&lc->state, &expected, LIFECYCLE_UNINITIALIZED)) {
    log_dev("[lifecycle] reset: not in INITIALIZED state (current: %d)", expected);
    return false; // Not in INITIALIZED state
  }
 
  /* Winner: destroy sync primitive if configured (reset keeps same primitive) */
  if (lc->sync_type == LIFECYCLE_SYNC_MUTEX && lc->sync.mutex != NULL) {
    log_dev("[lifecycle] reset: destroying and resetting mutex");
    mutex_destroy(lc->sync.mutex);
  } else if (lc->sync_type == LIFECYCLE_SYNC_RWLOCK && lc->sync.rwlock != NULL) {
    log_dev("[lifecycle] reset: destroying and resetting rwlock");
    rwlock_destroy(lc->sync.rwlock);
  } else {
    log_dev("[lifecycle] reset: completed (no sync primitive, allows reinit)");
  }
 
  return true;
}

References atomic_cas_u64(), LIFECYCLE_INITIALIZED, LIFECYCLE_SYNC_MUTEX, LIFECYCLE_SYNC_RWLOCK, LIFECYCLE_UNINITIALIZED, log_dev, lifecycle_t::mutex, mutex_destroy(), lifecycle_t::rwlock, rwlock_destroy(), lifecycle_t::state, lifecycle_t::sync, and lifecycle_t::sync_type.

Referenced by client_crypto_init().

lifecycle_shutdown()

bool lifecycle_shutdown

(

lifecycle_t *

lc

)

Regular shutdown: INITIALIZED → UNINITIALIZED.

Parameters

lc	lifecycle state (may include sync_type and sync pointer)

Returns

true if THIS caller should do shutdown work

false if already UNINITIALIZED or DEAD

Allows re-initialization after shutdown (unlike shutdown_forever). If lc->sync_type != SYNC_NONE, destroys the sync primitive.

Definition at line 108 of file lifecycle.c.

                                         {
  if (lc == NULL) {
    lifecycle_log_dev("[lifecycle] shutdown: NULL lifecycle pointer");
    return false;
  }
  uint64_t expected = LIFECYCLE_INITIALIZED;
  if (!atomic_cas_u64(&lc->state, &expected, LIFECYCLE_UNINITIALIZED)) {
    lifecycle_log_dev("[lifecycle] shutdown: not in INITIALIZED state (current: %d)", expected);
    return false; // Not initialized or in unexpected state
  }
 
  /* Winner: destroy sync primitive if configured */
  if (lc->sync_type == LIFECYCLE_SYNC_MUTEX && lc->sync.mutex != NULL) {
    lifecycle_log_dev("[lifecycle] shutdown: destroying mutex");
    mutex_destroy(lc->sync.mutex);
  } else if (lc->sync_type == LIFECYCLE_SYNC_RWLOCK && lc->sync.rwlock != NULL) {
    lifecycle_log_dev("[lifecycle] shutdown: destroying rwlock");
    rwlock_destroy(lc->sync.rwlock);
  } else {
    lifecycle_log_dev("[lifecycle] shutdown: completed (no sync primitive)");
  }
 
  return true;
}

References atomic_cas_u64(), atomic_store_int(), LIFECYCLE_INITIALIZED, lifecycle_log_dev, LIFECYCLE_SYNC_MUTEX, LIFECYCLE_SYNC_RWLOCK, LIFECYCLE_UNINITIALIZED, lifecycle_t::mutex, mutex_destroy(), lifecycle_t::rwlock, rwlock_destroy(), lifecycle_t::state, lifecycle_t::sync, and lifecycle_t::sync_type.

Referenced by acds_strings_destroy(), asciichat_instr_runtime_global_destroy(), asciichat_pcre2_cleanup_all(), audio_sender_finalize(), audio_terminate_portaudio_final(), buffer_pool_cleanup_global(), colorscheme_destroy(), crypto_client_cleanup(), lifecycle_shutdown_forever(), log_destroy(), log_search_destroy(), named_destroy(), named_init(), options_state_destroy(), options_state_init(), platform_cleanup_binary_path_cache(), simd_caches_destroy_all(), stats_cleanup(), symbol_cache_destroy(), and timer_system_destroy().

lifecycle_shutdown_forever()

bool lifecycle_shutdown_forever

(

lifecycle_t *

lc

)

Permanent shutdown: any non-DEAD → DEAD.

Parameters

lc	lifecycle state

Returns

true if module was INITIALIZED and caller should do shutdown work

false if already DEAD

Once DEAD, future init/init_once calls always return false. Spins if called while init_once is in progress (INITIALIZING state). Used for modules that must never be re-initialized.

Definition at line 133 of file lifecycle.c.

                                                 {
  if (lc == NULL) {
    log_dev("[lifecycle] shutdown_forever: NULL lifecycle pointer");
    return false;
  }
 
  uint64_t current;
  do {
    current = atomic_load_u64(&lc->state);
    if (current == LIFECYCLE_DEAD) {
      log_dev("[lifecycle] shutdown_forever: already DEAD");
      return false;
    }
    if (current == LIFECYCLE_INITIALIZING) {
      log_dev("[lifecycle] shutdown_forever: spinning on INITIALIZING");
    }
  } while (current == LIFECYCLE_INITIALIZING || !atomic_cas_u64(&lc->state, &current, LIFECYCLE_DEAD));
 
  log_dev("[lifecycle] shutdown_forever: transitioned to DEAD (was in state: %d)", current);
  return current == LIFECYCLE_INITIALIZED;
}

References atomic_cas_u64(), atomic_load_u64(), LIFECYCLE_DEAD, LIFECYCLE_INITIALIZED, LIFECYCLE_INITIALIZING, lifecycle_shutdown(), log_dev, and lifecycle_t::state.