asciichat_errno.h

Go to the documentation of this file.

#pragma once
 
/* Existing buffer budgets in bytes, including NUL for text storage. */
#define ASCIICHAT_ERROR_COUNTER_CAPACITY 256
 
/* Existing buffer budgets in bytes, including NUL for text storage. */
#define ASCIICHAT_BACKTRACE_FRAME_CAPACITY 32
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <libplatform/debug/backtrace.h>
#include "common/error_codes.h"
#include "common.h"
#include "log/log.h"
 
#define ASCIICHAT_ERRNO_MESSAGE_MAX 1024
#define ASCIICHAT_ERRNO_MAX_DEPTH 64
#define ASCIICHAT_ERRNO_MAX_THREADS 256
#define ASCIICHAT_ERRNO_MAX_FRAMES 1024
#define ASCIICHAT_ERRNO_HISTORY_SIZE 128

const char *asciichat_error_format(const char *message, asciichat_error_t code);

typedef struct {
  asciichat_error_t code;
  const char *file;
  int line;
  const char *function;
  char context_message[ASCIICHAT_ERRNO_MESSAGE_MAX];
  uint64_t timestamp;  
  uint64_t created_ns; 
  uint64_t error_id;
  uint64_t cause_id;
  uint64_t thread_id;
  uint64_t generation;
  int system_errno;
  int wsa_error;
  backtrace_t backtrace;
  bool has_system_error;
  bool has_wsa_error;
  bool message_truncated;
} asciichat_error_context_t;
 
typedef enum {
  ASCIICHAT_ERRNO_HANDLED,
  ASCIICHAT_ERRNO_DISMISSED,
  ASCIICHAT_ERRNO_THREAD_EXIT,
  ASCIICHAT_ERRNO_OVERFLOW,
} asciichat_errno_outcome_t;
 
typedef struct {
  asciichat_error_context_t context;
  uint64_t resolved_ns;
  asciichat_errno_outcome_t outcome;
} asciichat_errno_history_t;

typedef struct {
  uint64_t thread_id;
  uint64_t generation;
  uint64_t after_id;
  uint64_t previous_after_id;
} asciichat_errno_scope_t;
 
typedef struct {
  size_t total;
  size_t copied;
} asciichat_errno_snapshot_t;
 
typedef struct {
  uint64_t error_counts[ASCIICHAT_ERROR_COUNTER_CAPACITY];
  uint64_t total_errors;
  uint64_t last_error_time;
  asciichat_error_t last_error_code;
  uint64_t dropped_errors;
  uint64_t overwritten_history;
  size_t pending_errors;
  size_t registered_threads;
} asciichat_error_stats_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
asciichat_error_t errno_set(asciichat_error_t code, const char *file, int line, const char *function,
                            const char *message);
asciichat_error_t errno_set_with_message(asciichat_error_t code, const char *file, int line, const char *function,
                                         const char *format, ...);
asciichat_error_t errno_set_with_system_error(asciichat_error_t code, const char *file, int line, const char *function,
                                              int sys_errno);
asciichat_error_t errno_set_with_system_error_and_message(asciichat_error_t code, const char *file, int line,
                                                          const char *function, int sys_errno, const char *format, ...);
asciichat_error_t errno_set_with_wsa_error(asciichat_error_t code, const char *file, int line, const char *function,
                                           int wsa_error);
 
// Arguments evaluate once. Capture errno before evaluating message arguments.
#define SET_ERRNO(code, ...) errno_set_with_message((code), __FILE__, __LINE__, __func__, __VA_ARGS__)
#define SET_ERRNO_SYS(code, ...)                                                                                       \
  ({                                                                                                                   \
    int _asciichat_saved_errno = platform_get_last_error();                                                            \
    errno_set_with_system_error_and_message((code), __FILE__, __LINE__, __func__, _asciichat_saved_errno,              \
                                            __VA_ARGS__);                                                              \
  })
 
bool errno_has(asciichat_error_context_t *context);
bool errno_has_thread_error(uint64_t thread_id, asciichat_error_context_t *context);
bool errno_has_code(asciichat_error_t code);
bool errno_has_code_tid(uint64_t thread_id, asciichat_error_t code);
bool errno_peek_since(asciichat_errno_scope_t scope, asciichat_error_context_t *out);
asciichat_error_t errno_import(const asciichat_error_context_t *cause);
bool errno_has_code_since(asciichat_errno_scope_t scope, asciichat_error_t code);
bool errno_has_wsa_error(void);
bool errno_scope_is_clean(asciichat_errno_scope_t scope);
void errno_print_chain(uint64_t thread_id, uint64_t error_id);
asciichat_error_t errno_get(void);
asciichat_error_t errno_get_thread_error(uint64_t thread_id);
void errno_clear(void);
void errno_clear_all(void);
void errno_clear_thread_error(uint64_t thread_id);
void errno_clear_thread_errors(uint64_t thread_id);
bool errno_clear_if_top(uint64_t thread_id, uint64_t generation, uint64_t error_id);
bool errno_clear_if_current(uint64_t thread_id, uint64_t generation, uint64_t error_id);
// Observe a suboperation without severing its causal link to the caller.
asciichat_errno_scope_t errno_checkpoint(void);
asciichat_errno_scope_t errno_scope_begin(void);
void errno_scope_end(asciichat_errno_scope_t scope, asciichat_errno_outcome_t outcome);

asciichat_errno_snapshot_t errno_snapshot(uint64_t thread_id, asciichat_error_context_t *out, size_t capacity);
size_t errno_threads_snapshot(uint64_t *out, size_t capacity);
size_t errno_history_snapshot(asciichat_errno_history_t *out, size_t capacity);
size_t errno_title_snapshot(asciichat_error_context_t *latest);
void errno_notifications_enable(bool enabled);
void errno_notifications_pause(void);
bool errno_notifications_pending(void);
size_t errno_notifications_snapshot(asciichat_error_context_t *out, size_t capacity, uint64_t *dropped);
void errno_notifications_dismiss(uint64_t through_id);
bool errno_notifications_suppress(bool suppress);
void errno_print_stacks(void);
void errno_print_history(void);
void errno_print_hash_stats(void);
// Per-thread automatic logging suppression; storage is never suppressed.
void errno_suppress(bool suppress);
// Idempotent current-thread cleanup. Does not disable other threads.
void errno_destroy(void);
// Process shutdown, after producers and readers have joined.
void errno_shutdown(void);
void errno_request_exit(asciichat_error_t code);
asciichat_error_t errno_exit_code(void);
 
void asciichat_error_stats_init(void);
void asciichat_error_stats_record(asciichat_error_t code);
void asciichat_error_stats_print(void);
void asciichat_error_stats_reset(void);
asciichat_error_stats_t asciichat_error_stats_get(void);
void asciichat_fatal_with_context(asciichat_error_t code, const char *file, int line, const char *function,
                                  const char *format, ...);
void asciichat_print_error_context(const asciichat_error_context_t *context);
 
#define HAS_ERRNO(context) errno_has(context)
#define HAS_ERRNO_CODE(code) errno_has_code(code)
#define HAS_ERRNO_CODE_TID(tid, code) errno_has_code_tid((tid), (code))
#define HAS_ERRNO_CODE_SINCE(scope, code) errno_has_code_since((scope), (code))
#define GET_ERRNO() errno_get()
#define CLEAR_ERRNO() errno_clear()
#define CLEAR_ERRNO_ALL() errno_clear_all()
#define CLEAR_ERRNO_TID(tid) errno_clear_thread_error(tid)
#define CLEAR_ERRNO_ALL_TID(tid) errno_clear_thread_errors(tid)
#define PRINT_ERRNO_CONTEXT(context) asciichat_print_error_context(context)
#define LOG_ERRNO_IF_SET(message)                                                                                      \
  do {                                                                                                                 \
    asciichat_error_context_t _ctx;                                                                                    \
    if (HAS_ERRNO(&_ctx)) {                                                                                            \
      log_error("%s", (message));                                                                                      \
      errno_print_chain(_ctx.thread_id, _ctx.error_id);                                                                \
    }                                                                                                                  \
  } while (0)
#define LOG_ERRNO_IF_CODE(error_code, message)                                                                         \
  do {                                                                                                                 \
    asciichat_error_context_t _ctx;                                                                                    \
    if (HAS_ERRNO(&_ctx) && _ctx.code == (error_code)) {                                                               \
      log_error("%s", (message));                                                                                      \
      errno_print_chain(_ctx.thread_id, _ctx.error_id);                                                                \
    }                                                                                                                  \
  } while (0)
#define PRINT_ERRNO_IF_ERROR() LOG_ERRNO_IF_SET("Pending error")
#ifndef NDEBUG
#define ASSERT_NO_ERRNO_SINCE(scope)                                                                                   \
  do {                                                                                                                 \
    if (!errno_scope_is_clean(scope))                                                                                  \
      FATAL(ERROR_INVALID_STATE, "Successful operation left unresolved errors");                                       \
  } while (0)
#define ASSERT_NO_ERRNO()                                                                                              \
  do {                                                                                                                 \
    asciichat_error_context_t _ctx;                                                                                    \
    if (HAS_ERRNO(&_ctx)) {                                                                                            \
      asciichat_print_error_context(&_ctx);                                                                            \
      FATAL(_ctx.code, "Unresolved error at operation boundary");                                                      \
    }                                                                                                                  \
  } while (0)
#else
#define ASSERT_NO_ERRNO_SINCE(scope) ((void)(scope))
#define ASSERT_NO_ERRNO() ((void)0)
#endif
 
#ifdef __cplusplus
}
#endif