diff --git a/firmware/CHANGELOG.md b/firmware/CHANGELOG.md index 85515a7b39..2ce8378291 100644 --- a/firmware/CHANGELOG.md +++ b/firmware/CHANGELOG.md @@ -54,6 +54,7 @@ or - Instant RPM is now used automatically on triggers with 24 or more teeth per engine cycle (a 12 tooth crank wheel or better), instead of only when "Always use instant RPM" was enabled. RPM, and everything derived from it, now responds within a fraction of an engine cycle instead of once per cycle. The setting remains, and now forces instant RPM on triggers with fewer teeth than that. ### Fixed + - Configuration burns now serialize direct, scheduled, and background writes with configuration reads. Requests made during a burn are preserved, and a failed burn stays pending until a new request. The `flash_status` console command reports the last result and completed driver writes. - Changing or clearing the MAP 2, MAF, MAF 2 or fuel level sensor input no longer leaves the sensor reading its old pin (and the pin claimed) until the ECU is rebooted. MAF and fuel level input changes now take effect immediately, like other analog sensors - STM32F7 dual-bank ECUs no longer stall (potentially stopping the engine) when burning configuration with the engine running - configuration is now committed to flash when the engine is stopped #776 - SD card log field names now include their category prefix (e.g. `Boost: Target` instead of just `Target`), matching the names shown in TunerStudio diff --git a/firmware/controllers/configuration_write.h b/firmware/controllers/configuration_write.h new file mode 100644 index 0000000000..14f7af2c17 --- /dev/null +++ b/firmware/controllers/configuration_write.h @@ -0,0 +1,79 @@ +#pragma once + +#include "flash_int.h" + +enum class ConfigurationWritePhase { + Complete, + Layout, + Erase, + Program, + Verify, +}; + +struct ConfigurationWriteResult { + ConfigurationWritePhase phase; + flashaddr_t address; + int error; + // Copies whose erase and program operations completed successfully. + unsigned completedCopies; + + bool success() const { + return phase == ConfigurationWritePhase::Complete; + } +}; + +// Callers serialize access. A failed attempt remains pending, but only a new +// request permits an automatic retry. Requests arriving during a write survive it. +class ConfigurationWriteState { +public: + void request() { + m_pending = true; + m_requested = true; + } + + bool pending() const { + return m_pending; + } + bool writing() const { + return m_writing; + } + bool reading() const { + return m_reading; + } + bool shouldWrite() const { + return m_requested && !m_writing && !m_reading; + } + + bool begin(bool requestedOnly = false) { + if (m_writing || m_reading || (requestedOnly && !m_requested)) { + return false; + } + m_pending = true; + m_requested = false; + m_writing = true; + return true; + } + + void complete(bool success) { + m_writing = false; + m_pending = !success || m_requested; + } + + bool beginRead() { + if (m_writing || m_reading) { + return false; + } + m_reading = true; + return true; + } + + void endRead() { + m_reading = false; + } + +private: + bool m_pending = false; + bool m_requested = false; + bool m_writing = false; + bool m_reading = false; +}; diff --git a/firmware/controllers/flash_main.cpp b/firmware/controllers/flash_main.cpp index ab4e96e114..569105b1c8 100644 --- a/firmware/controllers/flash_main.cpp +++ b/firmware/controllers/flash_main.cpp @@ -11,12 +11,15 @@ #if EFI_INTERNAL_FLASH +#if !EFI_UNIT_TEST #include "mpu_util.h" +#endif #include "flash_main.h" #include "eficonsole.h" #include "flash_int.h" #include "crc_accelerator.h" +#include "configuration_write.h" #if EFI_TUNER_STUDIO #include "tunerstudio.h" @@ -24,7 +27,8 @@ #include "runtime_state.h" -static bool needToWriteConfiguration = false; +static ConfigurationWriteState configurationWriteState; +static ConfigurationWriteResult lastWriteResult{ConfigurationWritePhase::Complete, 0, FLASH_RETURN_SUCCESS, 0}; /** * https://sourceforge.net/p/rusefi/tickets/335/ @@ -37,6 +41,8 @@ static uint32_t flashStateCrc(const persistent_config_container_s& state) { return singleCrc(&state.persistentConfiguration, sizeof(persistent_config_s)); } +static void writeConfiguration(bool requestedOnly); + #if EFI_FLASH_WRITE_THREAD chibios_rt::BinarySemaphore flashWriteSemaphore(/*taken =*/true); @@ -49,106 +55,159 @@ static void flashWriteThread(void*) { // Wait for a request to come in flashWriteSemaphore.wait(); - // Do the actual flash write operation - writeToFlashNow(); + // Claim a pending request atomically; a direct write may have consumed it. + writeConfiguration(true); } } #endif // EFI_FLASH_WRITE_THREAD -void setNeedToWriteConfiguration() { - efiPrintf("Scheduling configuration write"); - needToWriteConfiguration = true; - +static void wakeFlashWriter() { #if EFI_FLASH_WRITE_THREAD if (allowFlashWhileRunning()) { - // Signal the flash writer thread to wake up and write at its leisure flashWriteSemaphore.signal(); } -#endif // EFI_FLASH_WRITE_THREAD +#endif +} + +void setNeedToWriteConfiguration() { + efiPrintf("Scheduling configuration write"); + { + chibios_rt::CriticalSectionLocker lock; + configurationWriteState.request(); + } + wakeFlashWriter(); } bool getNeedToWriteConfiguration() { - return needToWriteConfiguration; + chibios_rt::CriticalSectionLocker lock; + return configurationWriteState.pending(); +} + +static bool shouldWriteConfiguration() { + chibios_rt::CriticalSectionLocker lock; + return configurationWriteState.shouldWrite(); } void writeToFlashIfPending() { - // with a flash write thread, the schedule happens directly from - // setNeedToWriteConfiguration, so there's nothing to do here - if (allowFlashWhileRunning() || !getNeedToWriteConfiguration()) { - // Allow sensor timeouts again now that we're done (and a little time has passed) + // Keep failures visible, but require a new request before an automatic retry. + if (allowFlashWhileRunning() || !shouldWriteConfiguration()) { Sensor::inhibitTimeouts(false); return; } - // Prevent sensor timeouts while flashing Sensor::inhibitTimeouts(true); - writeToFlashNow(); - // we do not want to allow sensor timeouts right away, we re-enable next time method is invoked + writeConfiguration(true); + // Re-enable timeouts on the next invocation, after sensors have had time to update. } -// Erase and write a copy of the configuration at the specified address +// Keep storage operations here until the integrity/verification change. template -int eraseAndFlashCopy(flashaddr_t storageAddress, const TStorage& data) { - // error already reported, return +static ConfigurationWriteResult +eraseAndFlashCopy(flashaddr_t storageAddress, const TStorage& data, unsigned completedCopies) { if (!storageAddress) { - return FLASH_RETURN_SUCCESS; + return {ConfigurationWritePhase::Layout, storageAddress, FLASH_RETURN_NO_PERMISSION, completedCopies}; } auto err = intFlashErase(storageAddress, sizeof(TStorage)); - if (FLASH_RETURN_SUCCESS != err) { - firmwareError("Failed to erase flash at 0x%08x: %d", storageAddress, err); - return err; + if (err != FLASH_RETURN_SUCCESS) { + return {ConfigurationWritePhase::Erase, storageAddress, err, completedCopies}; } err = intFlashWrite(storageAddress, reinterpret_cast(&data), sizeof(TStorage)); - if (FLASH_RETURN_SUCCESS != err) { - firmwareError("Failed to write flash at 0x%08x: %d", storageAddress, err); - return err; + if (err != FLASH_RETURN_SUCCESS) { + return {ConfigurationWritePhase::Program, storageAddress, err, completedCopies}; } - return err; + return {ConfigurationWritePhase::Complete, 0, FLASH_RETURN_SUCCESS, completedCopies + 1}; } bool burnWithoutFlash = false; void writeToFlashNow() { - engine->configBurnTimer.reset(); - bool isSuccess = false; + writeConfiguration(false); +} - if (burnWithoutFlash) { - needToWriteConfiguration = false; - return; +static void writeConfiguration(bool requestedOnly) { + { + chibios_rt::CriticalSectionLocker lock; + if (!configurationWriteState.begin(requestedOnly)) { + // Preserve direct requests that arrive during another flash operation. + if (!requestedOnly) { + configurationWriteState.request(); + } + return; + } } - efiPrintf("Writing pending configuration..."); - // Set up the container - persistentState.size = sizeof(persistentState); - persistentState.version = FLASH_DATA_VERSION; - persistentState.value = flashStateCrc(persistentState); + engine->configBurnTimer.reset(); + ConfigurationWriteResult result{ConfigurationWritePhase::Complete, 0, FLASH_RETURN_SUCCESS, 0}; -#if EFI_STORAGE_INT_FLASH == TRUE - // Flash two copies - int result1 = eraseAndFlashCopy(getFlashAddrFirstCopy(), persistentState); - int result2 = FLASH_RETURN_SUCCESS; - /* Only if second copy is supported */ - if (getFlashAddrSecondCopy()) { - result2 = eraseAndFlashCopy(getFlashAddrSecondCopy(), persistentState); - } + if (!burnWithoutFlash) { + efiPrintf("Writing pending configuration..."); + // No system lock is held while the driver erases, programs or sleeps. - // handle success/failure - isSuccess = (result1 == FLASH_RETURN_SUCCESS) && (result2 == FLASH_RETURN_SUCCESS); + persistentState.size = sizeof(persistentState); + persistentState.version = FLASH_DATA_VERSION; + persistentState.value = flashStateCrc(persistentState); + +#if EFI_STORAGE_INT_FLASH == TRUE + result = eraseAndFlashCopy(getFlashAddrFirstCopy(), persistentState, 0); + // A known failure of the first copy must leave the backup untouched. + if (result.success() && getFlashAddrSecondCopy()) { + result = eraseAndFlashCopy(getFlashAddrSecondCopy(), persistentState, result.completedCopies); + } +#else + result = {ConfigurationWritePhase::Layout, 0, FLASH_RETURN_NO_PERMISSION, 0}; #endif + resetMaxValues(); + } - if (isSuccess) { - efiPrintf("FLASH_SUCCESS"); - } else { - efiPrintf("Flashing failed"); + { + chibios_rt::CriticalSectionLocker lock; + lastWriteResult = result; + configurationWriteState.complete(result.success()); + } + if (!burnWithoutFlash) { + if (result.success()) { + efiPrintf("FLASH_SUCCESS"); + } else { + // Publish completion before reporting an error: production firmwareError can return. + firmwareError( + "Configuration flash failed: phase %d address 0x%08x error %d copies %u", + static_cast(result.phase), + result.address, + result.error, + result.completedCopies); + } } - resetMaxValues(); + // A new request may have arrived while the low-priority H7 writer was busy. + if (shouldWriteConfiguration()) { + wakeFlashWriter(); + } +} - // Write complete, clear the flag - needToWriteConfiguration = false; +static void printFlashStatus() { + ConfigurationWriteResult result; + bool pending; + bool writing; + bool reading; + { + chibios_rt::CriticalSectionLocker lock; + result = lastWriteResult; + pending = configurationWriteState.pending(); + writing = configurationWriteState.writing(); + reading = configurationWriteState.reading(); + } + efiPrintf( + "flash_status pending=%d writing=%d reading=%d phase=%d address=0x%08x error=%d copies=%u", + pending, + writing, + reading, + static_cast(result.phase), + result.address, + result.error, + result.completedCopies); } static void doResetConfiguration() { @@ -225,6 +284,15 @@ static FlashState readConfiguration() { } void readFromFlash() { + bool canRead; + { + chibios_rt::CriticalSectionLocker lock; + canRead = configurationWriteState.beginRead(); + } + if (!canRead) { + efiPrintf("Cannot read configuration while another flash operation is active"); + return; + } FlashState result = readConfiguration(); switch (result) { @@ -253,10 +321,18 @@ void readFromFlash() { // we can only change the state after the CRC check engineConfiguration->byFirmwareVersion = getRusEfiVersion(); validateConfiguration(); + { + chibios_rt::CriticalSectionLocker lock; + configurationWriteState.endRead(); + } + if (shouldWriteConfiguration()) { + wakeFlashWriter(); + } } void initFlash() { addConsoleAction("readconfig", readFromFlash); + addConsoleAction("flash_status", printFlashStatus); /** * This would write NOW (you should not be doing this while connected to real engine) */ diff --git a/unit_tests/global.h b/unit_tests/global.h index 3762515cf8..56a2b17c6e 100644 --- a/unit_tests/global.h +++ b/unit_tests/global.h @@ -32,6 +32,7 @@ extern "C" { #endif /* __cplusplus */ #define CH_FREQUENCY 1000 +#define HAL_SUCCESS 0 #define NO_CACHE typedef uint32_t systime_t; diff --git a/unit_tests/tests/system/test_configuration_write.cpp b/unit_tests/tests/system/test_configuration_write.cpp new file mode 100644 index 0000000000..40f4c29e59 --- /dev/null +++ b/unit_tests/tests/system/test_configuration_write.cpp @@ -0,0 +1,53 @@ +#include "pch.h" +#include "configuration_write.h" + +TEST(ConfigurationWriteState, FailedAttemptNeedsANewRequestForAutomaticRetry) { + ConfigurationWriteState state; + EXPECT_FALSE(state.begin(true)); + state.request(); + ASSERT_TRUE(state.begin(true)); + EXPECT_TRUE(state.pending()); + EXPECT_TRUE(state.writing()); + EXPECT_FALSE(state.begin()); + EXPECT_FALSE(state.beginRead()); + state.complete(false); + EXPECT_TRUE(state.pending()); + EXPECT_FALSE(state.writing()); + EXPECT_FALSE(state.shouldWrite()); + EXPECT_FALSE(state.begin(true)); + state.request(); + ASSERT_TRUE(state.begin(true)); + state.complete(true); + EXPECT_FALSE(state.pending()); +} + +TEST(ConfigurationWriteState, RequestDuringWriteSurvivesBothSuccessAndFailure) { + for (bool success : {false, true}) { + ConfigurationWriteState state; + ASSERT_TRUE(state.begin()); + state.request(); + EXPECT_FALSE(state.shouldWrite()); + state.complete(success); + EXPECT_TRUE(state.pending()); + EXPECT_TRUE(state.shouldWrite()); + ASSERT_TRUE(state.begin(true)); + state.complete(true); + EXPECT_FALSE(state.pending()); + } +} + +TEST(ConfigurationWriteState, ReadSerializesDirectAndRequestedWrites) { + ConfigurationWriteState state; + ASSERT_TRUE(state.beginRead()); + EXPECT_TRUE(state.reading()); + EXPECT_FALSE(state.beginRead()); + state.request(); + EXPECT_FALSE(state.begin()); + EXPECT_FALSE(state.begin(true)); + EXPECT_FALSE(state.shouldWrite()); + state.endRead(); + EXPECT_TRUE(state.shouldWrite()); + ASSERT_TRUE(state.begin(true)); + state.complete(true); + EXPECT_FALSE(state.pending()); +} diff --git a/unit_tests/tests/system/test_flash_write_lifecycle.cpp b/unit_tests/tests/system/test_flash_write_lifecycle.cpp new file mode 100644 index 0000000000..b861fe19b6 --- /dev/null +++ b/unit_tests/tests/system/test_flash_write_lifecycle.cpp @@ -0,0 +1,290 @@ +#include "pch.h" +#include "flash_main.h" +#include "eficonsole.h" +#include "flash_int.h" +#include "crc_accelerator.h" +#include "configuration_write.h" +#include "tunerstudio.h" +#include "runtime_state.h" +#include "stored_value_sensor.h" + +#include +#include + +// Compile the production entry points with only flash I/O replaced. +// The error hook returns, matching production firmwareError behavior. +namespace flash_lifecycle_test { +static persistent_config_container_s persistentState; +static bool concurrent; +static unsigned errors; +static unsigned reads; +static flashaddr_t firstAddress; +static flashaddr_t secondAddress; +static flashaddr_t failingAddress; +static ConfigurationWritePhase failingPhase; +static std::vector erases; +static std::vector programs; +static std::function duringWrite; +static std::function duringRead; +static std::function duringError; + +bool allowFlashWhileRunning() { + return concurrent; +} +flashaddr_t getFlashAddrFirstCopy() { + return firstAddress; +} +flashaddr_t getFlashAddrSecondCopy() { + return secondAddress; +} +void firmwareError(const char*, ...) { + ++errors; + if (duringError) { + duringError(); + } +} +int intFlashErase(flashaddr_t address, size_t size) { + erases.push_back(address); + EXPECT_EQ(size, sizeof(persistentState)); + if (address == failingAddress && failingPhase == ConfigurationWritePhase::Erase) { + return FLASH_RETURN_OPERROR; + } + return FLASH_RETURN_SUCCESS; +} +int intFlashWrite(flashaddr_t address, const char* buffer, size_t size) { + programs.push_back(address); + EXPECT_EQ(size, sizeof(persistentState)); + EXPECT_EQ(buffer, reinterpret_cast(&persistentState)); + EXPECT_EQ(persistentState.version, FLASH_DATA_VERSION); + EXPECT_EQ(persistentState.size, sizeof(persistentState)); + EXPECT_EQ(persistentState.value, singleCrc(&persistentState.persistentConfiguration, sizeof(persistent_config_s))); + if (duringWrite) { + duringWrite(); + } + if (address == failingAddress && failingPhase == ConfigurationWritePhase::Program) { + return FLASH_RETURN_PSEQERROR; + } + return FLASH_RETURN_SUCCESS; +} +int intFlashRead(flashaddr_t, char* destination, size_t size) { + ++reads; + EXPECT_EQ(destination, reinterpret_cast(&persistentState)); + EXPECT_EQ(size, sizeof(persistentState)); + if (duringRead) { + duringRead(); + } + // Read a valid copy so the production loader follows its normal path. + persistentState.size = sizeof(persistentState); + persistentState.version = FLASH_DATA_VERSION; + persistentState.value = singleCrc(&persistentState.persistentConfiguration, sizeof(persistent_config_s)); + return FLASH_RETURN_SUCCESS; +} +void writeToFlashNow(); + +#undef EFI_INTERNAL_FLASH +#define EFI_INTERNAL_FLASH 1 +#undef EFI_STORAGE_INT_FLASH +#define EFI_STORAGE_INT_FLASH 1 +#undef EFI_FLASH_WRITE_THREAD +#define EFI_FLASH_WRITE_THREAD 0 +#include "../../../firmware/controllers/flash_main.cpp" +} // namespace flash_lifecycle_test + +namespace { +class FlashWriteLifecycle : public testing::Test { +protected: + void SetUp() override { + using namespace flash_lifecycle_test; + concurrent = false; + errors = reads = 0; + firstAddress = 0x100000; + secondAddress = 0x200000; + failingAddress = 0; + failingPhase = ConfigurationWritePhase::Complete; + erases.clear(); + programs.clear(); + duringWrite = duringRead = duringError = {}; + configurationWriteState = {}; + lastWriteResult = {ConfigurationWritePhase::Complete, 0, FLASH_RETURN_SUCCESS, 0}; + burnWithoutFlash = false; + } + void TearDown() override { + Sensor::inhibitTimeouts(false); + } +}; + +TEST_F(FlashWriteLifecycle, DirectWritePublishesBothDriverCompletions) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_EQ(erases, (std::vector{firstAddress, secondAddress})); + EXPECT_EQ(programs, erases); + EXPECT_FALSE(flash_lifecycle_test::getNeedToWriteConfiguration()); + EXPECT_EQ(lastWriteResult.completedCopies, 2u); + EXPECT_TRUE(lastWriteResult.success()); +} + +TEST_F(FlashWriteLifecycle, FirstDriverFailureStopsBeforeBackupAndPublishesBeforeError) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + for (auto phase : {ConfigurationWritePhase::Erase, ConfigurationWritePhase::Program}) { + erases.clear(); + programs.clear(); + failingAddress = firstAddress; + failingPhase = phase; + duringError = [&] { + EXPECT_FALSE(configurationWriteState.writing()); + EXPECT_TRUE(flash_lifecycle_test::getNeedToWriteConfiguration()); + EXPECT_FALSE(flash_lifecycle_test::shouldWriteConfiguration()); + EXPECT_EQ(lastWriteResult.phase, phase); + EXPECT_EQ(lastWriteResult.address, firstAddress); + EXPECT_EQ(lastWriteResult.completedCopies, 0u); + }; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_EQ(erases, (std::vector{firstAddress})); + EXPECT_EQ(programs.size(), phase == ConfigurationWritePhase::Erase ? 0u : 1u); + } + EXPECT_EQ(errors, 2u); +} + +TEST_F(FlashWriteLifecycle, SecondDriverFailureReportsOneCompletedCopy) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + failingAddress = secondAddress; + failingPhase = ConfigurationWritePhase::Program; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_EQ(lastWriteResult.completedCopies, 1u); + EXPECT_EQ(lastWriteResult.address, secondAddress); + EXPECT_EQ(lastWriteResult.error, FLASH_RETURN_PSEQERROR); + EXPECT_TRUE(flash_lifecycle_test::getNeedToWriteConfiguration()); +} + +TEST_F(FlashWriteLifecycle, FailedPendingWriteWaitsForFreshRequest) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + failingAddress = firstAddress; + failingPhase = ConfigurationWritePhase::Erase; + flash_lifecycle_test::setNeedToWriteConfiguration(); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_TRUE(flash_lifecycle_test::getNeedToWriteConfiguration()); + for (int i = 0; i < 5; ++i) { + flash_lifecycle_test::writeToFlashIfPending(); + } + EXPECT_EQ(erases.size(), 1u); + failingAddress = 0; + flash_lifecycle_test::setNeedToWriteConfiguration(); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_FALSE(flash_lifecycle_test::getNeedToWriteConfiguration()); + EXPECT_EQ(erases.size(), 3u); +} + +TEST_F(FlashWriteLifecycle, ReentrantDirectWritePreservesRequestWithoutOverlappingIo) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + duringWrite = [] { flash_lifecycle_test::writeToFlashNow(); }; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_EQ(erases.size(), 2u); + EXPECT_TRUE(flash_lifecycle_test::getNeedToWriteConfiguration()); + duringWrite = {}; + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_FALSE(flash_lifecycle_test::getNeedToWriteConfiguration()); + EXPECT_EQ(erases.size(), 4u); +} + +TEST_F(FlashWriteLifecycle, NewRequestDuringFailedWriteIsEligibleForNextAttempt) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + failingAddress = firstAddress; + failingPhase = ConfigurationWritePhase::Program; + duringWrite = [] { flash_lifecycle_test::setNeedToWriteConfiguration(); }; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_TRUE(flash_lifecycle_test::shouldWriteConfiguration()); + duringWrite = {}; + failingAddress = 0; + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_FALSE(flash_lifecycle_test::getNeedToWriteConfiguration()); +} + +TEST_F(FlashWriteLifecycle, ReadCannotOverwriteRamDuringProgramming) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + duringWrite = [] { flash_lifecycle_test::readFromFlash(); }; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_EQ(reads, 0u); +} + +TEST_F(FlashWriteLifecycle, WriteDuringReadWaitsForLoadToFinish) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + duringRead = [] { + flash_lifecycle_test::writeToFlashNow(); + flash_lifecycle_test::writeToFlashIfPending(); + flash_lifecycle_test::readFromFlash(); + EXPECT_TRUE(erases.empty()); + }; + flash_lifecycle_test::readFromFlash(); + EXPECT_EQ(reads, 1u); + EXPECT_FALSE(configurationWriteState.reading()); + EXPECT_TRUE(flash_lifecycle_test::getNeedToWriteConfiguration()); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_EQ(erases.size(), 2u); + EXPECT_FALSE(flash_lifecycle_test::getNeedToWriteConfiguration()); +} + +TEST_F(FlashWriteLifecycle, ConsumedRequestCannotTriggerStaleWriterWakeup) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + concurrent = true; + flash_lifecycle_test::setNeedToWriteConfiguration(); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_TRUE(erases.empty()); + failingAddress = firstAddress; + failingPhase = ConfigurationWritePhase::Erase; + flash_lifecycle_test::writeToFlashNow(); + // This is the atomic claim used by the H7 writer after a semaphore wakeup. + flash_lifecycle_test::writeConfiguration(true); + EXPECT_EQ(erases.size(), 1u); + EXPECT_TRUE(flash_lifecycle_test::getNeedToWriteConfiguration()); +} + +TEST_F(FlashWriteLifecycle, BurnWithoutFlashConsumesRequestWithoutDriverIo) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + burnWithoutFlash = true; + flash_lifecycle_test::setNeedToWriteConfiguration(); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_TRUE(erases.empty()); + EXPECT_TRUE(programs.empty()); + EXPECT_FALSE(flash_lifecycle_test::getNeedToWriteConfiguration()); + EXPECT_EQ(lastWriteResult.completedCopies, 0u); +} + +TEST_F(FlashWriteLifecycle, PendingWriterKeepsExistingTimeoutDelay) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + StoredValueSensor sensor(SensorType::WastegatePosition, MS2NT(10)); + sensor.setValidValue(20, getTimeNowNt()); + eth.moveTimeForwardMs(100); + ASSERT_FALSE(sensor.get().Valid); + using namespace flash_lifecycle_test; + duringWrite = [&] { EXPECT_TRUE(sensor.get().Valid); }; + flash_lifecycle_test::setNeedToWriteConfiguration(); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_TRUE(sensor.get().Valid); + flash_lifecycle_test::writeToFlashIfPending(); + EXPECT_FALSE(sensor.get().Valid); +} + +TEST_F(FlashWriteLifecycle, SupportsSingleCopyAndRejectsMissingPrimary) { + EngineTestHelper eth(engine_type_e::TEST_ENGINE); + using namespace flash_lifecycle_test; + secondAddress = 0; + flash_lifecycle_test::writeToFlashNow(); + EXPECT_EQ(lastWriteResult.completedCopies, 1u); + firstAddress = 0; + erases.clear(); + flash_lifecycle_test::writeToFlashNow(); + EXPECT_TRUE(erases.empty()); + EXPECT_EQ(lastWriteResult.phase, ConfigurationWritePhase::Layout); + EXPECT_EQ(lastWriteResult.completedCopies, 0u); +} +} // namespace diff --git a/unit_tests/tests/tests.mk b/unit_tests/tests/tests.mk index 619a7ab476..a49ada7e39 100644 --- a/unit_tests/tests/tests.mk +++ b/unit_tests/tests/tests.mk @@ -54,6 +54,8 @@ TESTS_SRC_CPP = \ tests/util/test_scaled_channel.cpp \ tests/util/test_timer.cpp \ tests/system/test_periodic_thread_controller.cpp \ + tests/system/test_flash_write_lifecycle.cpp \ + tests/system/test_configuration_write.cpp \ tests/test_util.cpp \ tests/test_start_stop.cpp \ tests/test_hardware_reinit.cpp \