common.c

Go to the documentation of this file.

 
// Platform abstraction includes memory sizing functions
#include <ascii-chat/common.h>
#include <ascii-chat/platform/system.h>
#include <ascii-chat/platform/init.h>
#include <ascii-chat/platform/memory.h>
#include <ascii-chat/log/logging.h>
#include <ascii-chat/buffer_pool.h>
#include <ascii-chat/video/palette.h>
#include <ascii-chat/video/simd/common.h>   // For simd_caches_destroy_all()
#include <ascii-chat/video/webcam/webcam.h> // For webcam_destroy()
#include <ascii-chat/options/colorscheme.h> // For colorscheme_destroy()
#include <ascii-chat/util/time.h>           // For timer_system_destroy()
#include <ascii-chat/util/pcre2.h>          // For asciichat_pcre2_cleanup_all()
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/crypto/known_hosts.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/options/rcu.h>       // For RCU-based options access
#include <ascii-chat/discovery/strings.h> // For RCU-based options access
#include <string.h>
#include <stdatomic.h>
#include <limits.h>
#include <stdlib.h>
 
#ifndef _WIN32
#include <pthread.h> // For PTHREAD_MUTEX_INITIALIZER on POSIX
#endif
 
/* ============================================================================
 * Global Variables for Early Argv Inspection
 * ============================================================================
 */
 
// These globals are used by lib/platform/terminal.c to detect --color flag
// during early execution phases (e.g., when --help is processed before
// options are fully parsed and published to RCU)
// ASCIICHAT_API is required for proper DLL export on Windows
ASCIICHAT_API int g_argc = 0;
ASCIICHAT_API char **g_argv = NULL;
 
// Global flags for --color detection (set during options_init before RCU is ready)
ASCIICHAT_API bool g_color_flag_passed = false; // Was --color explicitly passed in argv?
ASCIICHAT_API bool g_color_flag_value = false;  // What was the value of --color?
 
/* ============================================================================
 * Shutdown Check System Implementation
 * ============================================================================
 */
 
// Use atomic for thread-safe access to shutdown callback
#include <stdatomic.h>
static _Atomic(shutdown_check_fn) g_shutdown_callback = NULL;
 
void shutdown_register_callback(shutdown_check_fn callback) {
  atomic_store(&g_shutdown_callback, callback);
}
 
bool shutdown_is_requested(void) {
  shutdown_check_fn callback = atomic_load(&g_shutdown_callback);
  if (callback == NULL) {
    return false; // No callback registered, assume not shutting down
  }
  return callback();
}
 
/* ============================================================================
 * Shared Initialization Implementation
 * ============================================================================
 */
 
#if defined(DEBUG_MEMORY) && !defined(USE_MIMALLOC_DEBUG) && !defined(NDEBUG)
#include <ascii-chat/debug/memory.h>
#elif defined(USE_MIMALLOC_DEBUG) && !defined(NDEBUG)
static void print_mimalloc_stats(void);
#endif
 
// Guard to prevent multiple initialization of shared subsystems
// (can happen if asciichat_shared_init() is called multiple times during startup)
// But allow subsystem reinitialization for tests and other use cases
static bool g_shared_initialized = false;
 
#ifndef _WIN32
static void asciichat_common_atfork_child(void) {
  // Reset the shared initialization flag so asciichat_shared_init() will reinitialize subsystems
  g_shared_initialized = false;
}
 
__attribute__((constructor)) static void register_common_fork_handlers(void) {
  pthread_atfork(NULL, NULL, asciichat_common_atfork_child);
}
#endif
 
asciichat_error_t asciichat_shared_init(const char *log_file, bool is_client) {
  // Initialize shared subsystems BEFORE options_init()
  // This allows options_init() to use properly configured logging with colors
  //
  // NOTE: This function is called BEFORE options_init(), so we can't use GET_OPTION()
  // Palette config and quiet mode will be applied after options_init() is called
 
  // Only register initialization tracking once
  if (!g_shared_initialized) {
    // 1. TIMER SYSTEM - Initialize first so timing is available for everything else
    if (!timer_system_init()) {
      FATAL(ERROR_PLATFORM_INIT, "Failed to initialize timer system");
    }
 
    // 2. LOGGING - Initialize with provided log file
    // Force stderr for client-like modes when stdout is piped to keep stdout clean
    bool force_stderr = is_client && terminal_is_piped_output();
    // Use LOG_DEBUG by default; will be reconfigured after options_init()
    log_init(log_file, LOG_DEBUG, force_stderr, false /* don't use_mmap */);
 
    // 3. PLATFORM - Initialize platform-specific functionality (Winsock, etc)
    if (platform_init() != ASCIICHAT_OK) {
      FATAL(ERROR_PLATFORM_INIT, "Failed to initialize platform");
    }
 
    // 4. BUFFER POOL - Initialize global shared buffer pool
    buffer_pool_init_global();
 
    // Mark that we've initialized (prevents re-registration of subsystems)
    g_shared_initialized = true;
  }
 
  // NOTE: This library function does NOT register atexit() handlers.
  // Library code should not own the process lifecycle. The application
  // is responsible for calling atexit(asciichat_shared_destroy) if it
  // wants automatic cleanup on normal exit.
 
  return ASCIICHAT_OK;
}
 
void asciichat_shared_destroy(void) {
  // Guard against double cleanup (can be called explicitly + via atexit)
  static bool shutdown_done = false;
  if (shutdown_done) {
    return;
  }
  shutdown_done = true;
 
  // Cleanup in reverse order of initialization (LIFO)
  // This ensures dependencies are properly handled
 
  // 0. Stop background threads first (before any cleanup that might use them)
  // Terminal resize detection thread (Windows only, checks if active)
  extern void terminal_stop_resize_detection(void);
  terminal_stop_resize_detection();
 
#ifndef NDEBUG
  // Lock debug thread - must join before any lock cleanup
  extern void lock_debug_cleanup_thread(void);
  lock_debug_cleanup_thread();
 
  // Lock debug system - set initialized=false so mutex_lock uses mutex_lock_impl directly
  // This must happen after thread cleanup but before any subsystem that uses mutex_lock
  extern void lock_debug_destroy(void);
  lock_debug_destroy();
#endif
 
  // 1. Webcam - cleanup resources
  webcam_destroy();
 
  // 2. SIMD caches - cleanup CPU-specific caches
  simd_caches_destroy_all();
 
  // 3. Discovery service strings cache - cleanup session string cache
  acds_strings_destroy();
 
  // 4. Logging - in correct order (end first, then begin)
  log_shutdown_end();
  log_shutdown_begin();
 
  // 5. Known hosts - cleanup authentication state
  known_hosts_destroy();
 
  // 6. Options state - cleanup RCU-based options
  options_state_destroy();
 
  // 7. Buffer pool - cleanup global buffer pool
  buffer_pool_cleanup_global();
 
  // 8. Platform cleanup - restores terminal, cleans up platform resources
  // (includes symbol cache cleanup on Windows)
  platform_destroy();
 
  // 9. Keyboard - restore terminal settings (redundant with platform_destroy but safe)
  extern void keyboard_destroy(void);
  keyboard_destroy();
 
  // 10. Timer system - cleanup timers (may still log!)
  timer_system_destroy();
 
  // 11. Error context cleanup
  asciichat_errno_destroy();
 
  // 12. Logging cleanup - free log format buffers before memory report
  log_destroy();
 
  // 13. Memory stats (debug builds only) - runs with colors still available
  //     Note: PCRE2 singletons are ignored in the report (expected system allocations)
  //     Note: debug_memory_report() is also called manually during shutdown in server_main()
  //     The function is safe to call multiple times with polling-based locking
#if defined(USE_MIMALLOC_DEBUG) && !defined(NDEBUG)
  print_mimalloc_stats();
#endif
 
#if defined(DEBUG_MEMORY) && !defined(NDEBUG)
  debug_memory_report();
#endif
 
  // 14. Color cleanup - free compiled ANSI strings (AFTER memory report)
  log_cleanup_colors();
  colorscheme_destroy();
 
  // 15. PCRE2 - cleanup all regex singletons together
  asciichat_pcre2_cleanup_all();
}
 
#if defined(USE_MIMALLOC_DEBUG) && !defined(NDEBUG)
// Wrapper function for mi_stats_print to use with atexit()
// mi_stats_print takes a parameter, but atexit requires void(void)
static void print_mimalloc_stats(void) {
  // Skip memory report if an action flag was passed (for clean action output)
  // unless explicitly forced via ASCII_CHAT_MEMORY_DEBUG environment variable
  if (has_action_flag() && !SAFE_GETENV("ASCII_CHAT_MEMORY_DEBUG")) {
    return;
  }
  mi_stats_print(NULL); // NULL = print to stderr
}
#endif