errors.c File Reference

#include "serene/rt/errors.h"
#include <stdio.h>
#include "serene/rt/context.h"
#include "serene/utils.h"
#include "serene/utils/srn_dbg_sym.h"

Include dependency graph for errors.c:

Go to the source code of this file.

Functions
static const char *	srn_error_tag_name (srn_error_tag_t tag)
char *	srn_error_to_string (const srn_context_t *ctx, const srn_error_t *err)
	Format err as a newly allocated string of the form [TAG]: msg, allocated in ctx.
void	srn_error_trace_push (const srn_context_t *ctx, srn_error_t *err, void *addr)
	Append a return address to the trace of a runtime-layer error.
srn_error_t *	srn_errors_make (const srn_context_t *ctx, srn_error_tag_t tag, const char *msg, void *caller)
	Build an error in ctx's memory, tagged tag and carrying msg.
srn_error_t *	srn_errors_from (const srn_context_t *ctx, const srn_error_t *src, void *caller)
	Build an error in ctx's memory that carries the layer, tag, message and payload of src, with a trace of its own that starts at caller.
void *	srn_errors_fail (const srn_context_t *ctx, size_t size, size_t alignment, srn_error_tag_t tag, const char *msg, void *caller)
	Allocate a size/alignment value in ctx, set its ERROR_HEADER (the first member, srn_error_t *maybe_error) to a fresh error, and return it.

Function Documentation

srn_error_tag_name()

const char * srn_error_tag_name ( srn_error_tag_t tag )

static

Definition at line 36 of file errors.c.

                                                           {
  switch (tag) {
  case ABSURD:
    return "ABSURD";
  case NOT_IMPLEMENTED:
    return "NOT_IMPLEMENTED";
  case SEQ_LIMIT_REACHED:
    return "SEQ_LIMIT_REACHED";
  case AL_LIMIT_REACHED:
    return "AL_LIMIT_REACHED";
  case SM_BUFFER_ID_EXHAUSTED:
    return "SM_BUFFER_ID_EXHAUSTED";
  case INDEX_OUT_OF_BOUND:
    return "INDEX_OUT_OF_BOUND";
  case CORRUPTED_SEQ:
    return "CORRUPTED_SEQ";
  case CORRUPTED_ARRAY_LIST:
    return "CORRUPTED_ARRAY_LIST";
  case FAILED_TO_ADD_MODULE:
    return "FAILED_TO_ADD_MODULE";
  case JIT_IR_PARSE_FAILED:
    return "JIT_IR_PARSE_FAILED";
  case JIT_SYMBOL_NOT_FOUND:
    return "JIT_SYMBOL_NOT_FOUND";
  case JIT_SYMBOL_ALREADY_DEFINED:
    return "JIT_SYMBOL_ALREADY_DEFINED";
  case EMPTY_NAMESPACE_NAME:
    return "EMPTY_NAMESPACE_NAME";
  case EMPTY_SYMBOL_NAME:
    return "EMPTY_SYMBOL_NAME";
  case STRING_LENGTH_LIMIT_EXCEEDED:
    return "STRING_LENGTH_LIMIT_EXCEEDED";
  case WRONG_RANGE:
    return "WRONG_RANGE";
  case EPOLL_INIT_FAILED:
    return "EPOLL_INIT_FAILED";
  case EPOLL_EVENT_FD_FAILED:
    return "EPOLL_EVENT_FD_FAILED";
  case EPOLL_FAILED_TO_ADD_FD:
    return "EPOLL_FAILED_TO_ADD_FD";
  case CONNECTION_REFUSED:
    return "CONNECTION_REFUSED";
  case CONNECTION_RESET:
    return "CONNECTION_RESET";
  case CONNECTION_ABORTED:
    return "CONNECTION_ABORTED";
  case BROKEN_PIPE:
    return "BROKEN_PIPE";
  case BAD_DESCRIPTOR:
    return "BAD_DESCRIPTOR";
  case TIMED_OUT:
    return "TIMED_OUT";
  case CANCELED:
    return "CANCELED";
  case NOT_CONNECTED:
    return "NOT_CONNECTED";
  case ADDRESS_IN_USE:
    return "ADDRESS_IN_USE";
  case HOST_UNREACHABLE:
    return "HOST_UNREACHABLE";
  case NETWORK_UNREACHABLE:
    return "NETWORK_UNREACHABLE";
  case MESSAGE_TOO_LONG:
    return "MESSAGE_TOO_LONG";
  case TOO_MANY_OPEN_FILES:
    return "TOO_MANY_OPEN_FILES";
  case PERMISSION_DENIED:
    return "PERMISSION_DENIED";
  case OUT_OF_MEMORY:
    return "OUT_OF_MEMORY";
  case NOT_FOUND:
    return "NOT_FOUND";
  case ALREADY_EXISTS:
    return "ALREADY_EXISTS";
  case IS_A_DIRECTORY:
    return "IS_A_DIRECTORY";
  case NOT_A_DIRECTORY:
    return "NOT_A_DIRECTORY";
  case NO_SPACE:
    return "NO_SPACE";
  case INVALID_ARGUMENT:
    return "INVALID_ARGUMENT";
  case CHANNEL_BUSY:
    return "CHANNEL_BUSY";
  case MEMORY_MAP_FAILED:
    return "MEMORY_MAP_FAILED";
  case IR_PARSE_ERROR:
    return "IR_PARSE_ERROR";
  case UNKNOWN_IO_ERROR:
    return "UNKNOWN_IO_ERROR";
  }
  return "UNKNOWN";
}

Here is the caller graph for this function:

srn_error_to_string()

char * srn_error_to_string ( const srn_context_t * ctx, const srn_error_t * err )

nodiscard

Format err as a newly allocated string of the form [TAG]: msg, allocated in ctx.

Returns [UNKNOWN]: <null> when err is null.

Definition at line 133 of file errors.c.

                                                                            {
  PANIC_IF_NULL(err);
  const char *tag = srn_error_tag_name(err->tag);
  const char *msg = err->msg != nullptr ? err->msg : "<null>";
 
  int header_len = snprintf(nullptr, 0, "[%s]: %s", tag, msg);
  PANIC_IF(header_len < 0, "srn_error_to_string: formatting failed");
 
  // Measure the trace lines before allocating so a single allocation covers
  // the whole string.
  int trace_len = 0;
  char sym[256];
  if (err->layer == SRN_ERR_RUNTIME_LAYER && err->as.frames != nullptr) {
    for (uint16_t i = 0; i < err->as.frames->count; i++) {
      void *addr       = err->as.frames->return_addrs[i];
      const char *name = srn_dbg_sym_name(addr, sym, sizeof(sym));
      if (name != nullptr) {
        trace_len += snprintf(nullptr, 0, "\n  #%u %p %s", i, addr, name);
      } else {
        trace_len += snprintf(nullptr, 0, "\n  #%u %p", i, addr);
      }
    }
  }
 
  size_t total = (size_t)header_len + (size_t)trace_len + 1;
  char *buf    = srn_allocate(ctx, total, alignof(char));
  PANIC_IF_NULL(buf);
 
  int written = snprintf(buf, total, "[%s]: %s", tag, msg);
  if (err->layer == SRN_ERR_RUNTIME_LAYER && err->as.frames != nullptr) {
    for (uint16_t i = 0; i < err->as.frames->count; i++) {
      void *addr       = err->as.frames->return_addrs[i];
      const char *name = srn_dbg_sym_name(addr, sym, sizeof(sym));
      if (name != nullptr) {
        written += snprintf(buf + written, total - (size_t)written, "\n  #%u %p %s", i, addr, name);
      } else {
        written += snprintf(buf + written, total - (size_t)written, "\n  #%u %p", i, addr);
      }
    }
  }
 
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_error_trace_push()

void srn_error_trace_push	(	const srn_context_t *	ctx,
		srn_error_t *	err,
		void *	addr )

Append a return address to the trace of a runtime-layer error.

Allocates frames from ctx on the first call. Silently does nothing when the trace is full or the error is not a runtime-layer error.

Definition at line 177 of file errors.c.

                                                                                  {
  if (err->layer != SRN_ERR_RUNTIME_LAYER) {
    return;
  }
 
  if (err->as.frames == nullptr) {
    err->as.frames = ALLOC(ctx, srn_trace_frames_t);
    PANIC_IF_NULL(err->as.frames);
    err->as.frames->count = 0;
  }
 
  if (err->as.frames->count >= TRACE_FRAME_DEPTH) {
    return;
  }
 
  err->as.frames->return_addrs[err->as.frames->count++] = addr;
}

Here is the caller graph for this function:

srn_errors_fail()

void * srn_errors_fail ( const srn_context_t * ctx, size_t size, size_t alignment, srn_error_tag_t tag, const char * msg, void * caller )

nodiscard

Allocate a size/alignment value in ctx, set its ERROR_HEADER (the first member, srn_error_t *maybe_error) to a fresh error, and return it.

The result is a valid fallible value whose HAS_ERROR is true. Use the FAIL macro, which fills in size/alignment from the target type.

Definition at line 224 of file errors.c.

  {
  // The ERROR_HEADER convention guarantees `srn_error_t *maybe_error` is the
  // first member of any fallible T, so offset 0 of the value is that pointer.
  // Allocate the value and set it to a fresh error; the caller checks it with
  // HAS_ERROR and never reads the other fields of an errored value.
  void *value = srn_allocate(ctx, size, alignment);
  PANIC_IF_NULL(value);
  *(srn_error_t **)value = srn_errors_make(ctx, tag, msg, caller);
  return value;
}

Here is the call graph for this function:

srn_errors_from()

srn_error_t * srn_errors_from	(	const srn_context_t *	ctx,
		const srn_error_t *	src,
		void *	caller )

Build an error in ctx's memory that carries the layer, tag, message and payload of src, with a trace of its own that starts at caller.

src is not written to, so this is the way to take a trace on an error that is shared or immutable, such as the reactor's static IO errors. A runtime layer src with frames has them copied, so the earlier trace is kept. The ERR_FROM macro supplies caller.

Definition at line 207 of file errors.c.

                                                                                             {
  PANIC_IF_NULL(src);
  srn_error_t *err = ALLOC_OR_PANIC(ctx, srn_error_t);
  err->layer       = src->layer;
  err->tag         = src->tag;
  err->msg         = src->msg;
  err->as          = src->as;
 
  if (src->layer == SRN_ERR_RUNTIME_LAYER && src->as.frames != nullptr) {
    err->as.frames  = ALLOC_OR_PANIC(ctx, srn_trace_frames_t);
    *err->as.frames = *src->as.frames;
  }
 
  srn_error_trace_push(ctx, err, caller);
  return err;
}

Here is the call graph for this function:

srn_errors_make()

srn_error_t * srn_errors_make	(	const srn_context_t *	ctx,
		srn_error_tag_t	tag,
		const char *	msg,
		void *	caller )

Build an error in ctx's memory, tagged tag and carrying msg.

caller is the return address of the call site (pass __builtin_return_address(0)) and is recorded as the first frame of the trace. The ERR macro supplies it automatically.

Definition at line 196 of file errors.c.

                                                                                              {
  srn_error_t *err = ALLOC(ctx, srn_error_t);
  PANIC_IF_NULL(err);
  err->layer     = SRN_ERR_RUNTIME_LAYER;
  err->tag       = tag;
  err->msg       = (char *)msg;
  err->as.frames = nullptr;
  srn_error_trace_push(ctx, err, caller);
  return err;
}

Here is the call graph for this function:

Here is the caller graph for this function: