Github/littlefs
1
Fork 0
Code Actions Activity

ck: Traded ckmeta/ckdata for flag-based ck functions

Browse Source 
TLDR: Replaced lfs3_file_ckmeta/ckdata and lfs3_fs_ckmeta/ckdata with
flag based ck functions:

- lfs3_file_ckmeta -> lfs3_file_ck + LFS3_CK_CKMETA
- lfs3_file_ckdata -> lfs3_file_ck + LFS3_CK_CKDATA
- lfs3_fs_ckmeta -> lfs3_fs_ck + LFS3_FSCK_CKMETA
- lfs3_fs_ckdata -> lfs3_fs_ck + LFS3_FSCK_CKDATA

Note lfs3_fs_ck is equivalent to lfs3_fs_gc, but:

1. Performs the work in one call (equivalent to littlefs2's lfs2_fs_gc)
2. Takes flags at call time (like lfs3_mount) instead of cfg time (like
   lfs3_fs_gc)
3. Avoids the constant RAM necessary to track incremental GC state

---

Motivation:

I've been thinking: It's a bit weird that users are able to one-shot
janitorial work in lfs3_mount, but there's no equivalent function after
the filesystem is mounted.

Originally this is what lfs3_fs_gc was for, but after adding support for
incremental GC, it made sense to hide lfs3_fs_gc behind the opt-in
LFS3_GC ifdef due to the extra (ironically non-gc-able) state.

In theory lfs3_trv_t fills a bit of the gap, but, without the internal
i_flag handling and traversal restarts, it's a bit hard to use. And
basically requires duplicating said log, which we need anyways for
lfs3_mount!

So ideally we'd add an explicit one-shot GC function, but now lfs3_fs_gc
is taken.

While thinking about alternative names, I realized we can just call this
lfs3_fs_ck and completely replace lfs3_fs_ckmeta/ckdata.

This has some extra benefits:

- Avoids an explosion of ckmeta/ckdata/repairmeta/repairdata functions
- Discourages redundant traversals that could accomplish more work
- Makes it less confusing that ckdata implies ckmeta

---

I also tweaked lfs3_file_ck to match, but note that lfs3_file_ck is
internally very different from lfs3_fs_ck. For one, lfs3_file_ck only
supports "actual" check flags (LFS3_CK_*) vs all gc flags (LFS3_FSCK_*):

lfs3_file_ck:

  LFS3_CK_CKMETA          0x00010000  Check metadata checksums
  LFS3_CK_CKDATA          0x00020000  Check metadata + data checksums
  LFS3_CK_REPAIRMETA*     0x00040000  Repair metadata blocks
  LFS3_CK_REPAIRDATA*     0x00080000  Repair metadata + data blocks

  * Planned

lfs3_fs_ck:

  LFS3_FSCK_MKCONSISTENT  0x00000800  Make the filesystem consistent
  LFS3_FSCK_LOOKAHEAD     0x00001000  Repopulate lookahead buffer
  LFS3_FSCK_LOOKGBMAP     0x00002000  Repopulate the gbmap
  LFS3_FSCK_PREERASE*     0x00004000  Pre-erase unused blocks
  LFS3_FSCK_COMPACTMETA   0x00008000  Compact metadata logs
  LFS3_FSCK_CKMETA        0x00010000  Check metadata checksums
  LFS3_FSCK_CKDATA        0x00020000  Check metadata + data checksums
  LFS3_FSCK_REPAIRMETA*   0x00040000  Repair metadata blocks
  LFS3_FSCK_REPAIRDATA*   0x00080000  Repair metadata + data blocks

  * Planned

As a plus, this also saves a bit of code:

                 code          stack          ctx
  before:       35968           2280          660
  after:        35924 (-0.1%)   2280 (+0.0%)  660 (+0.0%)

                 code          stack          ctx
  gbmap before: 38828           2296          772
  gbmap after:  38812 (-0.0%)   2296 (+0.0%)  772 (+0.0%)
This commit is contained in:
Christopher Haster
2025-11-15 23:27:25 -06:00
parent ad2e8b3498
commit 5c0cebb00b
5 changed files with 207 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs3.c
+65 -130
View File
@@ -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;
lfs3.h
+64 -32
View File
@@ -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.
scripts/dbgflags.py
+16
View File
@@ -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
tests/test_ck.toml
+45 -45
View File
@@ -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;
tests/test_gc.toml
+17 -17
View File
@@ -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;
}
}