error_handling.cpp File Reference

Detailed Description

Date

Apr 1, 2014

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file error_handling.cpp.

Functions
const char *	getCriticalErrorMessage (void)
void	checkLastBootError ()
void	logHardFault (uint32_t type, uintptr_t faultAddress, port_extctx *ctx, uint32_t csfr)
void	chDbgPanic3 (const char *msg, const char *file, int line)
bool	warning (ObdCode code, const char *fmt,...)
const char *	getWarningMessage (void)
void	onLockHook (void)
void	onUnlockHook (void)
void	firmwareError (ObdCode code, const char *fmt,...)

Variables
static critical_msg_t	warningBuffer
static critical_msg_t	criticalErrorMessageBuffer
int	warningEnabled
bool	hasFirmwareErrorFlag = false
const char *	dbg_panic_file
int	dbg_panic_line
WarningCodeState	unitTestWarningCodeState
uint32_t	lastLockTime
uint32_t	maxLockedDuration = 0

Function Documentation

chDbgPanic3()

void chDbgPanic3	(	const char *	msg,
		const char *	file,
		int	line
	)

Definition at line 105 of file error_handling.cpp.

                                                               {
#if EFI_PROD_CODE
    // Attempt to break in to the debugger, if attached
    __asm volatile("BKPT #0\n");
#endif
 
#if EFI_BACKUP_SRAM
    auto sramState = getBackupSram();
    strncpy(sramState->Err.hardFile, file, efi::size(sramState->Err.hardFile) - 1);
    sramState->Err.hardLine = line;
    sramState->Err.check = 123;
    strncpy(sramState->Err.rawMsg, msg, efi::size(sramState->Err.rawMsg) - 1);
#endif // EFI_BACKUP_SRAM
 
    if (hasOsPanicError())
        return;
    dbg_panic_file = file;
    dbg_panic_line = line;
#if CH_DBG_SYSTEM_STATE_CHECK
    ch.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
}

Here is the call graph for this function:

checkLastBootError()

void checkLastBootError

(

)

Definition at line 30 of file error_handling.cpp.

                          {
#if EFI_BACKUP_SRAM
    auto sramState = getBackupSram();
 
    switch (sramState->Err.Cookie) {
    case ErrorCookie::FirmwareError:
        efiPrintf("Last boot had firmware error: %s", sramState->Err.ErrorString);
        break;
    case ErrorCookie::HardFault: {
        efiPrintf("Last boot had raw: %s", sramState->Err.rawMsg);
        efiPrintf("Last boot had hardFile: %s", sramState->Err.hardFile);
        efiPrintf("Last boot had line: %d", sramState->Err.hardLine);
        efiPrintf("Last boot had check: %d", sramState->Err.check);
        efiPrintf("Last boot had error: %s", sramState->Err.ErrorString);
        efiPrintf("Last boot had hard fault type: %x addr: %x CSFR: %x", sramState->Err.FaultType, sramState->Err.FaultAddress, sramState->Err.Csfr);
        if (engineConfiguration->rethrowHardFault) {
            criticalError("Last boot had hard fault type: %x addr: %x CSFR: %x", sramState->Err.FaultType, sramState->Err.FaultAddress, sramState->Err.Csfr);
        }
 
        auto ctx = &sramState->Err.FaultCtx;
        efiPrintf("r0  0x%x", ctx->r0);
        efiPrintf("r1  0x%x", ctx->r1);
        efiPrintf("r2  0x%x", ctx->r2);
        efiPrintf("r3  0x%x", ctx->r3);
        efiPrintf("r12 0x%x", ctx->r12);
        efiPrintf("lr (thread)  0x%x", ctx->lr_thd);
        efiPrintf("pc  0x%x", ctx->pc);
        efiPrintf("xpsr  0x%x", ctx->xpsr);
 
        /* FPU registers - not very usefull for debug */
        if (0) {
            // Print rest the context as a sequence of uintptr
            uintptr_t* data = reinterpret_cast<uintptr_t*>(&sramState->Err.FaultCtx);
            for (size_t i = 8; i < sizeof(port_extctx) / sizeof(uintptr_t); i++) {
                efiPrintf("Fault ctx %d: %x", i, data[i]);
            }
        }
 
        break;
    }
    default:
        // No cookie stored or invalid cookie (ie, backup RAM contains random garbage)
        break;
    }
 
    // Reset cookie so we don't print it again.
    sramState->Err.Cookie = ErrorCookie::None;
 
    if (sramState->Err.BootCountCookie != 0xdeadbeef) {
        sramState->Err.BootCountCookie = 0xdeadbeef;
        sramState->Err.BootCount = 0;
    }
 
    efiPrintf("Power cycle count: %d", sramState->Err.BootCount);
    sramState->Err.BootCount++;
#endif // EFI_BACKUP_SRAM
}

Referenced by runRusEfi().

Here is the call graph for this function:

Here is the caller graph for this function:

firmwareError()

void firmwareError	(	ObdCode	code,
		const char *	fmt,
			...
	)

Something really bad had happened - firmware cannot function, we cannot run the engine We definitely use this critical error approach in case of invalid configuration. If user sets a self-contradicting configuration we have to just put a hard stop on this.

see also warning()

in case of simple error message let's reduce stack usage chvsnprintf could cause an overflow if we're already low

Definition at line 265 of file error_handling.cpp.

                                                       {
#if EFI_PROD_CODE
    if (hasFirmwareErrorFlag)
        return;
    hasFirmwareErrorFlag = true;
#if EFI_ENGINE_CONTROL
    getLimpManager()->fatalError();
#endif // EFI_ENGINE_CONTROL
    engine->engineState.warnings.addWarningCode(code);
#ifdef EFI_PRINT_ERRORS_AS_WARNINGS
    {
        va_list ap;
        va_start(ap, fmt);
        chvsnprintf(warningBuffer, sizeof(warningBuffer), fmt, ap);
        va_end(ap);
    }
#endif // EFI_PRINT_ERRORS_AS_WARNINGS
    criticalShutdown();
    enginePins.communicationLedPin.setValue(1, /*force*/true);
 
    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
         */
        strncpy((char*) criticalErrorMessageBuffer, fmt, sizeof(criticalErrorMessageBuffer) - 1);
        criticalErrorMessageBuffer[sizeof(criticalErrorMessageBuffer) - 1] = 0; // just to be sure
    } else {
        va_list ap;
        va_start(ap, fmt);
        chvsnprintf(criticalErrorMessageBuffer, sizeof(criticalErrorMessageBuffer), fmt, ap);
        va_end(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);
    }
 
#if EFI_BACKUP_SRAM
    auto sramState = getBackupSram();
    strncpy(sramState->Err.ErrorString, criticalErrorMessageBuffer, efi::size(sramState->Err.ErrorString));
    sramState->Err.Cookie = ErrorCookie::FirmwareError;
#endif // EFI_BACKUP_SRAM
#else
 
  // large buffer on stack is risky we better use normal memory
    static char errorBuffer[200];
 
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(errorBuffer, sizeof(errorBuffer), fmt, ap);
    va_end(ap);
 
    printf("\x1B[31m>>>>>>>>>> firmwareError [%s]\r\n\x1B[0m\r\n", errorBuffer);
 
#if EFI_SIMULATOR || EFI_UNIT_TEST
    throw std::logic_error(errorBuffer);
#endif /* EFI_SIMULATOR */
#endif
}

Referenced by TriggerWaveform::addEvent(), assertTimeIsLinear(), TriggerWaveform::calculateExpectedEventCounts(), calculateTriggerSynchPoint(), checkLastResetCause(), MultiChannelStateSequence::checkSwitchTimes(), AemXSeriesWideband::decodeRusefiStandard(), TriggerDecoderBase::decodeTriggerEvent(), doInitElectronicThrottle(), efiExtiEnablePin(), ensureArrayIsAscending(), SingleTimerExecutor::executeAllPendingActions(), fatalErrorForPresetApply(), findIndexMsg(), TriggerStimulatorHelper::findTriggerSyncPoint(), getAdcChannelBrainPin(), getAirmassModel(), getFiringOrderCylinderId(), getFiringOrderLength(), getFiringOrderTable(), getHwPin(), getIgnitionPinForIndex(), getInjectionModeDurationMultiplier(), getMapCfg(), getNumberOfInjections(), getNumberOfSparks(), getPortIndex(), getSpiDevice(), gpio_pin_markUsed(), PwmConfig::handleCycleStart(), TriggerCentral::handleShaftSignal(), EtbController::init(), initAuxValves(), initEgoSensor(), initHistogram(), initializeSkippedToothTrigger(), OutputPin::initPin(), look_up_rpm_can_id(), look_up_vss_can_id(), myerror(), onCliCaseError(), onCliDuplicateError(), onCliOverflowError(), FLStack< T, MAXSIZE >::pop(), portSetHardwareSchedulerTimer(), FLStack< T, MAXSIZE >::push(), recalculateAuxValveTiming(), EventQueue::remove(), resetConfigurationExt(), runBench(), SingleTimerExecutor::scheduleByTimestampNt(), setHardwareSchedulerTimer(), GppwmChannel::setOutput(), startCanPins(), swapOutputBuffers(), tachUpdate(), timerCallback(), timerValidationCallback(), turnOnTriggerInputPin(), InjectionEvent::update(), validateHardwareTimer(), validateThermistorConfig(), and wrapAngle().

Here is the call graph for this function:

getCriticalErrorMessage()

const char* getCriticalErrorMessage

(

void

)

Definition at line 25 of file error_handling.cpp.

                                          {
    return criticalErrorMessageBuffer;
}

Referenced by TunerStudio::handleCrcCommand(), handleTestCommand(), and updateDevConsoleState().

Here is the caller graph for this function:

getWarningMessage()

const char* getWarningMessage

(

void

)

Definition at line 211 of file error_handling.cpp.

                                    {
    return warningBuffer;
}

logHardFault()

void logHardFault	(	uint32_t	type,
		uintptr_t	faultAddress,
		port_extctx *	ctx,
		uint32_t	csfr
	)

Definition at line 88 of file error_handling.cpp.

                                                                                          {
    criticalShutdown();
#if EFI_BACKUP_SRAM
    auto sramState = getBackupSram();
    sramState->Err.Cookie = ErrorCookie::HardFault;
    sramState->Err.check = 321;
    sramState->Err.FaultType = type;
    sramState->Err.FaultAddress = faultAddress;
    sramState->Err.Csfr = csfr;
    memcpy(&sramState->Err.FaultCtx, ctx, sizeof(port_extctx));
#endif // EFI_BACKUP_SRAM
}

Referenced by HardFault_Handler_C(), MemManage_Handler_C(), and UsageFault_Handler_C().

Here is the call graph for this function:

Here is the caller graph for this function:

onLockHook()

void onLockHook

(

void

)

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

Definition at line 234 of file error_handling.cpp.

                      {
#if ENABLE_PERF_TRACE
    perfEventInstantGlobal(PE::GlobalLock);
#endif /* ENABLE_PERF_TRACE */
 
#if EFI_CLOCK_LOCKS
    lastLockTime = getTimeNowLowerNt();
#endif /* EFI_CLOCK_LOCKS */
}

Here is the call graph for this function:

onUnlockHook()

void onUnlockHook

(

void

)

Definition at line 244 of file error_handling.cpp.

                        {
#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 */
}

Here is the call graph for this function:

warning()

bool warning	(	ObdCode	code,
		const char *	fmt,
			...
	)

ObdCode::OBD_PCM_Processor_Fault is the general error code for now

Returns

TRUE in case there were warnings recently

Definition at line 165 of file error_handling.cpp.

                                                 {
    if (hasFirmwareErrorFlag)
        return true;
 
#if EFI_SIMULATOR || EFI_PROD_CODE
    bool known = engine->engineState.warnings.isWarningNow(code);
 
    // if known - just reset timer
    engine->engineState.warnings.addWarningCode(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);
 
    if (engineConfiguration->showHumanReadableWarning) {
#if EFI_TUNER_STUDIO
    // TODO: does this work? Fix or remove
    memcpy(persistentState.persistentConfiguration.warning_message, warningBuffer, sizeof(warningBuffer));
#endif /* EFI_TUNER_STUDIO */
    }
 
    efiPrintf("WARNING: %s", warningBuffer);
#else
    // todo: we need access to 'engine' here so that we can migrate to real 'engine->engineState.warnings'
    unitTestWarningCodeState.addWarningCode(code);
    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;
}

Referenced by TriggerWaveform::addEvent(), assertPinAssigned(), TriggerStimulatorHelper::assertSyncPosition(), buildTimingMap(), check(), createLogFile(), CanTsListener::decodeFrame(), AemXSeriesWideband::decodeRusefiDiag(), Engine::efiWatchdog(), findIndexMsg(), fireSparkBySettingPinLow(), flexCallback(), getAdvance(), SpeedDensityAirmass::getAirmass(), getBaroCorrection(), getCrankingFuel3(), getFiringOrderCylinderId(), getInjectionOffset(), getInternalAdcValue(), getRunningAdvance(), IgnitionState::getSparkDwell(), IFuelComputer::getTCharge(), Pid::getUnclampedOutput(), TriggerCentral::handleShaftSignal(), handleVvtCamSignal(), hip_init(), hipThread(), TriggerWaveform::initializeTriggerWaveform(), interpolateMsg(), TriggerCentral::isToothExpectedNow(), mainTriggerCallback(), mapAveragingAdcCallback(), mapAveragingTriggerCallback(), PrimaryTriggerDecoder::onNotEnoughTeeth(), VvtTriggerDecoder::onNotEnoughTeeth(), SensorChecker::onSlowCallback(), PrimaryTriggerDecoder::onTooManyTeeth(), VvtTriggerDecoder::onTooManyTeeth(), onTriggerEventSparkLogic(), InjectionEvent::onTriggerTooth(), EngineState::periodicFastCallback(), prepareIgnitionSchedule(), readFromFlash(), scheduleSparkEvent(), HIP9011::setAngleWindowWidth(), setGlobalTriggerAngleOffset(), setHardwareSchedulerTimer(), OutputPin::setOnchipValue(), SimplePwm::setSimplePwmDutyCycle(), startDwellByTurningSparkPinHigh(), startSimplePwm(), MapAverager::stop(), InjectionEvent::update(), LimpManager::updateState(), validateBaroMap(), TriggerCentral::validateCamVvtCounters(), and CanTxMessage::~CanTxMessage().

Here is the call graph for this function:

Variable Documentation

criticalErrorMessageBuffer

critical_msg_t criticalErrorMessageBuffer

static

Definition at line 16 of file error_handling.cpp.

Referenced by firmwareError(), and getCriticalErrorMessage().

dbg_panic_file

const char* dbg_panic_file

Definition at line 22 of file error_handling.cpp.

Referenced by chDbgPanic3().

dbg_panic_line

int dbg_panic_line

Definition at line 23 of file error_handling.cpp.

Referenced by chDbgPanic3().

hasFirmwareErrorFlag

bool hasFirmwareErrorFlag = false

Definition at line 20 of file error_handling.cpp.

Referenced by firmwareError(), and warning().

lastLockTime

uint32_t lastLockTime

Definition at line 217 of file error_handling.cpp.

Referenced by onLockHook(), and onUnlockHook().

maxLockedDuration

uint32_t maxLockedDuration = 0

Maximum time before requesting lock and releasing lock at the end of critical section

Definition at line 221 of file error_handling.cpp.

Referenced by onUnlockHook(), printRuntimeStats(), resetMaxValues(), and updateTunerStudioState().

unitTestWarningCodeState

WarningCodeState unitTestWarningCodeState

Definition at line 156 of file error_handling.cpp.

Referenced by warning().

warningBuffer

critical_msg_t warningBuffer

static

Definition at line 15 of file error_handling.cpp.

Referenced by firmwareError(), getWarningMessage(), and warning().

warningEnabled

int warningEnabled

extern

Go to the source code of this file.