Harden nRF52 filesystem recovery and flash writes
This commit is contained in:
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)
|
||||
|
||||
@@ -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 ="
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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.
|
||||
|
||||
Reference in new issue
Block a user