diff --git a/lfs3.c b/lfs3.c index a3e3b9f4..25ffe7da 100644 --- a/lfs3.c +++ b/lfs3.c @@ -12240,7 +12240,6 @@ static void lfs3_file_close_(lfs3_t *lfs3, const lfs3_file_t *file); static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, const lfs3_name_t *name); #endif -static int lfs3_file_ck(lfs3_t *lfs3, lfs3_file_t *file, uint32_t flags); int lfs3_file_opencfg_(lfs3_t *lfs3, lfs3_file_t *file, const char *path, uint32_t flags, @@ -12399,17 +12398,18 @@ int lfs3_file_opencfg_(lfs3_t *lfs3, lfs3_file_t *file, goto failed; } + // add to tracked mdirs + lfs3_handle_open(lfs3, &file->b.h); + // check metadata/data for errors? - if (lfs3_t_isckmeta(file->b.h.flags) - || lfs3_t_isckdata(file->b.h.flags)) { - err = lfs3_file_ck(lfs3, file, file->b.h.flags); + if (file->b.h.flags & LFS3_CK_ALL) { + err = lfs3_file_ck(lfs3, file, file->b.h.flags & LFS3_CK_ALL); if (err) { + lfs3_handle_close(lfs3, &file->b.h); goto failed; } } - // add to tracked mdirs - lfs3_handle_open(lfs3, &file->b.h); return 0; failed:; @@ -14532,9 +14532,14 @@ failed:; } #endif -// file check functions +// file check function +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); -static int lfs3_file_ck(lfs3_t *lfs3, lfs3_file_t *file, uint32_t flags) { // validate ungrafted data block? if (lfs3_t_isckdata(flags) && lfs3_o_isungraft(file->b.h.flags)) { @@ -14596,25 +14601,6 @@ static int lfs3_file_ck(lfs3_t *lfs3, lfs3_file_t *file, uint32_t flags) { return 0; } -int lfs3_file_ckmeta(lfs3_t *lfs3, lfs3_file_t *file) { - LFS3_ASSERT(lfs3_handle_isopen(lfs3, &file->b.h)); - // can't read from writeonly files - LFS3_ASSERT(!lfs3_o_iswronly(file->b.h.flags)); - - return lfs3_file_ck(lfs3, file, - LFS3_T_RDONLY | LFS3_T_CKMETA); -} - -int lfs3_file_ckdata(lfs3_t *lfs3, lfs3_file_t *file) { - LFS3_ASSERT(lfs3_handle_isopen(lfs3, &file->b.h)); - // can't read from writeonly files - LFS3_ASSERT(!lfs3_o_iswronly(file->b.h.flags)); - - // in 2-block mode this is a noop - return lfs3_file_ck(lfs3, file, - LFS3_T_RDONLY | LFS3_T_CKMETA | LFS3_T_CKDATA); -} - /// Simple key-value API /// @@ -14757,13 +14743,7 @@ static int lfs3_init(lfs3_t *lfs3, uint32_t flags, #ifdef LFS3_GC // unknown gc flags? - LFS3_ASSERT((lfs3->cfg->gc_flags & ~( - LFS3_GC_MKCONSISTENT - | LFS3_GC_LOOKAHEAD - | LFS3_IFDEF_GBMAP(LFS3_GC_LOOKGBMAP, 0) - | LFS3_GC_COMPACTMETA - | LFS3_GC_CKMETA - | LFS3_GC_CKDATA)) == 0); + LFS3_ASSERT((lfs3->cfg->gc_flags & ~LFS3_GC_ALL) == 0); // check that gc_compactmeta_thresh makes sense // @@ -15583,10 +15563,6 @@ static int lfs3_mountinited(lfs3_t *lfs3) { return 0; } -// needed in lfs3_mount -static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_mgc_t *mgc, - uint32_t flags, lfs3_soff_t steps); - int lfs3_mount(lfs3_t *lfs3, uint32_t flags, const struct lfs3_cfg *cfg) { #ifdef LFS3_YES_RDONLY @@ -15683,25 +15659,8 @@ int lfs3_mount(lfs3_t *lfs3, uint32_t flags, } // run gc if requested - if (flags & ( - LFS3_IFDEF_RDONLY(0, LFS3_M_MKCONSISTENT) - | LFS3_IFDEF_RDONLY(0, LFS3_M_LOOKAHEAD) - | LFS3_IFDEF_RDONLY(0, - LFS3_IFDEF_GBMAP(LFS3_M_LOOKGBMAP, 0)) - | LFS3_IFDEF_RDONLY(0, LFS3_M_COMPACTMETA) - | LFS3_M_CKMETA - | LFS3_M_CKDATA)) { - lfs3_mgc_t mgc; - err = lfs3_fs_gc_(lfs3, &mgc, - flags & ( - LFS3_IFDEF_RDONLY(0, LFS3_M_MKCONSISTENT) - | LFS3_IFDEF_RDONLY(0, LFS3_M_LOOKAHEAD) - | LFS3_IFDEF_RDONLY(0, - LFS3_IFDEF_GBMAP(LFS3_M_LOOKGBMAP, 0)) - | LFS3_IFDEF_RDONLY(0, LFS3_M_COMPACTMETA) - | LFS3_M_CKMETA - | LFS3_M_CKDATA), - -1); + if (flags & LFS3_FSCK_ALL) { + err = lfs3_fs_ck(lfs3, flags & LFS3_FSCK_ALL); if (err) { goto failed; } @@ -16002,23 +15961,8 @@ int lfs3_format(lfs3_t *lfs3, uint32_t flags, } // run gc if requested - if (flags & ( - LFS3_F_MKCONSISTENT - | LFS3_F_LOOKAHEAD - | LFS3_IFDEF_GBMAP(LFS3_F_LOOKGBMAP, 0) - | LFS3_F_COMPACTMETA - | LFS3_F_CKMETA - | LFS3_F_CKDATA)) { - lfs3_mgc_t mgc; - err = lfs3_fs_gc_(lfs3, &mgc, - flags & ( - LFS3_F_MKCONSISTENT - | LFS3_F_LOOKAHEAD - | LFS3_IFDEF_GBMAP(LFS3_F_LOOKGBMAP, 0) - | LFS3_F_COMPACTMETA - | LFS3_F_CKMETA - | LFS3_F_CKDATA), - -1); + if (flags & LFS3_FSCK_ALL) { + err = lfs3_fs_ck(lfs3, flags & LFS3_FSCK_ALL); if (err) { goto failed; } @@ -16103,6 +16047,12 @@ lfs3_ssize_t lfs3_fs_usage(lfs3_t *lfs3) { return count; } +// get the filesystem checksum +int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum) { + *cksum = lfs3->gcksum; + return 0; +} + // consistency stuff @@ -16272,58 +16222,12 @@ int lfs3_fs_mkconsistent(lfs3_t *lfs3) { } #endif -// filesystem check functions -static int lfs3_fs_ck(lfs3_t *lfs3, uint32_t flags) { - // we leave this up to lfs3_mtree_traverse - lfs3_mtrv_t mtrv; - lfs3_mtrv_init(&mtrv, flags); - while (true) { - lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &mtrv, - &bptr); - if (tag < 0) { - if (tag == LFS3_ERR_NOENT) { - break; - } - return tag; - } - } - - return 0; -} - -int lfs3_fs_ckmeta(lfs3_t *lfs3) { - return lfs3_fs_ck(lfs3, LFS3_T_RDONLY | LFS3_T_CKMETA); -} - -int lfs3_fs_ckdata(lfs3_t *lfs3) { - return lfs3_fs_ck(lfs3, LFS3_T_RDONLY | LFS3_T_CKMETA | LFS3_T_CKDATA); -} - -// get the filesystem checksum -int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum) { - *cksum = lfs3->gcksum; - return 0; -} - // low-level filesystem gc // // runs the traversal until all work is completed, which may take // multiple passes static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_mgc_t *mgc, uint32_t flags, lfs3_soff_t steps) { - // unknown gc flags? - LFS3_ASSERT((flags & ~LFS3_GC_ALL) == 0); - // these flags require a writable filesystem - LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) - || !lfs3_t_ismkconsistent(flags)); - LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) - || !lfs3_t_islookahead(flags)); - LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) - || !lfs3_t_islookgbmap(flags)); - LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) - || !lfs3_t_compactmeta(flags)); - // fix pending grms if requested #ifndef LFS3_RDONLY if (lfs3_t_ismkconsistent(flags) @@ -16336,7 +16240,7 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_mgc_t *mgc, #endif // do we have any pending work? - uint32_t pending = flags & (lfs3->flags & LFS3_GC_ALL); + uint32_t pending = flags & lfs3->flags & LFS3_GC_ALL; while (pending && (lfs3_off_t)steps > 0) { // start a new traversal? @@ -16376,13 +16280,13 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_mgc_t *mgc, lfs3_stag_t tag = lfs3_mtree_gc(lfs3, mgc, &bptr); if (tag < 0 && tag != LFS3_ERR_NOENT) { + lfs3_handle_close(lfs3, &mgc->t.h); return tag; } // end of traversal? if (tag == LFS3_ERR_NOENT) { lfs3_handle_close(lfs3, &mgc->t.h); - // clear any pending flags we make progress on pending &= lfs3->flags & LFS3_GC_ALL; } @@ -16396,11 +16300,49 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_mgc_t *mgc, return 0; } +// filesystem check function +// +// 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); + // these flags require a writable filesystem + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_ismkconsistent(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_islookahead(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_islookgbmap(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_compactmeta(flags)); + + // set needs-ck flags, this has the side-effect of signaling ck work + // is incomplete if we encounter an error, which is probably a good + // thing + lfs3->flags |= flags & (LFS3_I_CKMETA | LFS3_I_CKDATA); + + lfs3_mgc_t mgc; + return lfs3_fs_gc_(lfs3, &mgc, flags, -1); +} + // incremental filesystem gc // // perform any pending janitorial work #ifdef LFS3_GC int lfs3_fs_gc(lfs3_t *lfs3) { + // unknown gc flags? + LFS3_ASSERT((lfs3->cfg->gc_flags & ~LFS3_GC_ALL) == 0); + // these flags require a writable filesystem + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_ismkconsistent(lfs3->cfg->gc_flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_islookahead(lfs3->cfg->gc_flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_islookgbmap(lfs3->cfg->gc_flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) + || !lfs3_t_compactmeta(lfs3->cfg->gc_flags)); + + // run gc a configurable number of steps return lfs3_fs_gc_(lfs3, &lfs3->gc, lfs3->cfg->gc_flags, (lfs3->cfg->gc_steps) @@ -16412,14 +16354,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_IFDEF_RDONLY(0, LFS3_I_MKCONSISTENT) - | LFS3_IFDEF_RDONLY(0, LFS3_I_LOOKAHEAD) - | LFS3_IFDEF_RDONLY(0, - LFS3_IFDEF_GBMAP(LFS3_I_LOOKGBMAP, 0)) - | LFS3_IFDEF_RDONLY(0, LFS3_I_COMPACTMETA) - | LFS3_I_CKMETA - | LFS3_I_CKDATA)) == 0); + LFS3_ASSERT((flags & ~LFS3_FSCK_ALL) == 0); // reset the requested flags lfs3->flags |= flags; diff --git a/lfs3.h b/lfs3.h index 7e4c6213..25ae2be3 100644 --- a/lfs3.h +++ b/lfs3.h @@ -362,6 +362,47 @@ 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 +#ifndef LFS3_RDONLY +#define LFS3_FSCK_MKCONSISTENT \ + 0x00000800 // Make the filesystem consistent +#endif +#ifndef LFS3_RDONLY +#define LFS3_FSCK_LOOKAHEAD \ + 0x00001000 // Repopulate lookahead buffer +#endif +#if !defined(LFS3_RDONLY) && defined(LFS3_GBMAP) +#define LFS3_FSCK_LOOKGBMAP \ + 0x00002000 // Repopulate the gbmap +#endif +#ifndef LFS3_RDONLY +#define LFS3_FSCK_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) + // GC flags #ifndef LFS3_RDONLY #define LFS3_GC_MKCONSISTENT \ @@ -1550,17 +1591,11 @@ int lfs3_file_rewind(lfs3_t *lfs3, lfs3_file_t *file); // Returns the size of the file, or a negative error code on failure. lfs3_soff_t lfs3_file_size(lfs3_t *lfs3, lfs3_file_t *file); -// Check a file for metadata errors +// Check a file for errors and other work // // Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative // error code on failure. -int lfs3_file_ckmeta(lfs3_t *lfs3, lfs3_file_t *file); - -// Check a file for metadata + data errors -// -// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative -// error code on failure. -int lfs3_file_ckdata(lfs3_t *lfs3, lfs3_file_t *file); +int lfs3_file_ck(lfs3_t *lfs3, lfs3_file_t *file, uint32_t flags); /// Directory operations /// @@ -1660,30 +1695,6 @@ int lfs3_fs_stat(lfs3_t *lfs3, struct lfs3_fsinfo *fsinfo); // Returns the number of allocated blocks, or a negative error code on failure. lfs3_ssize_t lfs3_fs_usage(lfs3_t *lfs3); -// Attempt to make the filesystem consistent and ready for writing -// -// Calling this function is not required, consistency will be implicitly -// enforced on the first operation that writes to the filesystem, but this -// function allows the work to be performed earlier and without other -// filesystem changes. -// -// Returns a negative error code on failure. -#ifndef LFS3_RDONLY -int lfs3_fs_mkconsistent(lfs3_t *lfs3); -#endif - -// Check the filesystem for metadata errors -// -// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative -// error code on failure. -int lfs3_fs_ckmeta(lfs3_t *lfs3); - -// Check the filesystem for metadata + data errors -// -// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative -// error code on failure. -int lfs3_fs_ckdata(lfs3_t *lfs3); - // Get the current filesystem checksum // // This is a checksum of all metadata + data in the filesystem, which @@ -1700,6 +1711,27 @@ int lfs3_fs_ckdata(lfs3_t *lfs3); // Returns a negative error code on failure. int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum); +// Attempt to make the filesystem consistent and ready for writing +// +// Calling this function is not required, consistency will be implicitly +// enforced on the first operation that writes to the filesystem, but this +// function allows the work to be performed earlier and without other +// filesystem changes. +// +// Returns a negative error code on failure. +#ifndef LFS3_RDONLY +int lfs3_fs_mkconsistent(lfs3_t *lfs3); +#endif + +// Check the filesystem for errors and other work +// +// This actually supports all janitorial work, but spins until all work +// is complete. See lfs3_fs_gc for incremental gc. +// +// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative +// error code on failure. +int lfs3_fs_ck(lfs3_t *lfs3, uint32_t flags); + // Perform any janitorial work that may be pending // // The exact janitorial work depends on the configured flags and steps. diff --git a/scripts/dbgflags.py b/scripts/dbgflags.py index 11b60daf..b5970b6d 100755 --- a/scripts/dbgflags.py +++ b/scripts/dbgflags.py @@ -14,6 +14,8 @@ PREFIX_SEEK = ['--seek'] # Filter by LFS3_SEEK_* flags 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 @@ -107,6 +109,20 @@ 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 +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 6949e19b..129e6077 100644 --- a/tests/test_ck.toml +++ b/tests/test_ck.toml @@ -180,7 +180,7 @@ code = ''' # test we can detect at least fully clobbered blocks [cases.test_ck_ckmeta_easy] -# METHOD=0 => lfs3_fs_ckmeta +# METHOD=0 => lfs3_fs_ck # METHOD=1 => lfs3_fs_gc # METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount @@ -268,9 +268,9 @@ code = ''' } clobbered:; - // find clobbered blocks with lfs3_fs_ckmeta + // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - lfs3_fs_ckmeta(&lfs3) => LFS3_ERR_CORRUPT; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => LFS3_ERR_CORRUPT; // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { @@ -317,7 +317,7 @@ done:; ''' [cases.test_ck_ckdata_easy] -# METHOD=0 => lfs3_fs_ckdata +# METHOD=0 => lfs3_fs_ck # METHOD=1 => lfs3_fs_gc # METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount @@ -406,9 +406,9 @@ code = ''' } clobbered:; - // find clobbered blocks with lfs3_fs_ckmeta + // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - lfs3_fs_ckdata(&lfs3) => LFS3_ERR_CORRUPT; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => LFS3_ERR_CORRUPT; // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { @@ -456,7 +456,7 @@ done:; # test some more interesting errors [cases.test_ck_ckmeta_hard] -# METHOD=0 => lfs3_fs_ckmeta +# METHOD=0 => lfs3_fs_ck # METHOD=1 => lfs3_fs_gc # METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount @@ -550,9 +550,9 @@ code = ''' printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfs3_fs_ckmeta + // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - int err = lfs3_fs_ckmeta(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; @@ -711,7 +711,7 @@ done:; ''' [cases.test_ck_ckdata_hard] -# METHOD=0 => lfs3_fs_ckdata +# METHOD=0 => lfs3_fs_ck # METHOD=1 => lfs3_fs_gc # METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount @@ -806,9 +806,9 @@ code = ''' printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfs3_fs_ckdata + // find clobbered blocks with lfs3_fs_ck if (METHOD == 0) { - int err = lfs3_fs_ckdata(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; @@ -971,8 +971,8 @@ done:; # test we can detect at least fully clobbered blocks [cases.test_ck_file_ckmeta_easy] -# METHOD=0 => lfs3_file_ckmeta -# METHOD=1 => lfs3_file_close+open+ckmeta +# METHOD=0 => lfs3_file_ck +# METHOD=1 => lfs3_file_close+open+ck # METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1042,15 +1042,15 @@ code = ''' } clobbered:; - // find clobbered blocks with lfs3_file_ckmeta + // find clobbered blocks with lfs3_file_ck if (METHOD == 0) { - lfs3_file_ckmeta(&lfs3, &file) => LFS3_ERR_CORRUPT; + lfs3_file_ck(&lfs3, &file, LFS3_CK_CKMETA) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfs3_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ck } else if (METHOD == 1) { lfs3_file_close(&lfs3, &file) => 0; lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; - lfs3_file_ckmeta(&lfs3, &file) => LFS3_ERR_CORRUPT; + lfs3_file_ck(&lfs3, &file, LFS3_CK_CKMETA) => LFS3_ERR_CORRUPT; // find clobbered blocks with lfs3_file_close+open } else if (METHOD == 2) { @@ -1070,8 +1070,8 @@ done:; ''' [cases.test_ck_file_ckdata_easy] -# METHOD=0 => lfs3_file_ckdata -# METHOD=1 => lfs3_file_close+open+ckdata +# METHOD=0 => lfs3_file_ck +# METHOD=1 => lfs3_file_close+open+ck # METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1142,15 +1142,15 @@ code = ''' } clobbered:; - // find clobbered blocks with lfs3_file_ckmeta + // find clobbered blocks with lfs3_file_ck if (METHOD == 0) { - lfs3_file_ckdata(&lfs3, &file) => LFS3_ERR_CORRUPT; + lfs3_file_ck(&lfs3, &file, LFS3_CK_CKDATA) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfs3_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ck } else if (METHOD == 1) { lfs3_file_close(&lfs3, &file) => 0; lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; - lfs3_file_ckdata(&lfs3, &file) => LFS3_ERR_CORRUPT; + lfs3_file_ck(&lfs3, &file, LFS3_CK_CKDATA) => LFS3_ERR_CORRUPT; // find clobbered blocks with lfs3_file_close+open } else if (METHOD == 2) { @@ -1172,8 +1172,8 @@ done:; # test some more interesting errors [cases.test_ck_file_ckmeta_hard] -# METHOD=0 => lfs3_file_ckmeta -# METHOD=1 => lfs3_file_close+open+ckmeta +# METHOD=0 => lfs3_file_ck +# METHOD=1 => lfs3_file_close+open+ck # METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1251,19 +1251,19 @@ code = ''' printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfs3_file_ckmeta + // find clobbered blocks with lfs3_file_ck if (METHOD == 0) { - int err = lfs3_file_ckmeta(&lfs3, &file); + int err = lfs3_file_ck(&lfs3, &file, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfs3_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ck } else if (METHOD == 1) { lfs3_file_close(&lfs3, &file) => 0; lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; - int err = lfs3_file_ckmeta(&lfs3, &file); + int err = lfs3_file_ck(&lfs3, &file, LFS3_CK_CKMETA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; @@ -1322,8 +1322,8 @@ done:; ''' [cases.test_ck_file_ckdata_hard] -# METHOD=0 => lfs3_file_ckdata -# METHOD=1 => lfs3_file_close+open+ckdata +# METHOD=0 => lfs3_file_ck +# METHOD=1 => lfs3_file_close+open+ck # METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1402,9 +1402,9 @@ code = ''' printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfs3_file_ckdata + // find clobbered blocks with lfs3_file_ck if (METHOD == 0) { - int err = lfs3_file_ckdata(&lfs3, &file); + int err = lfs3_file_ck(&lfs3, &file, LFS3_CK_CKDATA); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { goto detected; @@ -1414,7 +1414,7 @@ code = ''' } else if (METHOD == 1) { lfs3_file_close(&lfs3, &file) => 0; lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; - int err = lfs3_file_ckdata(&lfs3, &file); + int err = lfs3_file_ck(&lfs3, &file, 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_ckdata(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckmeta(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckdata(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckmeta(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckdata(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckmeta(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckdata(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckmeta(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckdata(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckmeta(&lfs3); + int err = lfs3_fs_ck(&lfs3, LFS3_FSCK_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 d473d8b3..7cfe8964 100644 --- a/tests/test_gc.toml +++ b/tests/test_gc.toml @@ -1293,7 +1293,7 @@ code = ''' done:; ''' -# test that our explicit functions (lfs3_fs_ckmeta/ckdata) work as well, +# test that our explicit functions (lfs3_fs_ck) work as well, # these call the same logic internally [cases.test_gc_ckmeta_explicit] defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1377,8 +1377,8 @@ code = ''' } clobbered:; - // lfs3_fs_ckmeta should find the clobbered block - lfs3_fs_ckmeta(&lfs3) => LFS3_ERR_CORRUPT; + // lfs3_fs_ckshould find the clobbered block + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => LFS3_ERR_CORRUPT; lfs3_unmount(&lfs3) => 0; } @@ -1468,8 +1468,8 @@ code = ''' } clobbered:; - // lfs3_fs_ckdata should find the clobbered block - lfs3_fs_ckdata(&lfs3) => LFS3_ERR_CORRUPT; + // lfs3_fs_ckshould find the clobbered block + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => LFS3_ERR_CORRUPT; lfs3_unmount(&lfs3) => 0; } @@ -1482,7 +1482,7 @@ done:; # AFTER=0 => after running lfs3_fs_gc once # AFTER=1 => after running lfs3_fs_gc to completion # AFTER=2 => after running lfs3_trv_t -# AFTER=3 => after lfs3_fs_ckmeta +# AFTER=3 => after lfs3_fs_ck # AFTER=4 => after remounting with LFS3_M_CKMETA defines.AFTER = [0, 1, 2, 3, 4] defines.GC_FLAGS = 'LFS3_GC_CKMETA' @@ -1563,9 +1563,9 @@ code = ''' } lfs3_trv_close(&lfs3, &trv) => 0; - // run lfs3_fs_ckmeta + // run lfs3_fs_ck } else if (AFTER == 3) { - lfs3_fs_ckmeta(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; @@ -1648,7 +1648,7 @@ done:; # AFTER=0 => after running lfs3_fs_gc once # AFTER=1 => after running lfs3_fs_gc to completion # AFTER=2 => after running lfs3_trv_t -# AFTER=3 => after lfs3_fs_ckdata +# AFTER=3 => after lfs3_fs_ck # AFTER=4 => after remounting with LFS3_M_CKDATA defines.AFTER = [0, 1, 2, 3, 4] defines.GC_FLAGS = 'LFS3_GC_CKDATA' @@ -1729,9 +1729,9 @@ code = ''' } lfs3_trv_close(&lfs3, &trv) => 0; - // run lfs3_fs_ckdata + // run lfs3_fs_ck } else if (AFTER == 3) { - lfs3_fs_ckdata(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_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_ckmeta(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; } if (CKDATA && (fsinfo.flags & LFS3_I_CKDATA)) { - lfs3_fs_ckdata(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; } } @@ -2245,11 +2245,11 @@ code = ''' } if (CKMETA && (fsinfo.flags & LFS3_I_CKMETA)) { - lfs3_fs_ckmeta(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; } if (CKDATA && (fsinfo.flags & LFS3_I_CKDATA)) { - lfs3_fs_ckdata(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; } } @@ -2416,11 +2416,11 @@ code = ''' } if (CKMETA && (fsinfo.flags & LFS3_I_CKMETA)) { - lfs3_fs_ckmeta(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKMETA) => 0; } if (CKDATA && (fsinfo.flags & LFS3_I_CKDATA)) { - lfs3_fs_ckdata(&lfs3) => 0; + lfs3_fs_ck(&lfs3, LFS3_FSCK_CKDATA) => 0; } }