Github/littlefs
1
Fork 0
Code Actions Activity

gc: Added more tests over info flags, dropped gc_flags default

Browse Source 
Since we dropped lfsr_gc_setflags/setsteps, it was no longer possible to
set gc_flags to zero (perfectly valid and useful for system bringup/
testing things). Supporting gc_flags=0 means it's not possible to
provide a default, but this is probably ok as users need to opt-in to
LFS_GC anyways.

Note that at least gc_steps=0 doesn't make sense, so the default there
is reasonable.

Fixing this also highlighted that gc_flags/steps are no longer mutable,
making the comment in lfs_init out-of-date. Dropping these saves a bit
of lfs_t size, so that's nice.

And then testing also revealed that LFS_GC_CKDATA implying LFS_GC_CKDATA
means it should probably clear the LFS_I_CKMETA flag as well.

---

And here I thought this was going to be just a simple test-writing
exercise!

Code changes:

                   code          stack          ctx
  default before: 37792           2608          620
  default after:  37792 (-0.0%)   2608 (+0.0%)  620 (+0.0%)

  gc before:      37896           2608          768
  gc after:       37848 (-0.1%)   2608 (+0.0%)  760 (-1.0%)
This commit is contained in:
Christopher Haster
2025-01-08 16:02:36 -06:00
parent bb4e6cca2c
commit 9ed9cf0ccd
5 changed files with 600 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+6 -18
View File
@@ -9646,7 +9646,8 @@ eot:;
&& !lfsr_t_ismtreeonly(t->o.o.flags)
&& !lfsr_t_isdirty(t->o.o.flags)
&& !lfsr_t_ismutated(t->o.o.flags)) {
lfs->flags &= ~LFS_I_CKDATA;
// note ckdata implies ckmeta
lfs->flags &= ~LFS_I_CKDATA & ~LFS_I_CKMETA;
}
return LFS_ERR_NOENT;
@@ -13383,22 +13384,6 @@ static int lfs_init(lfs_t *lfs, uint32_t flags,
lfs_memset(lfs->grm_p, 0, LFSR_GRM_DSIZE);
lfs_memset(lfs->grm_d, 0, LFSR_GRM_DSIZE);
#ifdef LFS_GC
// setup gc state, this can be mutated which is why we need a copy
if (lfs->cfg->gc_flags) {
lfs->gc.flags = lfs->cfg->gc_flags;
} else {
lfs->gc.flags = LFS_GC_MKCONSISTENT
| LFS_GC_LOOKAHEAD
| LFS_GC_COMPACT;
}
if (lfs->cfg->gc_steps) {
lfs->gc.steps = lfs->cfg->gc_steps;
} else {
lfs->gc.steps = 1;
}
#endif
return 0;
failed:;
@@ -14542,7 +14527,10 @@ static int lfsr_fs_gc_(lfs_t *lfs, lfsr_traversal_t *t,
// perform any pending janitorial work
int lfsr_fs_gc(lfs_t *lfs) {
return lfsr_fs_gc_(lfs, &lfs->gc.t,
lfs->gc.flags, lfs->gc.steps);
lfs->cfg->gc_flags,
(lfs->cfg->gc_steps)
? lfs->cfg->gc_steps
: 1);
}
#endif
lfs.h
-5
View File
@@ -349,9 +349,6 @@ struct lfs_config {
#ifdef LFS_GC
// Flags indicating what gc work to do during lfsr_gc calls.
//
// Defaults to LFS_GC_MKCONSISTENT + LFS_GC_LOOKAHEAD +
// LFS_GC_COMPACT when zero.
uint32_t gc_flags;
#endif
@@ -880,8 +877,6 @@ typedef struct lfs {
#ifdef LFS_GC
struct {
uint32_t flags;
lfs_soff_t steps;
lfsr_traversal_t t;
} gc;
#endif
tests/test_gc.toml
+542 -10
View File
@@ -1050,9 +1050,10 @@ done:;
[cases.test_gc_ckmeta_unck]
# AFTER=0 => after running lfsr_fs_gc once
# AFTER=1 => after running lfsr_fs_gc to completion
# AFTER=2 => after lfsr_fs_ckmeta
# AFTER=3 => after remounting with LFS_M_CKMETA
defines.AFTER = [0, 1, 2, 3]
# AFTER=2 => after running lfsr_traversal_t
# AFTER=3 => after lfsr_fs_ckmeta
# AFTER=4 => after remounting with LFS_M_CKMETA
defines.AFTER = [0, 1, 2, 3, 4]
defines.GC_FLAGS = 'LFS_GC_CKMETA'
defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000]
defines.N = [1, 2, 4, 8, 16, 32, 64]
@@ -1114,8 +1115,22 @@ code = '''
lfsr_fs_gc(&lfs) => 0;
}
// run lfsr_fs_ckmeta
// run lfsr_traversal_t
} else if (AFTER == 2) {
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, GC_FLAGS) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
// run lfsr_fs_ckmeta
} else if (AFTER == 3) {
lfsr_fs_ckmeta(&lfs) => 0;
struct lfs_fsinfo fsinfo;
@@ -1123,7 +1138,7 @@ code = '''
assert(!(fsinfo.flags & LFS_I_CKMETA));
// remount with LFS_M_CKMETA
} else if (AFTER == 3) {
} else if (AFTER == 4) {
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETA, CFG) => 0;
@@ -1198,9 +1213,10 @@ done:;
[cases.test_gc_ckdata_unck]
# AFTER=0 => after running lfsr_fs_gc once
# AFTER=1 => after running lfsr_fs_gc to completion
# AFTER=2 => after lfsr_fs_ckdata
# AFTER=3 => after remounting with LFS_M_CKDATA
defines.AFTER = [0, 1, 2]
# AFTER=2 => after running lfsr_traversal_t
# AFTER=3 => after lfsr_fs_ckdata
# AFTER=4 => after remounting with LFS_M_CKDATA
defines.AFTER = [0, 1, 2, 3, 4]
defines.GC_FLAGS = 'LFS_GC_CKDATA'
defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000]
defines.N = [1, 2, 4, 8, 16, 32, 64]
@@ -1262,8 +1278,22 @@ code = '''
lfsr_fs_gc(&lfs) => 0;
}
// run lfsr_fs_ckdata
// run lfsr_traversal_t
} else if (AFTER == 2) {
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, GC_FLAGS) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
// run lfsr_fs_ckdata
} else if (AFTER == 3) {
lfsr_fs_ckdata(&lfs) => 0;
struct lfs_fsinfo fsinfo;
@@ -1271,7 +1301,7 @@ code = '''
assert(!(fsinfo.flags & LFS_I_CKDATA));
// remount with LFS_M_CKDATA
} else if (AFTER == 3) {
} else if (AFTER == 4) {
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATA, CFG) => 0;
@@ -1347,6 +1377,508 @@ done:;
'''
# test that gc work clears flags in lfsr_fs_stat
[cases.test_gc_iflags]
# AFTER=0 => after running lfsr_fs_gc
# AFTER=1 => after running lfsr_traversal_t
# AFTER=2 => after explicit operations
# AFTER=3 => after remounting
defines.AFTER = [0, 1, 2, 3]
defines.MKCONSISTENT = [false, true]
defines.LOOKAHEAD = [false, true]
defines.COMPACT = [false, true]
defines.CKMETA = [false, true]
defines.CKDATA = [false, true]
defines.GC_FLAGS = '''
((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_GC_COMPACT : 0)
| ((CKMETA) ? LFS_GC_CKMETA : 0)
| ((CKDATA) ? LFS_GC_CKDATA : 0)
'''
defines.GC_STEPS = -1
defines.N = [1, 2, 4, 8, 16, 32, 64]
defines.SIZE = [
'0',
'FILE_BUFFER_SIZE/2',
'2*FILE_BUFFER_SIZE',
'BLOCK_SIZE/2',
'BLOCK_SIZE',
'2*BLOCK_SIZE',
'8*BLOCK_SIZE',
]
if = [
'(SIZE*N)/BLOCK_SIZE <= 32',
'LFS_IFDEF_GC(true, AFTER != 0)',
]
code = '''
lfs_t lfs;
lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0;
lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
// create an interesting filesystem
uint32_t prng = 42;
for (lfs_size_t i = 0; i < N; i++) {
char name[256];
sprintf(name, "squid%03x", i);
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
}
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name,
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE;
lfsr_file_close(&lfs, &file) => 0;
}
// remount to reset flags
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
// check that flags were reset
struct lfs_fsinfo fsinfo;
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
LFS_I_MKCONSISTENT
| LFS_I_LOOKAHEAD
| LFS_I_COMPACT
| LFS_I_CKMETA
| LFS_I_CKDATA));
// run gc
if (AFTER == 0) {
#ifdef LFS_GC
lfsr_fs_gc(&lfs) => 0;
#else
assert(false);
#endif
// run lfsr_traversal_t
} else if (AFTER == 1) {
while (true) {
// it may take multiple traversals to do all pending work
lfsr_fs_stat(&lfs, &fsinfo) => 0;
if (!(fsinfo.flags & (
((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_I_COMPACT : 0)
| ((CKMETA) ? LFS_I_CKMETA : 0)
| ((CKDATA) ? LFS_I_CKDATA : 0)))) {
break;
}
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, GC_FLAGS) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
// run explicit operations
//
// yes, doing these in separate traversals is inefficient, I don't care
} else if (AFTER == 2) {
while (true) {
// it may take multiple traversals to do all pending work
lfsr_fs_stat(&lfs, &fsinfo) => 0;
if (!(fsinfo.flags & (
((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_I_COMPACT : 0)
| ((CKMETA) ? LFS_I_CKMETA : 0)
| ((CKDATA) ? LFS_I_CKDATA : 0)))) {
break;
}
if (MKCONSISTENT) {
lfsr_fs_mkconsistent(&lfs) => 0;
}
if (LOOKAHEAD) {
// we need an explicit traversal for this
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, LFS_T_LOOKAHEAD) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
if (COMPACT) {
// we need an explicit traversal for this
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, LFS_T_COMPACT) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
if (CKMETA) {
lfsr_fs_ckmeta(&lfs) => 0;
}
if (CKDATA) {
lfsr_fs_ckdata(&lfs) => 0;
}
}
// remount with gc flags
} else if (AFTER == 3) {
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR | GC_FLAGS, CFG) => 0;
} else {
assert(false);
}
// did these clear the right flags?
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!COMPACT) ? LFS_I_COMPACT : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
lfsr_unmount(&lfs) => 0;
'''
# test that gc work clears flags in lfsr_fs_stat after lfsr_fs_unck
[cases.test_gc_iflags_unck]
# AFTER=0 => after running lfsr_fs_gc
# AFTER=1 => after running lfsr_traversal_t
# AFTER=2 => after explicit operations
# AFTER=3 => after remounting
defines.AFTER = [0, 1, 2, 3]
defines.MKCONSISTENT = [false, true]
defines.LOOKAHEAD = [false, true]
defines.COMPACT = [false, true]
defines.CKMETA = [false, true]
defines.CKDATA = [false, true]
defines.GC_FLAGS = '''
((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_GC_COMPACT : 0)
| ((CKMETA) ? LFS_GC_CKMETA : 0)
| ((CKDATA) ? LFS_GC_CKDATA : 0)
'''
defines.GC_STEPS = -1
defines.N = [1, 2, 4, 8, 16, 32, 64]
defines.SIZE = [
'0',
'FILE_BUFFER_SIZE/2',
'2*FILE_BUFFER_SIZE',
'BLOCK_SIZE/2',
'BLOCK_SIZE',
'2*BLOCK_SIZE',
'8*BLOCK_SIZE',
]
if = [
'(SIZE*N)/BLOCK_SIZE <= 32',
'LFS_IFDEF_GC(true, AFTER != 0)',
]
code = '''
lfs_t lfs;
lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0;
lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
// create an interesting filesystem
uint32_t prng = 42;
for (lfs_size_t i = 0; i < N; i++) {
char name[256];
sprintf(name, "squid%03x", i);
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
}
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name,
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE;
lfsr_file_close(&lfs, &file) => 0;
}
// remount to reset flags
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0;
// check that flags were reset
struct lfs_fsinfo fsinfo;
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
LFS_I_MKCONSISTENT
| LFS_I_LOOKAHEAD
| LFS_I_COMPACT
| LFS_I_CKMETA
| LFS_I_CKDATA));
// run gc
if (AFTER == 0) {
#ifdef LFS_GC
lfsr_fs_gc(&lfs) => 0;
#else
assert(false);
#endif
// run lfsr_traversal_t
} else if (AFTER == 1) {
while (true) {
// it may take multiple traversals to do all pending work
lfsr_fs_stat(&lfs, &fsinfo) => 0;
if (!(fsinfo.flags & (
((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_I_COMPACT : 0)
| ((CKMETA) ? LFS_I_CKMETA : 0)
| ((CKDATA) ? LFS_I_CKDATA : 0)))) {
break;
}
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, GC_FLAGS) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
// run explicit operations
//
// yes, doing these in separate traversals is inefficient, I don't care
} else if (AFTER == 2) {
while (true) {
// it may take multiple traversals to do all pending work
lfsr_fs_stat(&lfs, &fsinfo) => 0;
if (!(fsinfo.flags & (
((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_I_COMPACT : 0)
| ((CKMETA) ? LFS_I_CKMETA : 0)
| ((CKDATA) ? LFS_I_CKDATA : 0)))) {
break;
}
if (MKCONSISTENT) {
lfsr_fs_mkconsistent(&lfs) => 0;
}
if (LOOKAHEAD) {
// we need an explicit traversal for this
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, LFS_T_LOOKAHEAD) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
if (COMPACT) {
// we need an explicit traversal for this
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, LFS_T_COMPACT) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
if (CKMETA) {
lfsr_fs_ckmeta(&lfs) => 0;
}
if (CKDATA) {
lfsr_fs_ckdata(&lfs) => 0;
}
}
// remount with gc flags
} else if (AFTER == 3) {
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR | GC_FLAGS, CFG) => 0;
} else {
assert(false);
}
// did these clear the right flags?
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!COMPACT) ? LFS_I_COMPACT : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// test that we can reset flags with lfsr_fs_unck
lfsr_fs_unck(&lfs, GC_FLAGS) => 0;
// check that flags were reset
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
LFS_I_MKCONSISTENT
| LFS_I_LOOKAHEAD
| LFS_I_COMPACT
// note ckdata implies ckmeta, but uncking ckdata does
// _not_ imply uncking ckmeta
| ((!(CKDATA && !CKMETA)) ? LFS_I_CKMETA : 0)
| LFS_I_CKDATA));
// run gc
if (AFTER == 0) {
#ifdef LFS_GC
lfsr_fs_gc(&lfs) => 0;
#else
assert(false);
#endif
// run lfsr_traversal_t
} else if (AFTER == 1) {
while (true) {
// it may take multiple traversals to do all pending work
lfsr_fs_stat(&lfs, &fsinfo) => 0;
if (!(fsinfo.flags & (
((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_I_COMPACT : 0)
| ((CKMETA) ? LFS_I_CKMETA : 0)
| ((CKDATA) ? LFS_I_CKDATA : 0)))) {
break;
}
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, GC_FLAGS) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
// run explicit operations
//
// yes, doing these in separate traversals is inefficient, I don't care
} else if (AFTER == 2) {
while (true) {
// it may take multiple traversals to do all pending work
lfsr_fs_stat(&lfs, &fsinfo) => 0;
if (!(fsinfo.flags & (
((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((COMPACT) ? LFS_I_COMPACT : 0)
| ((CKMETA) ? LFS_I_CKMETA : 0)
| ((CKDATA) ? LFS_I_CKDATA : 0)))) {
break;
}
if (MKCONSISTENT) {
lfsr_fs_mkconsistent(&lfs) => 0;
}
if (LOOKAHEAD) {
// we need an explicit traversal for this
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, LFS_T_LOOKAHEAD) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
if (COMPACT) {
// we need an explicit traversal for this
lfsr_traversal_t t;
lfsr_traversal_open(&lfs, &t, LFS_T_COMPACT) => 0;
while (true) {
struct lfs_tinfo tinfo;
int err = lfsr_traversal_read(&lfs, &t, &tinfo);
assert(err == 0 || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
}
lfsr_traversal_close(&lfs, &t) => 0;
}
if (CKMETA) {
lfsr_fs_ckmeta(&lfs) => 0;
}
if (CKDATA) {
lfsr_fs_ckdata(&lfs) => 0;
}
}
// remount with gc flags
} else if (AFTER == 3) {
lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, LFS_M_RDWR | GC_FLAGS, CFG) => 0;
} else {
assert(false);
}
// did these clear the right flags?
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!COMPACT) ? LFS_I_COMPACT : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
lfsr_unmount(&lfs) => 0;
'''
# pseudo-fuzz test that dirtying still works with the GC API
[cases.test_gc_mutation]
defines.N = 100
tests/test_mount.toml
+8 -4
View File
@@ -71,7 +71,8 @@ code = '''
| ((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!COMPACT) ? LFS_I_COMPACT : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
lfsr_unmount(&lfs) => 0;
@@ -144,7 +145,8 @@ code = '''
assert(fsinfo.flags == (
LFS_I_MKCONSISTENT
| LFS_I_COMPACT
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
lfsr_unmount(&lfs) => 0;
'''
@@ -215,7 +217,8 @@ code = '''
assert(fsinfo.flags == (
LFS_I_MKCONSISTENT
| ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// mdir should have been compacted
@@ -314,7 +317,8 @@ code = '''
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!COMPACT) ? LFS_I_COMPACT : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the files
tests/test_traversal.toml
+44 -18
View File
@@ -1710,7 +1710,8 @@ code = '''
((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0)
| ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!COMPACT) ? LFS_I_COMPACT : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
lfsr_unmount(&lfs) => 0;
@@ -2823,7 +2824,10 @@ code = '''
((DESYNC) ? LFS_I_MKCONSISTENT : 0)
| ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!(CKMETA && DESYNC)) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC))
? LFS_I_CKMETA
: 0)
| ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0)));
lfsr_file_close(&lfs, &file2) => 0;
@@ -2929,7 +2933,10 @@ code = '''
((DESYNC) ? LFS_I_MKCONSISTENT : 0)
| ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!(CKMETA && DESYNC)) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC))
? LFS_I_CKMETA
: 0)
| ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0)));
lfsr_file_close(&lfs, &file2) => 0;
@@ -3028,7 +3035,10 @@ code = '''
((DESYNC) ? LFS_I_MKCONSISTENT : 0)
| ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!(CKMETA && DESYNC)) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC))
? LFS_I_CKMETA
: 0)
| ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0)));
lfsr_file_close(&lfs, &file2) => 0;
@@ -3124,7 +3134,10 @@ code = '''
((DESYNC) ? LFS_I_MKCONSISTENT : 0)
| ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!(CKMETA && DESYNC)) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC))
? LFS_I_CKMETA
: 0)
| ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0)));
// check the file contents
@@ -5448,7 +5461,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the file
@@ -5587,7 +5601,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the file
@@ -5700,7 +5715,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the file
@@ -5851,7 +5867,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -6067,7 +6084,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -6290,7 +6308,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -6451,7 +6470,8 @@ code = '''
assert(fsinfo.flags == (
((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!CKMETA || ORPHANS > 0) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0)
| ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -6591,7 +6611,8 @@ code = '''
((ORPHANS >= 3) ? LFS_I_MKCONSISTENT : 0)
| ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!CKMETA || ORPHANS > 0) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0)
| ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -6750,7 +6771,8 @@ code = '''
assert(fsinfo.flags == (
((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!CKMETA || ORPHANS > 0) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0)
| ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -6907,7 +6929,8 @@ code = '''
assert(fsinfo.flags == (
((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!CKMETA || ORPHANS > 0) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0)
| ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -7075,7 +7098,8 @@ code = '''
assert(fsinfo.flags == (
((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!CKMETA || ORPHANS > 0) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0)
| ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -7241,7 +7265,8 @@ code = '''
assert(fsinfo.flags == (
((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0)
| LFS_I_COMPACT
| ((!CKMETA || ORPHANS > 0) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0)
| ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0)));
// check we can still read the files
@@ -7432,7 +7457,8 @@ code = '''
lfsr_fs_stat(&lfs, &fsinfo) => 0;
assert(fsinfo.flags == (
((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0)
| ((!CKMETA) ? LFS_I_CKMETA : 0)
// note ckdata implies ckmeta
| ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0)
| ((!CKDATA) ? LFS_I_CKDATA : 0)));
// check we can still read the files