From c16c4a00d3073079fd761e724d3909da40ec0ee5 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sun, 16 Nov 2025 00:39:24 -0600 Subject: [PATCH] ck: Merged FSCK+CK -> CK flag namespace Unintentionally arriving at the infamous "fsck" name is a bit funny. But it's probably something we don't want to conflict with if we can help it, on the off chance we want a sort of lfs3_fsck function in the future. (This is all hypothetical, but lfs3_fsck may expect an unmounted filesystem, and have a much larger scope than lfs3_fs_ck. Though typing this out now I'm realizing how confusing that might be...) Since lfs3_file_ck and lfs3_fs_ck share a subset of flags, it's not _entirely_ unreasonable for lfs3_file_ck and lfs3_fs_ck to share the same namespace. There's a risk of confusing users around what flags lfs3_file_ck accepts, but we have asserts, and said flags (LFS3_CK_MKCONSISTENT, LFS3_CK_LOOKAHEAD, etc) just don't really make sense in lfs3_file_ck: fs file y LFS3_CK_MKCONSISTENT 0x00000800 Make the filesystem consistent y LFS3_CK_LOOKAHEAD 0x00001000 Repopulate lookahead buffer y LFS3_CK_LOOKGBMAP 0x00002000 Repopulate the gbmap y LFS3_CK_PREERASE* 0x00004000 Pre-erase unused blocks y LFS3_CK_COMPACTMETA 0x00008000 Compact metadata logs y y LFS3_CK_CKMETA 0x00010000 Check metadata checksums y y LFS3_CK_CKDATA 0x00020000 Check metadata + data checksums y y LFS3_CK_REPAIRMETA* 0x00040000 Repair data blocks y y LFS3_CK_REPAIRDATA* 0x00080000 Repair metadata + data blocks * Planned Another option would be to document that lfs3_fs_ck accepts both LFS3_CK_* _and_ LFS3_GC_* flags, but I worry that would be more confusing. It would also lock us into supporting all LFs3_GC_* flags in lfs3_fs_ck, which may not always be the case. Though this is an argument for doing away with the whole LFS3_M/F/CK/GC/I_* duplication... (tbh another reason for this is to reduce the number of namespaces by at least one). No code changes. --- lfs3.c | 27 +++++++++++++++++---------- lfs3.h | 35 +++++++---------------------------- scripts/dbgflags.py | 17 +++++------------ tests/test_ck.toml | 28 ++++++++++++++-------------- tests/test_gc.toml | 20 ++++++++++---------- 5 files changed, 53 insertions(+), 74 deletions(-) diff --git a/lfs3.c b/lfs3.c index 25ffe7da..59586fc0 100644 --- a/lfs3.c +++ b/lfs3.c @@ -12402,8 +12402,13 @@ int lfs3_file_opencfg_(lfs3_t *lfs3, lfs3_file_t *file, lfs3_handle_open(lfs3, &file->b.h); // check metadata/data for errors? - if (file->b.h.flags & LFS3_CK_ALL) { - err = lfs3_file_ck(lfs3, file, file->b.h.flags & LFS3_CK_ALL); + if (file->b.h.flags & ( + LFS3_CK_CKMETA + | LFS3_CK_CKDATA)) { + err = lfs3_file_ck(lfs3, file, + file->b.h.flags & ( + LFS3_CK_CKMETA + | LFS3_CK_CKDATA)); if (err) { lfs3_handle_close(lfs3, &file->b.h); goto failed; @@ -14537,8 +14542,10 @@ int lfs3_file_ck(lfs3_t *lfs3, lfs3_file_t *file, uint32_t flags) { LFS3_ASSERT(lfs3_handle_isopen(lfs3, &file->b.h)); // can't read from writeonly files LFS3_ASSERT(!lfs3_o_iswronly(file->b.h.flags)); - // unknown ck flags? - LFS3_ASSERT((flags & ~LFS3_CK_ALL) == 0); + // unknown ck flags? note only some ck flags work on files + LFS3_ASSERT((flags & ~( + LFS3_CK_CKMETA + | LFS3_CK_CKDATA)) == 0); // validate ungrafted data block? if (lfs3_t_isckdata(flags) @@ -15659,8 +15666,8 @@ int lfs3_mount(lfs3_t *lfs3, uint32_t flags, } // run gc if requested - if (flags & LFS3_FSCK_ALL) { - err = lfs3_fs_ck(lfs3, flags & LFS3_FSCK_ALL); + if (flags & LFS3_GC_ALL) { + err = lfs3_fs_ck(lfs3, flags & LFS3_GC_ALL); if (err) { goto failed; } @@ -15961,8 +15968,8 @@ int lfs3_format(lfs3_t *lfs3, uint32_t flags, } // run gc if requested - if (flags & LFS3_FSCK_ALL) { - err = lfs3_fs_ck(lfs3, flags & LFS3_FSCK_ALL); + if (flags & LFS3_GC_ALL) { + err = lfs3_fs_ck(lfs3, flags & LFS3_GC_ALL); if (err) { goto failed; } @@ -16305,7 +16312,7 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_mgc_t *mgc, // this just calls lfs3_fs_gc_ with unbounded steps int lfs3_fs_ck(lfs3_t *lfs3, uint32_t flags) { // unknown ck flags? - LFS3_ASSERT((flags & ~LFS3_FSCK_ALL) == 0); + LFS3_ASSERT((flags & ~LFS3_GC_ALL) == 0); // these flags require a writable filesystem LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) || !lfs3_t_ismkconsistent(flags)); @@ -16354,7 +16361,7 @@ int lfs3_fs_gc(lfs3_t *lfs3) { // unperform janitorial work int lfs3_fs_unck(lfs3_t *lfs3, uint32_t flags) { // unknown flags? - LFS3_ASSERT((flags & ~LFS3_FSCK_ALL) == 0); + LFS3_ASSERT((flags & ~LFS3_GC_ALL) == 0); // reset the requested flags lfs3->flags |= flags; diff --git a/lfs3.h b/lfs3.h index 25ae2be3..48a462bf 100644 --- a/lfs3.h +++ b/lfs3.h @@ -362,46 +362,25 @@ enum lfs3_btype { #define LFS3_t_DIRTY 0x02000000 // Filesystem ckpointed outside traversal #define LFS3_t_STALE 0x01000000 // Block queue probably out-of-date -// File check flags -#define LFS3_CK_CKMETA 0x00010000 // Check metadata checksums -#define LFS3_CK_CKDATA 0x00020000 // Check metadata + data checksums - -// an alias for all possible file check work -#define LFS3_CK_ALL ( \ - LFS3_GC_CKMETA \ - | LFS3_GC_CKDATA) - -// Filesystem check flags +// File/filesystem check flags #ifndef LFS3_RDONLY -#define LFS3_FSCK_MKCONSISTENT \ +#define LFS3_CK_MKCONSISTENT \ 0x00000800 // Make the filesystem consistent #endif #ifndef LFS3_RDONLY -#define LFS3_FSCK_LOOKAHEAD \ +#define LFS3_CK_LOOKAHEAD \ 0x00001000 // Repopulate lookahead buffer #endif #if !defined(LFS3_RDONLY) && defined(LFS3_GBMAP) -#define LFS3_FSCK_LOOKGBMAP \ +#define LFS3_CK_LOOKGBMAP \ 0x00002000 // Repopulate the gbmap #endif #ifndef LFS3_RDONLY -#define LFS3_FSCK_COMPACTMETA \ +#define LFS3_CK_COMPACTMETA \ 0x00008000 // Compact metadata logs #endif -#define LFS3_FSCK_CKMETA \ - 0x00010000 // Check metadata checksums -#define LFS3_FSCK_CKDATA \ - 0x00020000 // Check metadata + data checksums - -// an alias for all possible filesystem check work -#define LFS3_FSCK_ALL ( \ - LFS3_IFDEF_RDONLY(0, LFS3_FSCK_MKCONSISTENT) \ - | LFS3_IFDEF_RDONLY(0, LFS3_FSCK_LOOKAHEAD) \ - | LFS3_IFDEF_RDONLY(0, \ - LFS3_IFDEF_GBMAP(LFS3_FSCK_LOOKGBMAP, 0)) \ - | LFS3_IFDEF_RDONLY(0, LFS3_FSCK_COMPACTMETA) \ - | LFS3_FSCK_CKMETA \ - | LFS3_FSCK_CKDATA) +#define LFS3_CK_CKMETA 0x00010000 // Check metadata checksums +#define LFS3_CK_CKDATA 0x00020000 // Check metadata + data checksums // GC flags #ifndef LFS3_RDONLY diff --git a/scripts/dbgflags.py b/scripts/dbgflags.py index b5970b6d..c4594c78 100755 --- a/scripts/dbgflags.py +++ b/scripts/dbgflags.py @@ -15,7 +15,6 @@ PREFIX_A = ['--a', '--attr'] # Filter by LFS3_A_* flags PREFIX_F = ['--f', '--format'] # Filter by LFS3_F_* flags PREFIX_M = ['--m', '--mount'] # Filter by LFS3_M_* flags PREFIX_CK = ['--ck'] # Filter by LFS3_CK_* flags -PREFIX_FSCK = ['--fsck'] # Filter by LFS3_FSCK_* flags PREFIX_GC = ['--gc'] # Filter by LFS3_GC_* flags PREFIX_I = ['--i', '--info'] # Filter by LFS3_I_* flags PREFIX_T = ['--t', '--trv'] # Filter by LFS3_T_* flags @@ -109,20 +108,14 @@ M_COMPACTMETA = 0x00008000 # y- Compact metadata logs M_CKMETA = 0x00010000 # y- Check metadata checksums M_CKDATA = 0x00020000 # y- Check metadata + data checksums -# File check flags +# File/filesystem check flags +CK_MKCONSISTENT = 0x00000800 # -- Make the filesystem consistent +CK_LOOKAHEAD = 0x00001000 # -- Repopulate lookahead buffer +CK_LOOKGBMAP = 0x00002000 # -- Repopulate the gbmap +CK_COMPACTMETA = 0x00008000 # -- Compact metadata logs CK_CKMETA = 0x00010000 # -- Check metadata checksums CK_CKDATA = 0x00020000 # -- Check metadata + data checksums -# Filesystem check flags -FSCK_MKCONSISTENT \ - = 0x00000800 # -- Make the filesystem consistent -FSCK_LOOKAHEAD = 0x00001000 # -- Repopulate lookahead buffer -FSCK_LOOKGBMAP = 0x00002000 # -- Repopulate the gbmap -FSCK_COMPACTMETA \ - = 0x00008000 # -- Compact metadata logs -FSCK_CKMETA = 0x00010000 # -- Check metadata checksums -FSCK_CKDATA = 0x00020000 # -- Check metadata + data checksums - # GC flags GC_MKCONSISTENT = 0x00000800 # -- Make the filesystem consistent GC_LOOKAHEAD = 0x00001000 # -- Repopulate lookahead buffer diff --git a/tests/test_ck.toml b/tests/test_ck.toml index 129e6077..0ccbd0fc 100644 --- a/tests/test_ck.toml +++ b/tests/test_ck.toml @@ -270,7 +270,7 @@ code = ''' clobbered:; // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => LFS3_ERR_CORRUPT; + lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA) => LFS3_ERR_CORRUPT; // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { @@ -408,7 +408,7 @@ code = ''' clobbered:; // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => LFS3_ERR_CORRUPT; + lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA) => LFS3_ERR_CORRUPT; // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { @@ -552,7 +552,7 @@ code = ''' // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; @@ -808,7 +808,7 @@ code = ''' // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; @@ -2827,14 +2827,14 @@ code = ''' // run ckdata? if (CKDATA) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; @@ -3145,14 +3145,14 @@ code = ''' // run ckdata? if (CKDATA) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; @@ -3561,14 +3561,14 @@ code = ''' // run ckdata? if (CKDATA) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_open; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_open; @@ -3846,14 +3846,14 @@ code = ''' // run ckdata? if (CKDATA) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; @@ -4450,14 +4450,14 @@ code = ''' // run ckdata? if (CKDATA) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); + int err = lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; diff --git a/tests/test_gc.toml b/tests/test_gc.toml index 7cfe8964..7dc99b84 100644 --- a/tests/test_gc.toml +++ b/tests/test_gc.toml @@ -1378,7 +1378,7 @@ code = ''' clobbered:; // lfs3_fs_ckshould find the clobbered block - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => LFS3_ERR_CORRUPT; + lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA) => LFS3_ERR_CORRUPT; lfs3_unmount(&lfs3) => 0; } @@ -1469,7 +1469,7 @@ code = ''' clobbered:; // lfs3_fs_ckshould find the clobbered block - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => LFS3_ERR_CORRUPT; + lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA) => LFS3_ERR_CORRUPT; lfs3_unmount(&lfs3) => 0; } @@ -1565,7 +1565,7 @@ code = ''' // run lfs3_fs_ck } else if (AFTER == 3) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA) => 0; struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; @@ -1731,7 +1731,7 @@ code = ''' // run lfs3_fs_ck } else if (AFTER == 3) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA) => 0; struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; @@ -2010,11 +2010,11 @@ code = ''' } if (CKMETA && (fsinfo.flags & LFS3_I_CKMETA)) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA) => 0; } if (CKDATA && (fsinfo.flags & LFS3_I_CKDATA)) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA) => 0; } } @@ -2245,11 +2245,11 @@ code = ''' } if (CKMETA && (fsinfo.flags & LFS3_I_CKMETA)) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA) => 0; } if (CKDATA && (fsinfo.flags & LFS3_I_CKDATA)) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA) => 0; } } @@ -2416,11 +2416,11 @@ code = ''' } if (CKMETA && (fsinfo.flags & LFS3_I_CKMETA)) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKMETA) => 0; } if (CKDATA && (fsinfo.flags & LFS3_I_CKDATA)) { - lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; + lfs3_fs_ck(&lfs3, LFS3_CK_CKDATA) => 0; } }