fatal-error.c

#include "main-header.h"
#include "loader-api.h"
#include "constants.h"
#include "led.h"
#include "multiram.h"
 
/* These are volatile to try and prevent the compiler/linker optimising them
 * away as the variables never actually get used.  If the debugger won't show the
 * values of the variables, make them global my moving their declaration outside
 * of this function. */
static volatile uint32_t r0;
static volatile uint32_t r1;
static volatile uint32_t r2;
static volatile uint32_t r3;
static volatile uint32_t r12;
static volatile uint32_t lr;    /* Link register. */
static volatile uint32_t pc;    /* Program counter. */
static volatile uint32_t psr;   /* Program status register. */
 
static void stdHandler(uint32_t *pulFaultStackAddress)  __attribute__((naked, no_instrument_function));
 
static char fatalerrorbuf[512];
void fatal_error(const char *format, ...) {
  char *buf;
  va_list args;
 
  printf("Fatal error handler invoked\r\n");
  buf = (char *)&fatalerrorbuf;
  va_start(args, format);
  vsnprintf(buf, 511, format, args);
  va_end(args);
 
  void *padr = constants()->last_return_address;
  void *dadr = constants()->failing_address;
  int user = (int)constants()->in_user_app;
  long z = mculib_get_seconds_since_boot();
 
  led_indicate(LED_FATALERROR);
  for (;;) {
    printf("FATAL ERROR: %s @ %p (failing address: %p) (usermode:%i)\r\n", buf, padr, dadr, user);
    long l = mculib_get_seconds_since_boot();
    while (l == mculib_get_seconds_since_boot()) {
    }
    if ((mculib_get_seconds_since_boot() - z) > 10) {
      break;
    }
  }
  constants_validate();
  reboot_hard();
  stdHandler(NULL); // keeps gcc happy (function is used)
}
 
void prvGetRegistersFromStack(uint32_t *pulFaultStackAddress) {
  if (!is_stack(pulFaultStackAddress)) {
    r0 = 0;
    r1 = 0;
    r2 = 0;
    r3 = 0;
    r12 = 0;
    lr = 0xFFFFFFFF;
    pc = 0xFFFFFFFF;
    psr = 0;
    return;
  }
  r0 = pulFaultStackAddress[0];
  r1 = pulFaultStackAddress[1];
  r2 = pulFaultStackAddress[2];
  r3 = pulFaultStackAddress[3];
 
  r12 = pulFaultStackAddress[4];
  lr = pulFaultStackAddress[5];
  pc = pulFaultStackAddress[6];
  psr = pulFaultStackAddress[7];
}
 
static void printRegisters() {
  printf("r0:  %p\r\n", r0);
  printf("r1:  %p\r\n", r1);
  printf("r2:  %p\r\n", r2);
  printf("r3:  %p\r\n", r3);
  printf("r12: %p\r\n", r12);
  printf("lr:  %p\r\n", lr);
  printf("pc:  %p\r\n", pc);
  printf("psr: %p\r\n", psr);
  printf("fct: %p\r\n", constants()->last_return_address);
}
 
 
static void stdHandler(uint32_t *pulFaultStackAddress) {
  if (!is_stack(pulFaultStackAddress)) {
    fatal_error("hardfault, no stack");
  }
  prvGetRegistersFromStack(pulFaultStackAddress);
  printf("Vector: %p\r\n", *((uint32_t *)0xE000ED08));
  constants()->CFSR = *(uint32_t *)0xE000ED28;
  constants()->SHCSR = *((uint32_t *)0xE000ED24);
  constants()->MMFAR = *((uint32_t *)0xE000ED34);
  constants()->HFSR = *((uint32_t *)0xE000ED2C);
  constants()->BFAR = *((uint32_t *)0xE000ED38);
  printf("CFSR : %p\r\n", constants()->CFSR); // ufsr, mmfsr, bfsr
  printf("SHCSR: %p\r\n", constants()->SHCSR);
  printf("MMFAR: %p\r\n", constants()->MMFAR);
  printf("HFSR : %p\r\n", constants()->HFSR);
  printf("BFAR : %p\r\n", constants()->BFAR);
  printRegisters();
  constants()->last_return_address = (void *)pc;
  constants()->failing_address = (void *)r3;
  fatal_error("hardfault");
}
void UsageFault_Handler() __attribute__((no_instrument_function));
void BusFault_Handler() __attribute__((no_instrument_function));
void MemManage_Handler() __attribute__((no_instrument_function));
void HardFault_Handler() __attribute__((naked, no_instrument_function));
 
void UsageFault_Handler() {
  fatal_error("eeeeks usagefault");
}
 
void BusFault_Handler() {
  fatal_error("busfault");
}
void MemManage_Handler() {
  fatal_error("memmanagefault");
}
 
void HardFault_Handler() {
#ifdef __unix__
  printf("Hardfault in posix???\n");
#else
  __asm volatile
  (
    " tst lr, #4                                                \n"
    " ite eq                                                    \n"
    " mrseq r0, msp                                             \n"
    " mrsne r0, psp                                             \n"
    " ldr r1, [r0, #24]                                         \n"
    " ldr r2, handler2_address_const                            \n"
    " bx r2                                                     \n"
    " ldr r1, [r0, #24]                                         \n"
    " handler2_address_const: .word stdHandler    \n"
  );
#endif
}