ra8_crashlog.c

Go to the documentation of this file.

 
#include "ra8_crashlog.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_crashlog_internal.h"
#include "ra8_exception.h"

typedef enum : uint32_t {
  k_ra8_crashlog_crc_poly = 0xEDB88320UL, 
  k_ra8_crashlog_crc_seed = 0xFFFFFFFFUL, 
} ra8_crashlog_crc_const_t;

typedef enum : uint8_t {
  k_ra8_crashlog_crc_bits = 8U, 
} ra8_crashlog_crc_iter_t;

typedef enum : uint32_t {
  k_ra8_crashlog_loops_max = 255U, 
} ra8_crashlog_loops_const_t;

#ifdef RA8_OFF_TARGET
static volatile ra8_crashlog_record_t s_ra8_crashlog_record;
#else
[[gnu::section(".noinit")]] static volatile ra8_crashlog_record_t s_ra8_crashlog_record;
#endif
 
static_assert(sizeof(ra8_crashlog_record_t) <= (size_t)k_ra8_crashlog_reserve_bytes,
              "ra8_crashlog_record_t must fit the linker NOINIT region (LENGTH(NOINIT))");

RA8_INTERNAL static uint32_t internal_crashlog_crc32(const volatile uint8_t* data, uint32_t len)
{
  if (data == nullptr) {
    return 0U;
  }
  uint32_t crc = (uint32_t)k_ra8_crashlog_crc_seed;
  for (uint32_t i = 0U; i < len; i++) {
    crc ^= (uint32_t)data[i];
    for (uint8_t bit = 0U; bit < (uint8_t)k_ra8_crashlog_crc_bits; bit++) {
      const uint32_t mask = 0U - (crc & 1U);
      crc                 = (crc >> 1U) ^ ((uint32_t)k_ra8_crashlog_crc_poly & mask);
    }
  }
  return crc ^ (uint32_t)k_ra8_crashlog_crc_seed;
}

RA8_INTERNAL static uint32_t internal_crashlog_payload_crc(void)
{
  const volatile uint8_t* base = (const volatile uint8_t*)&s_ra8_crashlog_record;
  const uint32_t          off  = (uint32_t)offsetof(ra8_crashlog_record_t, boot_loops);
  return internal_crashlog_crc32(&base[off], (uint32_t)sizeof(s_ra8_crashlog_record) - off);
}

RA8_INTERNAL static bool internal_crashlog_is_valid(void)
{
  return (s_ra8_crashlog_record.magic == (uint32_t)k_ra8_crashlog_magic_valid) &&
         (internal_crashlog_payload_crc() == s_ra8_crashlog_record.crc);
}

void ra8_crashlog_install(void)
{
  ra8_exception_set_persist_hook(&ra8_crashlog_record_fault);
}

void ra8_crashlog_record_fault(const volatile ra8_exception_last_t* decoded)
{
  if (decoded == nullptr) {
    return;
  }
  /* Carry the prior crash count forward only if the existing record still
   * validates; a cold-boot / corrupted record restarts the count at 1. */
  uint32_t next = 1U;
  if (internal_crashlog_is_valid()) {
    const uint32_t prior = s_ra8_crashlog_record.boot_loops;
    next = (prior < (uint32_t)k_ra8_crashlog_loops_max) ? (prior + 1U)
                                                        : (uint32_t)k_ra8_crashlog_loops_max;
  }
  s_ra8_crashlog_record.magic      = 0U; /* invalidate for the write window */
  s_ra8_crashlog_record.boot_loops = next;
  s_ra8_crashlog_record.fault      = *decoded;
  s_ra8_crashlog_record.crc        = internal_crashlog_payload_crc();
  s_ra8_crashlog_record.magic      = (uint32_t)k_ra8_crashlog_magic_valid; /* validate LAST */
}

bool ra8_crashlog_peek(ra8_crashlog_record_t* out)
{
  if (out == nullptr) {
    return false;
  }
  if (!internal_crashlog_is_valid()) {
    return false;
  }
  *out = s_ra8_crashlog_record;
  return true;
}

void ra8_crashlog_claim(void)
{
  s_ra8_crashlog_record.magic      = 0U;
  s_ra8_crashlog_record.crc        = 0U;
  s_ra8_crashlog_record.boot_loops = 0U;
}

bool ra8_crashlog_safe_mode_requested(void)
{
  ra8_crashlog_record_t rec;
  if (!ra8_crashlog_peek(&rec)) {
    return false;
  }
  return rec.boot_loops > (uint32_t)k_ra8_crashlog_loop_threshold;
}
 
#ifdef RA8_OFF_TARGET
volatile ra8_crashlog_record_t* ra8_crashlog_test_record(void)
{
  return &s_ra8_crashlog_record;
}

void ra8_crashlog_test_wipe(void)
{
  volatile uint8_t* p = (volatile uint8_t*)&s_ra8_crashlog_record;
  for (uint32_t i = 0U; i < (uint32_t)sizeof(s_ra8_crashlog_record); i++) {
    p[i] = 0U;
  }
}
#endif /* RA8_OFF_TARGET */