errno.c

Go to the documentation of this file.

#include <ascii-chat/debug/errno.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/options/options.h>
#include <libplatform/thread.h>
#include <libplatform/cond.h>
#include <libplatform/atomic.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/debug/debug_helpers.h>
 
static atomic_t g_debug_errno_signal = {0};
static atomic_t g_debug_errno_exiting = {0};
static atomic_t g_debug_errno_cleaning = {0};
static platform_thread_t g_debug_errno_thread;
static mutex_t g_debug_errno_mutex;
static cond_t g_debug_errno_condition;
static bool g_debug_errno_initialized;
static bool g_debug_errno_started;
static uint64_t g_debug_errno_errno_deadline;
 
asciichat_error_t debug_errno_init(void) {
  if (g_debug_errno_initialized)
    return ASCIICHAT_OK;
  if (mutex_init(&g_debug_errno_mutex, "debug_errno") != 0)
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize diagnostics mutex");
  if (cond_init(&g_debug_errno_condition, "debug_errno") != 0) {
    mutex_destroy(&g_debug_errno_mutex);
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize diagnostics condition");
  }
  g_debug_errno_initialized = true;
  atomic_store_bool_impl(&g_debug_errno_cleaning, false);
  return ASCIICHAT_OK;
}
static void debug_errno_print_errno(void) {
  log_info("Errno stacks:");
  errno_print_stacks();
  errno_print_history();
  errno_print_hash_stats();
}
void debug_errno_print(void) {
  debug_errno_print_errno();
}
void debug_errno_print_delayed(uint64_t delay) {
  if (!g_debug_errno_initialized)
    return;
  debug_report_schedule(&g_debug_errno_mutex, &g_debug_errno_condition, &g_debug_errno_errno_deadline, delay);
}
void debug_errno_trigger_print(void) {
  // Do not signal a condition variable or invoke diagnostic hooks in a signal
  // handler. The worker checks this flag at most 100ms after its next wakeup.
  atomic_store_bool_impl(&g_debug_errno_signal, true);
}
bool debug_errno_is_cleanup_in_progress(void) {
  return atomic_load_bool_impl(&g_debug_errno_cleaning);
}
void debug_errno_poll(void) {
  if (!g_debug_errno_initialized)
    return;
  uint64_t now = time_get_ns();
  bool all = atomic_exchange_bool_impl(&g_debug_errno_signal, false);
  mutex_lock(&g_debug_errno_mutex);
  bool errors = g_debug_errno_errno_deadline && now >= g_debug_errno_errno_deadline;
  if (errors)
    g_debug_errno_errno_deadline = 0;
  mutex_unlock(&g_debug_errno_mutex);
  if (all || errors)
    debug_errno_print_errno();
}
#ifndef EMSCRIPTEN_BUILD
static void *debug_errno_worker(void *unused) {
  (void)unused;
  while (!atomic_load_bool_impl(&g_debug_errno_exiting)) {
    debug_errno_poll();
    mutex_lock(&g_debug_errno_mutex);
    uint64_t now = time_get_ns();
    uint64_t wait = 100 * NS_PER_MS_INT;
    uint64_t deadlines[] = {g_debug_errno_errno_deadline};
    for (size_t i = 0; i < sizeof(deadlines) / sizeof(deadlines[0]); ++i)
      if (deadlines[i]) {
        uint64_t remaining = deadlines[i] > now ? deadlines[i] - now : 1;
        if (remaining < wait)
          wait = remaining;
      }
    if (!atomic_load_bool_impl(&g_debug_errno_exiting))
      cond_timedwait(&g_debug_errno_condition, &g_debug_errno_mutex, wait);
    mutex_unlock(&g_debug_errno_mutex);
  }
  return NULL;
}
#endif
asciichat_error_t debug_errno_start_thread(void) {
  if (g_debug_errno_started)
    return ASCIICHAT_OK;
  asciichat_error_t result = debug_errno_init();
  if (result != ASCIICHAT_OK)
    return result;
  atomic_store_bool_impl(&g_debug_errno_exiting, false);
  atomic_store_bool_impl(&g_debug_errno_cleaning, false);
  options_t *opts = options_get();
  if (opts) {
    if (IS_OPTION_EXPLICIT(debug_errno_stacks_time, opts))
      debug_errno_print_delayed((uint64_t)(opts->debug_errno_stacks_time * NS_PER_SEC_INT));
  }
#ifndef EMSCRIPTEN_BUILD
  if (platform_thread_create(&g_debug_errno_thread, "debug_errno", debug_errno_worker, NULL) != 0)
    return SET_ERRNO(ERROR_THREAD, "Cannot start diagnostics worker");
#endif
  g_debug_errno_started = true;
  return ASCIICHAT_OK;
}
void debug_errno_cleanup_thread(void) {
  if (!g_debug_errno_started)
    return;
  atomic_store_bool_impl(&g_debug_errno_cleaning, true);
  mutex_lock(&g_debug_errno_mutex);
  atomic_store_bool_impl(&g_debug_errno_exiting, true);
  cond_signal(&g_debug_errno_condition);
  mutex_unlock(&g_debug_errno_mutex);
#ifndef EMSCRIPTEN_BUILD
  // Join fully: diagnostic data must not be destroyed while a reader is alive.
  if (thread_join(&g_debug_errno_thread, NULL) != 0)
    FATAL(ERROR_THREAD, "Cannot join diagnostics worker");
#endif
  g_debug_errno_started = false;
}
void debug_errno_destroy(void) {
  debug_errno_cleanup_thread();
  if (g_debug_errno_initialized) {
    cond_destroy(&g_debug_errno_condition);
    mutex_destroy(&g_debug_errno_mutex);
    g_debug_errno_initialized = false;
    atomic_store_bool_impl(&g_debug_errno_signal, false);
    g_debug_errno_errno_deadline = 0;
  }
}