Harden nRF52 filesystem recovery and flash writes

This commit is contained in:
mikecarper committed 2026-09-22 15:17:39 -07:00
1 parent 6a75e2a861
commit 47af95b4b2
24 files changed
+1220 -218

No files matched your search

@@ -36,6 +36,8 @@ public:
size_t max_write = std::numeric_limits<size_t>::max();
bool fail_read_open = false;
bool fail_rename = false;
bool false_success_rename = false;
unsigned read_open_failures_remaining = 0;
unsigned rename_calls = 0;
bool exists(const char* path) const {
@@ -49,6 +51,7 @@ public:
bool rename(const char* from, const char* to) {
rename_calls++;
if (fail_rename) return false;
if (false_success_rename) return true;
auto source = files.find(from);
if (source == files.end()) return false;
files[to] = source->second;
@@ -69,6 +72,10 @@ bool FakeFile::open(const char* path, uint8_t mode) {
_path = path;
_write_mode = mode == FILE_O_WRITE;
if (!_write_mode && (_fs->fail_read_open || !_fs->exists(path))) return false;
if (!_write_mode && _fs->read_open_failures_remaining > 0) {
_fs->read_open_failures_remaining--;
return false;
}
if (_write_mode) {
auto& contents = _fs->files[_path];
_position = contents.size();
@@ -188,6 +195,34 @@ TEST(AtomicFileWriter, RenameFailurePreservesLiveFileAndCleansTemp) {
EXPECT_EQ(fs.rename_calls, 1u);
}
TEST(AtomicFileWriter, FalseSuccessRenameIsDetectedByLiveReadback) {
FakeFilesystem fs;
fs.files["/prefs"] = bytes("old");
fs.false_success_rename = true;
mesh::AtomicFileWriter writer(&fs, "/prefs");
const uint8_t replacement[] = {'n', 'e', 'w'};
ASSERT_EQ(writer.write(replacement, sizeof(replacement)), sizeof(replacement));
EXPECT_FALSE(writer.commit());
EXPECT_EQ(fs.files["/prefs"], bytes("old"));
EXPECT_FALSE(fs.exists("/prefs.tmp"));
EXPECT_EQ(fs.rename_calls, 1u);
}
TEST(AtomicFileWriter, ValidationRetriesTransientReadOpenFailures) {
FakeFilesystem fs;
fs.files["/prefs"] = bytes("old");
fs.read_open_failures_remaining = 2;
mesh::AtomicFileWriter writer(&fs, "/prefs");
const uint8_t replacement[] = {'n', 'e', 'w'};
ASSERT_EQ(writer.write(replacement, sizeof(replacement)), sizeof(replacement));
EXPECT_TRUE(writer.commit());
EXPECT_EQ(fs.files["/prefs"], bytes("new"));
}
TEST(AtomicFileWriter, AbandonedWriteAndStaleTempAreCleaned) {
FakeFilesystem fs;
fs.files["/prefs"] = bytes("old");
@@ -56,6 +56,8 @@ class IdentityAndSettingsRecovery(unittest.TestCase):
for signature in ('bool IdentityStore::recover(',
'bool IdentityStore::load(const char *name, mesh::LocalIdentity& id)',
'bool IdentityStore::load(const char *name, mesh::LocalIdentity& id, char display_name[], int max_name_sz)',
'IdentityLoadResult IdentityStore::loadResult(\n const char *name, mesh::LocalIdentity& id)',
'IdentityLoadResult IdentityStore::loadResult(\n const char *name, mesh::LocalIdentity& id, char display_name[]',
'bool IdentityStore::saveWithRetry(',
'bool IdentityStore::save(const char *name, const mesh::LocalIdentity& id)',
'bool IdentityStore::save(const char *name, const mesh::LocalIdentity& id, const char display_name[])'):
@@ -87,6 +89,10 @@ int main() {
if (display) assert(strcmp(name, "saved name") == 0);
} else {
assert(live.pub_key[0] == 9 && strcmp(name, "unchanged") == 0);
const auto state = display
? store.loadResult("main", live, name, sizeof(name))
: store.loadResult("main", live);
assert(state == IdentityLoadResult::Loaded);
assert(store.saveWithRetry("main", live));
}
}
@@ -160,6 +166,7 @@ int main() {
with self.subTest(role=role):
source = (ROOT / 'examples' / role / 'main.cpp').read_text()
self.assertIn('if (identity_ready) identity_ready = store.saveWithRetry(', source)
self.assertIn('IdentityLoadResult::Unreadable', source)
failed = extract_braced(source, 'if (!identity_ready)')
self.assertIn('board.reboot();', failed)
self.assertIn('halt();' if role == 'kiss_modem' else 'return;', failed)
+24 -34
View File
@@ -875,12 +875,12 @@ class Nrf52ExtraFsContractTest(unittest.TestCase):
self.assertIn("_identity_creation_blocked = true;", unmounted_branch)
self.assertIn("_contact_load_incomplete = true;", unmounted_branch)
self.assertIn("return;", unmounted_branch)
self.assertIn("_primary_storage_unavailable = true;", primary_failure_branch)
self.assertIn("_identity_creation_blocked = true;", primary_failure_branch)
self.assertIn("_contact_load_incomplete = true;", primary_failure_branch)
self.assertIn("return;", primary_failure_branch)
self.assertGreaterEqual(primary_failure_branch.count("delay(3000);"), 2)
self.assertIn("_fs->format()", primary_failure_branch)
self.assertIn("createRamFallbackFileSystem()", primary_failure_branch)
self.assertIn("useVolatilePrimaryFS", primary_failure_branch)
self.assertNotIn("recoverPrimaryFilesystem", store_begin)
self.assertNotIn("->format(", store_begin)
self.assertIn("IdentityLoadResult::Unreadable", store_begin)
secondary_failure = store_begin.index(
"if (_fsExtra != nullptr && !validateLfsFilesystem(_fsExtra))"
)
@@ -905,46 +905,36 @@ class Nrf52ExtraFsContractTest(unittest.TestCase):
setup = function_body(MAIN.read_text(encoding="utf-8"), "void setup()")
main = MAIN.read_text(encoding="utf-8")
primary_helper = (
ROOT / "src/helpers/nrf52/InternalPrimaryFsBoot.h"
).read_text(encoding="utf-8")
self.assertIn(
"static const uint32_t INTERNAL_PRIMARY_FS_START = 0x000ED000UL;",
main,
"static const uint32_t INTERNAL_PRIMARY_FS_START = 0xED000UL;",
primary_helper,
)
self.assertIn(
"static const uint32_t INTERNAL_PRIMARY_FS_START = 0x0006D000UL;",
main,
"static const uint32_t INTERNAL_PRIMARY_FS_START = 0x6D000UL;",
primary_helper,
)
self.assertIn("7UL * FLASH_NRF52_PAGE_SIZE", main)
self.assertIn("7UL * FLASH_NRF52_PAGE_SIZE", primary_helper)
primary_policy = setup.index(
"InternalSecondaryFsBootResult primary_fs_boot"
)
primary_mount = setup.index(
"InternalFS.Adafruit_LittleFS::begin()", primary_policy
)
blank_scan = setup.index("isErasedFlashRange(", primary_mount)
primary_format = setup.index("InternalFS.format()", blank_scan)
quarantine = setup.index("store.markPrimaryFSUnavailable()", primary_format)
store_begin = setup.index("store.begin()", quarantine)
self.assertLess(primary_policy, primary_mount)
self.assertLess(primary_mount, blank_scan)
self.assertLess(blank_scan, primary_format)
self.assertLess(primary_format, quarantine)
self.assertLess(quarantine, store_begin)
primary_policy_body = setup[primary_policy:quarantine]
self.assertIn("INTERNAL_PRIMARY_FS_START", primary_policy_body)
self.assertIn("INTERNAL_PRIMARY_FS_SIZE", primary_policy_body)
self.assertIn(
"InternalSecondaryFsBootResult::PreservedNonBlank",
primary_policy_body,
)
self.assertIn(
"InternalSecondaryFsBootResult::InitializationFailed",
primary_policy_body,
)
fallback = setup.index("createRamFallbackFileSystem()", primary_policy)
volatile_store = setup.index("store.useVolatilePrimaryFS", fallback)
store_begin = setup.index("store.begin()", volatile_store)
self.assertLess(primary_policy, fallback)
self.assertLess(fallback, volatile_store)
self.assertLess(volatile_store, store_begin)
self.assertIn("beginInternalPrimaryFilesystemSafely", setup)
self.assertGreaterEqual(primary_helper.count("delay(3000);"), 2)
self.assertIn("fs.format()", primary_helper)
self.assertIn("ReinitializedUnreadable", primary_helper)
# Never call the core override in the nRF path: it auto-erases a
# nonblank filesystem after any mount failure. The sole occurrence is
# the separately scoped STM32 fallback.
self.assertEqual(setup.count("InternalFS.begin();"), 1)
self.assertGreater(setup.index("#else\n InternalFS.begin();", primary_policy), primary_format)
self.assertGreater(setup.index("#else\n InternalFS.begin();", primary_policy), fallback)
self.assertIn("store.disableSecondaryFS(true);", setup)
secondary_geometry = setup.index(
"const bool extra_fs_geometry_valid ="
+16 -4
View File
@@ -69,16 +69,28 @@ int main() {
store = (ROOT / "examples/companion_radio/DataStore.cpp").read_text()
mesh = (ROOT / "examples/companion_radio/MyMesh.cpp").read_text()
device = (ROOT / "examples/companion_radio/ResilientInternalExtraFS.cpp").read_text()
device_header = (
ROOT / "examples/companion_radio/ResilientInternalExtraFS.h"
).read_text()
self.assertIn("reinitializeInternalExtraFS(true)", store)
self.assertIn("scan_physical_pages && !extra->scanAndRetireBadPages()", store)
self.assertIn("extra->requestBootScan()", store)
self.assertIn("extra->requestBootScan(true)", store)
self.assertIn("setBootScanRequest(marker)", device)
self.assertIn("BOOT_SCAN_ALL", device)
self.assertIn("BOOT_SCAN_BAD_PAGE_BASE = 0x20", device_header)
self.assertIn("BOOT_SCAN_REPEAT = 0x3E", device_header)
self.assertIn("BOOT_SCAN_ALL = 0x3F", device_header)
self.assertNotIn("BOOT_SCAN_REPEAT_BASE", device_header)
page_markers = set(range(0x20, 0x20 + 25))
recovery_markers = page_markers | {0x3E, 0x3F}
ota_markers = {0x51, 0x53, 0xA6, 0xD4, 0xED}
ota_markers.update(range(0x90, 0xA0))
ota_markers.update(range(0xB1, 0xC0))
ota_markers.update(range(0xC1, 0xCA))
self.assertFalse(recovery_markers & ota_markers)
self.assertIn("uint32_t bad = _bad_pages;", device)
self.assertNotIn("_bad_pages | (_pending_pages & PAGE_MASK)", device)
self.assertIn("return _boot_scan_forced ||", (
ROOT / "examples/companion_radio/ResilientInternalExtraFS.h"
).read_text())
self.assertIn("return _boot_scan_forced ||", device_header)
self.assertIn("extra->acknowledgeRecoveredBootHint()", store)
self.assertIn("extra->pageMapNeedsSave()", store)
scan_command = mesh.split("void MyMesh::scanInternalExtraFS(Stream& output)", 1)[1]
+22 -1
View File
@@ -14,13 +14,32 @@ spec.loader.exec_module(module)
class Nrf52InternalFlashFixTest(unittest.TestCase):
def test_wait_cannot_be_optimized_into_immediate_success(self):
source = "before\n" + module.OLD_WAIT + " do_wait();\n }\nafter\n"
source = ("before\n" + module.OLD_WAIT + " do_wait();\n }\n"
+ module.OLD_FLUSH + module.OLD_VERIFY + "after\n")
patched = module.patched_source(source)
self.assertIn("volatile uint8_t sd_en", patched)
self.assertIn('''__asm volatile ("" ::: "memory");''', patched)
self.assertIn("if (sd_en)", patched)
self.assertIn("mesh_flash_nrf5x_flush_checked", patched)
self.assertIn("volatile uint8_t const * flash", patched)
self.assertEqual(module.patched_source(patched), patched)
def test_cache_failures_are_sticky_until_checked_sync(self):
patched = module.patched_cache_source(module.OLD_CACHE_FLUSH)
self.assertIn("mesh_flash_cache_take_flush_result", patched)
self.assertIn("mesh_flash_cache_flush_ok = false", patched)
self.assertIn("fc->program", patched)
self.assertIn("fc->verify", patched)
self.assertEqual(module.patched_cache_source(patched), patched)
def test_internalfs_propagates_checked_flush_failure(self):
source = (module.OLD_INTERNAL_READ + module.OLD_INTERNAL_PROG
+ module.OLD_INTERNAL_ERASE_WRITE + module.OLD_INTERNAL_SYNC)
patched = module.patched_internal_fs_source(source)
self.assertIn("== (int) size", patched)
self.assertIn("mesh_flash_nrf5x_flush_checked() ? 0 : LFS_ERR_IO", patched)
self.assertEqual(module.patched_internal_fs_source(patched), patched)
def test_unrecognized_framework_fails_closed(self):
with self.assertRaises(RuntimeError):
module.patched_source("changed SDK layout")
@@ -29,6 +48,8 @@ class Nrf52InternalFlashFixTest(unittest.TestCase):
ini = (ROOT / "platformio.ini").read_text(encoding="utf-8")
self.assertIn("pre:scripts/nrf52_internal_flash_fix.py", ini)
self.assertIn('"*flash_nrf5x.c"', SCRIPT.read_text())
self.assertIn('"*flash_cache.c"', SCRIPT.read_text())
self.assertIn('"*InternalFileSystem.cpp"', SCRIPT.read_text())
# The hardware-in-loop images intentionally bypass nrf52_base, but
# still use the same framework and must not regress to its unsafe SVC
# flash-completion wait.