ra8_esp_hosted_log.c

Go to the documentation of this file.

 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
 
#include "esp_log.h"
#include "ra8_attributes.h"
#include "ra8_esp_hosted_fmt_internal.h"
#include "ra8_esp_hosted_log_internal.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_esp_hosted_rtos_internal.h"
#include "ra8_log.h"

typedef enum : uint16_t {
  k_ra8_esp_hosted_log_line_max = 160U,
  k_ra8_esp_hosted_log_dump_bytes = 32U,
  k_ra8_esp_hosted_log_dump_cost = 3U,
} ra8_esp_hosted_log_bound_t;

static int s_ra8_esp_hosted_log_level = (int)ESP_LOG_INFO;

static const char* const s_ra8_esp_hosted_log_tag = "C6LINK";

RA8_INTERNAL
static void internal_emit(int level, const char* tag, const char* line)
{
  if (level <= (int)ESP_LOG_ERROR) {
    ra8_log_error(tag, line);
  } else if (level == (int)ESP_LOG_WARN) {
    ra8_log_warn(tag, line);
  } else if (level == (int)ESP_LOG_INFO) {
    ra8_log_info(tag, line);
  } else {
    ra8_log_debug(tag, line);
  }
}

RA8_PRIV
bool priv_ra8_esp_hosted_log_accepts(int level)
{
  return (level > (int)ESP_LOG_NONE) && (level <= s_ra8_esp_hosted_log_level);
}

RA8_PRIV
void priv_ra8_esp_hosted_log_vwrite(int level, const char* tag, const char* fmt, va_list ap)
{
  if (!priv_ra8_esp_hosted_log_accepts(level) || (fmt == nullptr)) {
    return;
  }
 
  char line[(uint32_t)k_ra8_esp_hosted_log_line_max] = {};
  (void)priv_ra8_esp_hosted_fmt_vformat(line, (uint32_t)sizeof(line), fmt, ap);
  internal_emit(level, (tag == nullptr) ? s_ra8_esp_hosted_log_tag : tag, line);
}

void ra8_esp_hosted_log_write(int level, const char* tag, const char* fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  priv_ra8_esp_hosted_log_vwrite(level, tag, fmt, ap);
  va_end(ap);
}

void ra8_esp_hosted_log_hexdump(int level, const char* tag, const void* buf, uint32_t len)
{
  if (!priv_ra8_esp_hosted_log_accepts(level) || (buf == nullptr) || (len == 0U)) {
    return;
  }
 
  const uint8_t* bytes = (const uint8_t*)buf;
  uint32_t       shown = len;
  if (shown > (uint32_t)k_ra8_esp_hosted_log_dump_bytes) {
    shown = (uint32_t)k_ra8_esp_hosted_log_dump_bytes;
  }
 
  char     line[(uint32_t)k_ra8_esp_hosted_log_line_max] = {};
  uint32_t pos                                           = 0U;
  for (uint32_t i = 0U; i < shown; i++) {
    char          nibbles[(uint32_t)k_ra8_esp_hosted_fmt_digits_max + 2U] = {};
    const uint8_t digits = priv_ra8_esp_hosted_fmt_utoa(nibbles,
                                                        (uint64_t)bytes[i],
                                                        (uint8_t)k_ra8_esp_hosted_log_dump_radix,
                                                        false);
    if ((pos + (uint32_t)k_ra8_esp_hosted_log_dump_cost) >= sizeof(line)) {
      break;
    }
    if (digits < (uint8_t)k_ra8_esp_hosted_log_dump_nibbles) {
      line[pos] = '0';
      pos++;
    }
    for (uint8_t d = 0U; d < digits; d++) {
      line[pos] = nibbles[d];
      pos++;
    }
    line[pos] = ' ';
    pos++;
  }
  line[pos] = '\0';
 
  internal_emit(level, (tag == nullptr) ? s_ra8_esp_hosted_log_tag : tag, line);
}

void ra8_esp_hosted_log_level_set(const char* tag, int level)
{
  (void)tag;
  int clamped = level;
  if (clamped < (int)ESP_LOG_NONE) {
    clamped = (int)ESP_LOG_NONE;
  }
  if (clamped > (int)ESP_LOG_VERBOSE) {
    clamped = (int)ESP_LOG_VERBOSE;
  }
  s_ra8_esp_hosted_log_level = clamped;
}

RA8_PRIV
int priv_ra8_esp_hosted_log_level_get(void)
{
  return s_ra8_esp_hosted_log_level;
}

void ra8_esp_hosted_log_fatal(const char* tag, const char* expr, int code)
{
  const char* safe_tag = (tag == nullptr) ? s_ra8_esp_hosted_log_tag : tag;
  ra8_esp_hosted_log_write((int)ESP_LOG_ERROR,
                           safe_tag,
                           "fatal: %s -> %d",
                           (expr == nullptr) ? "(expr)" : expr,
                           code);
  /* GCOVR_EXCL_START -- a park loop no host input can leave; entering it in
     a unit test would hang the suite rather than report anything. */
  while (true) {
#ifndef RA8_OFF_TARGET
    __asm__ volatile("wfi");
#endif
  }
  /* GCOVR_EXCL_STOP */
}

void ra8_esp_hosted_mem_dump(const char* label)
{
  uint32_t available = 0U;
  uint32_t fragments = 0U;
  priv_ra8_esp_hosted_rtos_pool_stats(&available, &fragments);
  ra8_esp_hosted_log_write((int)ESP_LOG_INFO,
                           s_ra8_esp_hosted_log_tag,
                           "%s: pool free %u bytes in %u fragments",
                           (label == nullptr) ? "(unnamed)" : label,
                           (unsigned int)available,
                           (unsigned int)fragments);
}

void ra8_esp_hosted_alloc_failed(const char* func, size_t bytes)
{
  ra8_esp_hosted_log_write((int)ESP_LOG_ERROR,
                           s_ra8_esp_hosted_log_tag,
                           "%s: pool cannot serve %zu bytes",
                           (func == nullptr) ? "(unnamed)" : func,
                           bytes);
}