andreika-git
/
rusefi
mirror of https://github.com/andreika-git/rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rusefi/firmware/controllers/core/error_handling.cpp

669 lines
19 KiB
C++
Raw Blame History

/**
* @file error_handling.cpp
*
* @date Apr 1, 2014
* @author Andrey Belomutskiy, (c) 2012-2020
*/
#include "pch.h"
#include "rusefi/efistringutil.h"
#include "os_util.h"
#include "backup_ram.h"
#include "error_handling_led.h"
#include "log_hard_fault.h"
#include "rusefi/critical_error.h"
/**
* Executes the BKPT instruction that causes the debugger to stop.
*/
#define bkpt() __asm volatile("BKPT #0\n")
// see strncpy man page
// this implementation helps avoiding following gcc error/warning:
// error: 'strncpy' output may be truncated copying xxx bytes from a string of length xxx
char *strlncpy(char *dest, const char *src, size_t size)
{
size_t i;
for (i = 0; (i < (size - 1)) && (src[i] != '\0'); i++)
dest[i] = src[i];
for ( ; i < size; i++)
dest[i] = '\0';
return dest;
}
static critical_msg_t warningBuffer;
static critical_msg_t criticalErrorMessageBuffer;
static critical_msg_t configErrorMessageBuffer; // recoverable configuration error, non-critical
bool hasCriticalFirmwareErrorFlag = false;
static bool hasConfigErrorFlag = false;
static bool hasReportFile = false;
// todo: revisit very questionable code!
// todo: reuse hasCriticalFirmwareErrorFlag? something?
bool isInHardFaultHandler = false;
const char *dbg_panic_file;
int dbg_panic_line;
// todo: need vararg version of 'firmwareError' to make this method vararg?
void efiCriticalError(const char *message) {
criticalError(message);
}
const char* getCriticalErrorMessage() {
return criticalErrorMessageBuffer;
}
bool hasConfigError() {
return hasConfigErrorFlag;
}
void clearConfigErrorMessage() {
hasConfigErrorFlag = false;
}
bool hasErrorReportFile() {
return hasReportFile;
}
const char* getConfigErrorMessageBuffer() {
return configErrorMessageBuffer;
}
#if EFI_PROD_CODE
#if EFI_BACKUP_SRAM
static backupErrorState lastBootError;
static uint32_t bootCount = 0;
#endif // EFI_BACKUP_SRAM
void errorHandlerInit() {
#if EFI_BACKUP_SRAM
/* copy error state from backup RAM and clear it in backup RAM.
* so few users can access previous error state and we should not care about who sohuld clear backup ram. */
auto sramState = getBackupSram();
memcpy(&lastBootError, &sramState->err, sizeof(backupErrorState));
memset(&sramState->err, 0x00, sizeof(sramState->err));
// Reset cookie so we don't report it again.
sramState->err.Cookie = ErrorCookie::None;
// Cookie can be some random value at first power on
// reset to None to avoid generating 'Unknown' fail report
if ((lastBootError.Cookie != ErrorCookie::FirmwareError) &&
(lastBootError.Cookie != ErrorCookie::HardFault) &&
(lastBootError.Cookie != ErrorCookie::ChibiOsPanic)) {
lastBootError.Cookie = ErrorCookie::None;
}
//bootcount
if (sramState->BootCountCookie != 0xdeadbeef) {
sramState->BootCountCookie = 0xdeadbeef;
sramState->BootCount = 0;
}
// save current bootcounter
bootCount = sramState->BootCount;
sramState->BootCount++;
if (engineConfiguration->rethrowHardFault) {
backupErrorState *err = &lastBootError;
if (err->Cookie == ErrorCookie::HardFault) {
criticalError("Last boot had hard fault type: %lx addr: %lx CSFR: %lx",
err->FaultType, err->FaultAddress, err->Csfr);
}
}
Reset_Cause_t cause = getMCUResetCause();
// if reset by watchdog, signal a fatal error
if ((cause == Reset_Cause_IWatchdog) || (cause == Reset_Cause_WWatchdog)) {
firmwareError(ObdCode::OBD_PCM_Processor_Fault, "Watchdog Reset detected! Check SD card for report file.");
}
#endif // EFI_PROD_CODE
// see https://github.com/rusefi/rusefi/wiki/Resilience
addConsoleAction("chibi_fault", [](){ chDbgCheck(0); } );
addConsoleAction("soft_fault", [](){ firmwareError(ObdCode::RUNTIME_CRITICAL_TEST_ERROR, "firmwareError: %d", getRusEfiVersion()); });
addConsoleAction("hard_fault", [](){ causeHardFault(); } );
}
bool errorHandlerIsStartFromError() {
#if EFI_BACKUP_SRAM
return (lastBootError.Cookie != ErrorCookie::None);
#else
return 0;
#endif
}
const char *errorCookieToName(ErrorCookie cookie)
{
switch (cookie) {
case ErrorCookie::None:
return "No error";
case ErrorCookie::FirmwareError:
return "firmware";
case ErrorCookie::HardFault:
return "HardFault";
case ErrorCookie::ChibiOsPanic:
return "ChibiOS panic";
}
return "Unknown";
}
#define printResetReason() \
PRINT("Reset Cause: %s", getMCUResetCause(getMCUResetCause()))
#define printErrorState() \
do { \
PRINT("Power cycle count: %lu", bootCount); \
\
if (cookie == ErrorCookie::None) { \
break; \
} \
\
PRINT("Last error type %s", errorCookieToName(err->Cookie)); \
\
switch (cookie) { \
case ErrorCookie::FirmwareError: \
{ \
PRINT("%s", err->msg); \
} \
break; \
case ErrorCookie::HardFault: \
{ \
PRINT("type: 0x%08lx addr: 0x%08lx CSFR: 0x%08lx", \
err->FaultType, err->FaultAddress, err->Csfr); \
\
auto ctx = &err->FaultCtx; \
PRINT("r0 0x%08lx", ctx->r0); \
PRINT("r1 0x%08lx", ctx->r1); \
PRINT("r2 0x%08lx", ctx->r2); \
PRINT("r3 0x%08lx", ctx->r3); \
PRINT("r12 0x%08lx", ctx->r12); \
PRINT("lr (thread) 0x%08lx", ctx->lr_thd); \
PRINT("pc 0x%08lx", ctx->pc); \
PRINT("xpsr 0x%08lx", ctx->xpsr); \
\
/* FPU registers - not very useful for debug */ \
if (0) { \
/* Print rest the context as a sequence of uintptr */ \
uintptr_t* data = reinterpret_cast<uintptr_t*>(&err->FaultCtx); \
for (size_t i = 8; i < sizeof(port_extctx) / sizeof(uintptr_t); i++) { \
PRINT("Fault ctx %d: 0x%08x", i, data[i]); \
} \
} \
} \
break; \
case ErrorCookie::ChibiOsPanic: \
{ \
PRINT("msg %s", err->msg); \
PRINT("file %s", err->file); \
PRINT("line %d", err->line); \
} \
break; \
default: \
/* No cookie stored or invalid cookie (ie, backup RAM contains random garbage) */ \
break; \
} \
} while(0)
#define printErrorStack() \
do { \
PRINT("SP 0x%08lx", err->sp); \
for (size_t i = 0; i < ERROR_STACK_DEPTH; i++) { \
PRINT(" 0x%08lx: 0x%08lx", err->sp - i * 4, err->stack[i]); \
} \
} while(0)
// TODO: reuse this code for writing crash report file
void errorHandlerShowBootReasonAndErrors() {
//this is console print
#define PRINT(...) efiPrintf(__VA_ARGS__)
printResetReason();
#if EFI_BACKUP_SRAM
backupErrorState *err = &lastBootError;
ErrorCookie cookie = err->Cookie;
printErrorState();
printErrorStack();
#endif // EFI_BACKUP_SRAM
#undef PRINT
}
#if EFI_FILE_LOGGING
#include "ff.h"
#define FAIL_REPORT_PREFIX "fail"
PUBLIC_API_WEAK void onBoardWriteErrorFile(FIL *) {
}
static const char *errorHandlerGetErrorName(ErrorCookie cookie)
{
switch (cookie) {
case ErrorCookie::None:
return "none";
case ErrorCookie::FirmwareError:
return "FWerror";
case ErrorCookie::HardFault:
return "HardFault";
case ErrorCookie::ChibiOsPanic:
return "OSpanic";
}
return "unknown";
}
bool needErrorReportFile = false;
void errorHandlerWriteReportFile(FIL *fd) {
#if EFI_BACKUP_SRAM
backupErrorState *err = &lastBootError;
ErrorCookie cookie = err->Cookie;
#else
ErrorCookie cookie = ErrorCookie::None;
#endif
if (cookie != ErrorCookie::None) {
needErrorReportFile = true;
}
auto cause = getMCUResetCause();
// TODO: should we also report Unknown?
if ((cause != Reset_Cause_NRST_Pin) && (cause != Reset_Cause_BOR) &&
(cause != Reset_Cause_POR) && (cause != Reset_Cause_Unknown)) {
// not an expected cause
needErrorReportFile = true;
}
if (needErrorReportFile) {
char fileName[_MAX_FILLER + 20];
memset(fd, 0, sizeof(FIL)); // clear the memory
//TODO: use date + time for file name?
#if EFI_BACKUP_SRAM
sprintf(fileName, "%05ld_%s_%s.txt",
bootCount, FAIL_REPORT_PREFIX, errorHandlerGetErrorName(cookie));
#else
sprintf(fileName, "last_%s_%s.txt",
FAIL_REPORT_PREFIX, errorHandlerGetErrorName(cookie));
#endif
FRESULT ret = f_open(fd, fileName, FA_CREATE_ALWAYS | FA_WRITE);
if (ret == FR_OK) {
//this is file print
#define PRINT(format, ...) f_printf(fd, format "\r\n", __VA_ARGS__)
printResetReason();
#if EFI_BACKUP_SRAM
printErrorState();
printErrorStack();
#endif // EFI_BACKUP_SRAM
f_printf(fd, "rusEFI v%d@%u", getRusEfiVersion(), /*do we have a working way to print 64 bit values?!*/(int)SIGNATURE_HASH);
// additional board-specific data
onBoardWriteErrorFile(fd);
// todo: figure out what else would be useful
f_close(fd);
enginePins.warningLedPin.setValue(1);
}
}
}
static int errorHandlerIsReportExist(ErrorCookie cookie) {
bool exist = false;
FRESULT fr; /* Return value */
DIR dj; /* Directory object */
FILINFO fno; /* File information */
TCHAR pattern[32];
sprintf(pattern, "*%s*", errorHandlerGetErrorName(cookie));
fr = f_findfirst(&dj, &fno, "", pattern);
exist = ((fr == FR_OK) && (fno.fname[0]));
f_closedir(&dj);
return exist;
}
int errorHandlerCheckReportFiles() {
hasReportFile =
(errorHandlerIsReportExist(ErrorCookie::FirmwareError) > 0) ||
(errorHandlerIsReportExist(ErrorCookie::HardFault) > 0) ||
(errorHandlerIsReportExist(ErrorCookie::ChibiOsPanic) > 0);
return hasReportFile;
}
static void errorHandlerDeleteTypedReport(ErrorCookie cookie) {
bool failed = false;
FRESULT fr; /* Return value */
DIR dj; /* Directory object */
FILINFO fno; /* File information */
TCHAR pattern[32];
sprintf(pattern, "*%s*", errorHandlerGetErrorName(cookie));
do {
fr = f_findfirst(&dj, &fno, "", pattern);
f_closedir(&dj);
if ((fr == FR_OK) && (fno.fname[0])) {
efiPrintf("deleting %s", fno.fname);
FRESULT ret = f_unlink(fno.fname);
if (ret != FR_OK) {
efiPrintf("Faield to delete %s: %d", fno.fname, ret);
failed = true;
} else {
efiPrintf("%s removed", fno.fname);
}
}
} while ((!failed) && (fr == FR_OK) && (fno.fname[0]));
}
void errorHandlerDeleteReports() {
errorHandlerDeleteTypedReport(ErrorCookie::FirmwareError);
errorHandlerDeleteTypedReport(ErrorCookie::HardFault);
errorHandlerDeleteTypedReport(ErrorCookie::ChibiOsPanic);
// update
errorHandlerCheckReportFiles();
}
#endif
#if EFI_BACKUP_SRAM
static void errorHandlerSaveStack(backupErrorState *err, uint32_t *sp)
{
err->sp = (uint32_t)sp;
for (size_t i = 0; i < ERROR_STACK_DEPTH; i++) {
// avoid optimizatio and usage of __builtin_memcpy
// to avoid "error: '__builtin_memcpy' reading 128 bytes from a region of size 4"
err->stack[i] = *(volatile uint32_t *)sp;
sp++;
}
}
#endif // EFI_BACKUP_SRAM
void logHardFault(uint32_t type, uintptr_t faultAddress, void* sp, port_extctx* ctx, uint32_t csfr) {
// todo: reuse hasCriticalFirmwareErrorFlag? something?
isInHardFaultHandler = true;
// Evidence first!
#if EFI_BACKUP_SRAM
auto bkpram = getBackupSram();
auto err = &bkpram->err;
if (err->Cookie == ErrorCookie::None) {
err->FaultType = type;
err->FaultAddress = faultAddress;
err->Csfr = csfr;
memcpy(&err->FaultCtx, ctx, sizeof(port_extctx));
err->Cookie = ErrorCookie::HardFault;
// copy stack last as it can be corrupted and cause another exeption
errorHandlerSaveStack(err, (uint32_t *)sp);
}
#endif // EFI_BACKUP_SRAM
// criticalShutdown() shutdown can cause cascaded fault.
// So we first save some valuable evidence and only after try to gracefully shutdown HW
criticalShutdown();
}
#endif /* EFI_PROD_CODE */
#if EFI_SIMULATOR || EFI_PROD_CODE
void chDbgPanic3(const char *msg, const char * file, int line) {
#if EFI_PROD_CODE
#if EFI_BACKUP_SRAM
// following is allocated on stack
// add some marker
uint32_t tmp = 0xfffffa11;
#endif
// Attempt to break in to the debugger, if attached
if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
{
bkpt();
}
#endif // EFI_PROD_CODE
#if EFI_BACKUP_SRAM
auto bkpram = getBackupSram();
auto err = &bkpram->err;
if (err->Cookie == ErrorCookie::None) {
strlncpy(err->file, file, efi::size(err->file));
err->line = line;
strlncpy(err->msg, msg, efi::size(err->msg));
err->Cookie = ErrorCookie::ChibiOsPanic;
// copy stack last as it can be corrupted and cause another exeption
uint32_t *sp = &tmp;
errorHandlerSaveStack(err, sp);
}
#endif // EFI_BACKUP_SRAM
if (hasOsPanicError())
return;
dbg_panic_file = file;
dbg_panic_line = line;
#if CH_DBG_SYSTEM_STATE_CHECK
ch0.dbg.panic_msg = msg;
#endif /* CH_DBG_SYSTEM_STATE_CHECK */
#if !EFI_PROD_CODE
printf("chDbgPanic3 %s %s%d", msg, file, line);
exit(-1);
#else // EFI_PROD_CODE
criticalError("assert fail %s %s:%d", msg, file, line);
// If on the main thread, longjmp back to the init process so we can keep USB alive
if (chThdGetSelfX()->threadId == 0) {
// Force unlock, since we may be throwing-under-lock
chSysUnconditionalUnlock();
// there was a port_disable in chSysHalt, reenable interrupts so USB works
port_enable();
__NO_RETURN void onAssertionFailure();
onAssertionFailure();
} else {
// Not the main thread.
// All hope is now lost.
// Reboot!
NVIC_SystemReset();
}
#endif // EFI_PROD_CODE
}
#endif /* EFI_SIMULATOR || EFI_PROD_CODE */
/**
* ObdCode::OBD_PCM_Processor_Fault is the general error code for now
*
* @returns TRUE in case there were warnings recently
*/
bool warning(ObdCode code, const char *fmt, ...) {
if (hasCriticalFirmwareErrorFlag) {
return true;
}
bool known = engine->engineState.warnings.isWarningNow(code);
// if known - just reset timer
engine->engineState.warnings.addWarningCode(code);
#if EFI_SIMULATOR || EFI_PROD_CODE
// we just had this same warning, let's not spam
if (known) {
return true;
}
// print Pxxxx (for standard OBD) or Cxxxx (for custom) prefix
size_t size = snprintf(warningBuffer, sizeof(warningBuffer), "%s%04d: ",
code < ObdCode::CUSTOM_NAN_ENGINE_LOAD ? "P" : "C", (int) code);
va_list ap;
va_start(ap, fmt);
chvsnprintf(warningBuffer + size, sizeof(warningBuffer) - size, fmt, ap);
va_end(ap);
efiPrintf("WARNING: %s", warningBuffer);
#else
printf("unit_test_warning: ");
va_list ap;
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
printf("\r\n");
#endif /* EFI_SIMULATOR || EFI_PROD_CODE */
return false;
}
#if EFI_CLOCK_LOCKS
uint32_t lastLockTime;
/**
* Maximum time before requesting lock and releasing lock at the end of critical section
*/
uint32_t maxLockedDuration = 0;
/**
* this depends on chdebug.h patch
#if CH_DBG_SYSTEM_STATE_CHECK == TRUE
-#define _dbg_enter_lock() (ch.dbg.lock_cnt = (cnt_t)1)
-#define _dbg_leave_lock() (ch.dbg.lock_cnt = (cnt_t)0)
+#define _dbg_enter_lock() {(ch.dbg.lock_cnt = (cnt_t)1); ON_LOCK_HOOK;}
+#define _dbg_leave_lock() {ON_UNLOCK_HOOK;(ch.dbg.lock_cnt = (cnt_t)0);}
#endif
*/
#endif /* EFI_CLOCK_LOCKS */
void onLockHook(void) {
#if ENABLE_PERF_TRACE
perfEventInstantGlobal(PE::GlobalLock);
#endif /* ENABLE_PERF_TRACE */
#if EFI_CLOCK_LOCKS
lastLockTime = getTimeNowLowerNt();
#endif /* EFI_CLOCK_LOCKS */
}
void onUnlockHook(void) {
#if EFI_CLOCK_LOCKS
uint32_t lockedDuration = getTimeNowLowerNt() - lastLockTime;
if (lockedDuration > maxLockedDuration) {
maxLockedDuration = lockedDuration;
}
// if (lockedDuration > 2800) {
// // un-comment this if you want a nice stop for a breakpoint
// maxLockedDuration = lockedDuration + 1;
// }
#endif /* EFI_CLOCK_LOCKS */
#if ENABLE_PERF_TRACE
perfEventInstantGlobal(PE::GlobalUnlock);
#endif /* ENABLE_PERF_TRACE */
}
#if EFI_SIMULATOR || EFI_UNIT_TEST
#include <stdexcept>
#endif
void configError(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
chvsnprintf(configErrorMessageBuffer, sizeof(configErrorMessageBuffer), fmt, ap);
va_end(ap);
hasConfigErrorFlag = true;
}
const char* getConfigErrorMessage() {
return configErrorMessageBuffer;
}
static void firmwareErrorV(ObdCode code, const char *fmt, va_list ap) {
#if EFI_PROD_CODE
#if EFI_BACKUP_SRAM
// following is allocated on stack
// add some marker
uint32_t tmp = 0xfaaaaa11;
#endif
if (hasCriticalFirmwareErrorFlag)
return;
hasCriticalFirmwareErrorFlag = true;
// construct error message
if (indexOf(fmt, '%') == -1) {
/**
* in case of simple error message let's reduce stack usage
* chvsnprintf could cause an overflow if we're already low
*/
strlncpy((char*) criticalErrorMessageBuffer, fmt, sizeof(criticalErrorMessageBuffer));
criticalErrorMessageBuffer[sizeof(criticalErrorMessageBuffer) - 1] = 0; // just to be sure
} else {
chvsnprintf(criticalErrorMessageBuffer, sizeof(criticalErrorMessageBuffer), fmt, ap);
}
int errorMessageSize = strlen((char*)criticalErrorMessageBuffer);
static char versionBuffer[32];
chsnprintf(versionBuffer, sizeof(versionBuffer), " %d@%s", getRusEfiVersion(), FIRMWARE_ID);
if (errorMessageSize + strlen(versionBuffer) < sizeof(criticalErrorMessageBuffer)) {
strcpy((char*)(criticalErrorMessageBuffer) + errorMessageSize, versionBuffer);
}
// Evidence first!
#if EFI_BACKUP_SRAM
auto bkpram = getBackupSram();
auto err = &bkpram->err;
if (err->Cookie == ErrorCookie::None) {
strlncpy(err->msg, criticalErrorMessageBuffer, sizeof(err->msg));
err->Cookie = ErrorCookie::FirmwareError;
// copy stack last as it can be corrupted and cause another exeption
uint32_t *sp = &tmp;
errorHandlerSaveStack(err, sp);
}
#endif // EFI_BACKUP_SRAM
#if EFI_ENGINE_CONTROL
getLimpManager()->fatalError();
#endif // EFI_ENGINE_CONTROL
engine->engineState.warnings.addWarningCode(code);
// criticalShutdown() shutdown can cause cascaded fault.
// So we first save some valuable evidence and only after try to gracefully shutdown HW
criticalShutdown();
enginePins.communicationLedPin.setValue(1, /*force*/true);
#else // EFI_PROD_CODE
// large buffer on stack is risky we better use normal memory
static char errorBuffer[200];
vsnprintf(errorBuffer, sizeof(errorBuffer), fmt, ap);
printf("\x1B[31m>>>>>>>>>> firmwareError [%s]\r\n\x1B[0m\r\n", errorBuffer);
throw std::logic_error(errorBuffer);
#endif // EFI_PROD_CODE
}
void firmwareError(ObdCode code, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
firmwareErrorV(code, fmt, ap);
va_end(ap);
}
// This is critical error for plain C use.
// From plain C file we cannot use somethings like this:
// #define criticalError(...) firmwareError(ObdCode::OBD_PCM_Processor_Fault, __VA_ARGS__)
// because of ObdCode::
// Also we can not write some wrapper that will pass variable length argument list to another variable length argument list function
void criticalErrorC(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
firmwareErrorV(ObdCode::OBD_PCM_Processor_Fault, fmt, ap);
va_end(ap);
}
Reference in New Issue View Git Blame Copy Permalink