Github/littlefs
1
Fork 0
Code Actions Activity

t: Dropped mtraversal=traversal alias

Browse Source 
We don't really need a second type anymore, and having one just risks
confusing new users.
This commit is contained in:
Christopher Haster
2024-07-05 15:25:10 -05:00
parent 2e6a5be4e3
commit c258420dd0
5 changed files with 183 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+129 -130
View File
@@ -8209,20 +8209,20 @@ static int lfsr_mtree_pathlookup(lfs_t *lfs, const char *path,
// traversing littlefs is a bit complex, so we use a state machine to keep
// track of where we are
enum {
LFSR_MTSTATE_MROOTANCHOR = 0,
LFSR_MTSTATE_MROOTCHAIN = 1,
LFSR_MTSTATE_MTREE = 2,
LFSR_MTSTATE_MDIRS = 3,
LFSR_MTSTATE_MDIR = 4,
LFSR_MTSTATE_BTREE = 5,
LFSR_MTSTATE_OMDIRS = 6,
LFSR_MTSTATE_OBTREE = 7,
LFSR_MTSTATE_DONE = 8,
LFSR_TSTATE_MROOTANCHOR = 0,
LFSR_TSTATE_MROOTCHAIN = 1,
LFSR_TSTATE_MTREE = 2,
LFSR_TSTATE_MDIRS = 3,
LFSR_TSTATE_MDIR = 4,
LFSR_TSTATE_BTREE = 5,
LFSR_TSTATE_OMDIRS = 6,
LFSR_TSTATE_OBTREE = 7,
LFSR_TSTATE_DONE = 8,
};
#define LFSR_MTRAVERSAL(_flags) \
((lfsr_mtraversal_t){ \
.o.o.state=LFSR_MTSTATE_MROOTANCHOR, \
#define LFSR_TRAVERSAL(_flags) \
((lfsr_traversal_t){ \
.o.o.state=LFSR_TSTATE_MROOTANCHOR, \
.o.o.flags=_flags, \
.o.o.mdir.mid=-1, \
.o.o.mdir.rbyd.blocks={-1,-1}, \
@@ -8275,46 +8275,46 @@ static inline bool lfsr_f_isdirty(uint32_t flags) {
static inline bool lfsr_f_isunsync(uint32_t flags);
// low-level traversal _only_ finds blocks
static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t,
lfsr_tag_t *tag_, lfsr_bptr_t *bptr_) {
while (true) {
switch (mt->o.o.state) {
switch (t->o.o.state) {
// start with the mrootanchor 0x{0,1}
//
// note we make sure to include all mroots in our mroot chain!
//
case LFSR_MTSTATE_MROOTANCHOR:;
case LFSR_TSTATE_MROOTANCHOR:;
// fetch the first mroot 0x{0,1}
int err = lfsr_mdir_fetch(lfs, &mt->o.o.mdir,
int err = lfsr_mdir_fetch(lfs, &t->o.o.mdir,
-1, &LFSR_MPTR_MROOTANCHOR());
if (err) {
return err;
}
// transition to traversing the mroot chain
mt->o.o.state = LFSR_MTSTATE_MROOTCHAIN;
t->o.o.state = LFSR_TSTATE_MROOTCHAIN;
if (tag_) {
*tag_ = LFSR_TAG_MDIR;
}
if (bptr_) {
bptr_->data.u.buffer = (const uint8_t*)&mt->o.o.mdir;
bptr_->data.u.buffer = (const uint8_t*)&t->o.o.mdir;
}
return 0;
// traverse the mroot chain, checking for mroot/mtree/mdir
case LFSR_MTSTATE_MROOTCHAIN:;
case LFSR_TSTATE_MROOTCHAIN:;
// lookup mroot, if we find one this is not the active mroot
lfsr_tag_t tag;
lfsr_data_t data;
err = lfsr_mdir_sublookup(lfs, &mt->o.o.mdir, LFSR_TAG_STRUCT,
err = lfsr_mdir_sublookup(lfs, &t->o.o.mdir, LFSR_TAG_STRUCT,
&tag, &data);
if (err) {
// if we have no mtree/mdir (inlined mdir), we need to
// traverse any files in our mroot next
if (err == LFS_ERR_NOENT) {
mt->o.o.mdir.mid = 0;
mt->o.o.state = LFSR_MTSTATE_MDIR;
t->o.o.mdir.mid = 0;
t->o.o.state = LFSR_TSTATE_MDIR;
continue;
}
return err;
@@ -8334,22 +8334,22 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
// btree inner nodes require checksums of their pointers,
// so creating a valid cycle is actually quite difficult
//
if (lfsr_mptr_cmp(&mptr, &mt->u.mtortoise.mptr) == 0) {
if (lfsr_mptr_cmp(&mptr, &t->u.mtortoise.mptr) == 0) {
LFS_ERROR("Cycle detected during mtree traversal "
"0x{%"PRIx32",%"PRIx32"}",
mptr.blocks[0],
mptr.blocks[1]);
return LFS_ERR_CORRUPT;
}
if (mt->u.mtortoise.step == (1U << mt->u.mtortoise.power)) {
mt->u.mtortoise.mptr = mptr;
mt->u.mtortoise.step = 0;
mt->u.mtortoise.power += 1;
if (t->u.mtortoise.step == (1U << t->u.mtortoise.power)) {
t->u.mtortoise.mptr = mptr;
t->u.mtortoise.step = 0;
t->u.mtortoise.power += 1;
}
mt->u.mtortoise.step += 1;
t->u.mtortoise.step += 1;
// fetch this mroot
err = lfsr_mdir_fetch(lfs, &mt->o.o.mdir, -1, &mptr);
err = lfsr_mdir_fetch(lfs, &t->o.o.mdir, -1, &mptr);
if (err) {
return err;
}
@@ -8358,7 +8358,7 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
*tag_ = LFSR_TAG_MDIR;
}
if (bptr_) {
bptr_->data.u.buffer = (const uint8_t*)&mt->o.o.mdir;
bptr_->data.u.buffer = (const uint8_t*)&t->o.o.mdir;
}
return 0;
@@ -8371,33 +8371,33 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
return err;
}
err = lfsr_mdir_fetch(lfs, &mt->o.o.mdir, 0, &mptr);
err = lfsr_mdir_fetch(lfs, &t->o.o.mdir, 0, &mptr);
if (err) {
return err;
}
// transition to traversing the mdir
mt->o.o.state = LFSR_MTSTATE_MDIR;
t->o.o.state = LFSR_TSTATE_MDIR;
if (tag_) {
*tag_ = LFSR_TAG_MDIR;
}
if (bptr_) {
bptr_->data.u.buffer = (const uint8_t*)&mt->o.o.mdir;
bptr_->data.u.buffer = (const uint8_t*)&t->o.o.mdir;
}
return 0;
// found an mtree?
} else if (tag == LFSR_TAG_MTREE) {
// fetch the root of the mtree
err = lfsr_data_readbtree(lfs, &data, &mt->o.bshrub.u.btree);
err = lfsr_data_readbtree(lfs, &data, &t->o.bshrub.u.btree);
if (err) {
return err;
}
// transition to traversing the mtree
mt->u.bt = LFSR_BTRAVERSAL();
mt->o.o.state = LFSR_MTSTATE_MTREE;
t->u.bt = LFSR_BTRAVERSAL();
t->o.o.state = LFSR_TSTATE_MTREE;
continue;
} else {
@@ -8406,44 +8406,44 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
}
// iterate over mdirs in the mtree
case LFSR_MTSTATE_MDIRS:;
case LFSR_TSTATE_MDIRS:;
// find the next mdir
err = lfsr_mtree_lookup(lfs, mt->o.o.mdir.mid,
&mt->o.o.mdir);
err = lfsr_mtree_lookup(lfs, t->o.o.mdir.mid,
&t->o.o.mdir);
if (err) {
// end of mtree? guess we're done
if (err == LFS_ERR_NOENT) {
mt->o.o.state = LFSR_MTSTATE_DONE;
t->o.o.state = LFSR_TSTATE_DONE;
continue;
}
return err;
}
// transition to traversing the mdir
mt->o.o.state = LFSR_MTSTATE_MDIR;
t->o.o.state = LFSR_TSTATE_MDIR;
if (tag_) {
*tag_ = LFSR_TAG_MDIR;
}
if (bptr_) {
bptr_->data.u.buffer = (const uint8_t*)&mt->o.o.mdir;
bptr_->data.u.buffer = (const uint8_t*)&t->o.o.mdir;
}
return 0;
// scan for blocks/btrees in the current mdir
case LFSR_MTSTATE_MDIR:;
case LFSR_TSTATE_MDIR:;
// not traversing all blocks? have we exceeded our mdir's weight?
// return to mtree iteration
if (lfsr_t_ismtreeonly(mt->o.o.flags)
|| lfsr_mid_rid(lfs, mt->o.o.mdir.mid)
>= (lfsr_srid_t)mt->o.o.mdir.rbyd.weight) {
mt->o.o.mdir.mid = lfsr_mid_bid(lfs, mt->o.o.mdir.mid) + 1;
mt->o.o.state = LFSR_MTSTATE_MDIRS;
if (lfsr_t_ismtreeonly(t->o.o.flags)
|| lfsr_mid_rid(lfs, t->o.o.mdir.mid)
>= (lfsr_srid_t)t->o.o.mdir.rbyd.weight) {
t->o.o.mdir.mid = lfsr_mid_bid(lfs, t->o.o.mdir.mid) + 1;
t->o.o.state = LFSR_TSTATE_MDIRS;
continue;
}
// do we have a block/btree?
err = lfsr_mdir_lookupnext(lfs, &mt->o.o.mdir, LFSR_TAG_DATA,
err = lfsr_mdir_lookupnext(lfs, &t->o.o.mdir, LFSR_TAG_DATA,
&tag, &data);
if (err && err != LFS_ERR_NOENT) {
return err;
@@ -8451,15 +8451,15 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
// found a direct block?
if (err != LFS_ERR_NOENT && tag == LFSR_TAG_BLOCK) {
err = lfsr_data_readbptr(lfs, &data, &mt->o.bshrub.u.bptr);
err = lfsr_data_readbptr(lfs, &data, &t->o.bshrub.u.bptr);
if (err) {
return err;
}
// found a bshrub (inlined btree)?
} else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_BSHRUB) {
err = lfsr_data_readshrub(lfs, &data, &mt->o.o.mdir,
&mt->o.bshrub.u.bshrub);
err = lfsr_data_readshrub(lfs, &data, &t->o.o.mdir,
&t->o.bshrub.u.bshrub);
if (err) {
return err;
}
@@ -8467,29 +8467,29 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
// found a btree?
} else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_BTREE) {
err = lfsr_data_readbtree(lfs, &data,
&mt->o.bshrub.u.btree);
&t->o.bshrub.u.btree);
if (err) {
return err;
}
// no? next we need to check any opened files
} else {
mt->ot = lfs->omdirs;
mt->o.o.state = LFSR_MTSTATE_OMDIRS;
t->ot = lfs->omdirs;
t->o.o.state = LFSR_TSTATE_OMDIRS;
continue;
}
// start traversing
mt->u.bt = LFSR_BTRAVERSAL();
mt->o.o.state = LFSR_MTSTATE_BTREE;
t->u.bt = LFSR_BTRAVERSAL();
t->o.o.state = LFSR_TSTATE_BTREE;
continue;
// scan for blocks/btrees in our opened file list
case LFSR_MTSTATE_OMDIRS:;
case LFSR_TSTATE_OMDIRS:;
// reached end of opened files? return to mdir traversal
if (!mt->ot) {
mt->o.o.mdir.mid += 1;
mt->o.o.state = LFSR_MTSTATE_MDIR;
if (!t->ot) {
t->o.o.mdir.mid += 1;
t->o.o.state = LFSR_TSTATE_MDIR;
continue;
}
@@ -8501,45 +8501,45 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
// literally every file open, but other things grow O(n^2) with
// this list anyways
//
if (mt->ot->mdir.mid != mt->o.o.mdir.mid
|| mt->ot->type != LFS_TYPE_REG
|| !lfsr_f_isunsync(mt->ot->flags)) {
mt->ot = mt->ot->next;
if (t->ot->mdir.mid != t->o.o.mdir.mid
|| t->ot->type != LFS_TYPE_REG
|| !lfsr_f_isunsync(t->ot->flags)) {
t->ot = t->ot->next;
continue;
}
// start traversing the file
const lfsr_file_t *file = (const lfsr_file_t*)mt->ot;
mt->o.bshrub = file->o.bshrub;
mt->u.bt = LFSR_BTRAVERSAL();
mt->o.o.state = LFSR_MTSTATE_OBTREE;
const lfsr_file_t *file = (const lfsr_file_t*)t->ot;
t->o.bshrub = file->o.bshrub;
t->u.bt = LFSR_BTRAVERSAL();
t->o.o.state = LFSR_TSTATE_OBTREE;
continue;
// traverse any btrees we see, this includes the mtree and any file
// btrees/bshrubs
case LFSR_MTSTATE_MTREE:;
case LFSR_MTSTATE_BTREE:;
case LFSR_MTSTATE_OBTREE:;
case LFSR_TSTATE_MTREE:;
case LFSR_TSTATE_BTREE:;
case LFSR_TSTATE_OBTREE:;
// traverse through our file
err = lfsr_bshrub_traverse(lfs, &mt->o.o.mdir, &mt->o.bshrub,
&mt->u.bt,
err = lfsr_bshrub_traverse(lfs, &t->o.o.mdir, &t->o.bshrub,
&t->u.bt,
NULL, &tag, bptr_);
if (err) {
if (err == LFS_ERR_NOENT) {
// end of mtree? start iterating over mdirs
if (mt->o.o.state == LFSR_MTSTATE_MTREE) {
mt->o.o.mdir.mid = 0;
mt->o.o.state = LFSR_MTSTATE_MDIRS;
if (t->o.o.state == LFSR_TSTATE_MTREE) {
t->o.o.mdir.mid = 0;
t->o.o.state = LFSR_TSTATE_MDIRS;
continue;
// end of mdir btree? start iterating over opened files
} else if (mt->o.o.state == LFSR_MTSTATE_BTREE) {
mt->ot = lfs->omdirs;
mt->o.o.state = LFSR_MTSTATE_OMDIRS;
} else if (t->o.o.state == LFSR_TSTATE_BTREE) {
t->ot = lfs->omdirs;
t->o.o.state = LFSR_TSTATE_OMDIRS;
continue;
// end of opened btree? go to next opened file
} else if (mt->o.o.state == LFSR_MTSTATE_OBTREE) {
mt->ot = mt->ot->next;
mt->o.o.state = LFSR_MTSTATE_OMDIRS;
} else if (t->o.o.state == LFSR_TSTATE_OBTREE) {
t->ot = t->ot->next;
t->o.o.state = LFSR_TSTATE_OMDIRS;
continue;
} else {
LFS_UNREACHABLE();
@@ -8565,7 +8565,7 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_mtraversal_t *mt,
continue;
case LFSR_MTSTATE_DONE:;
case LFSR_TSTATE_DONE:;
return LFS_ERR_NOENT;
default:;
@@ -8580,21 +8580,21 @@ static void lfs_alloc_markinuse(lfs_t *lfs, lfs_block_t block);
// high-level immutable traversal, handle extra features here,
// but no mutation! (we're called in lfs_alloc, so things would end up
// recursive)
static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_mtraversal_t *mt,
static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_traversal_t *t,
lfsr_tag_t *tag_, lfsr_bptr_t *bptr_) {
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse_(lfs, mt,
int err = lfsr_mtree_traverse_(lfs, t,
&tag, &bptr);
if (err) {
return err;
}
// validate btree nodes? note mdirs are already validated
if ((lfsr_t_isckmeta(mt->o.o.flags)
|| lfsr_t_isck(mt->o.o.flags)
if ((lfsr_t_isckmeta(t->o.o.flags)
|| lfsr_t_isck(t->o.o.flags)
// we also need to fetch to know if we need to compact
|| lfsr_t_iscompact(mt->o.o.flags))
|| lfsr_t_iscompact(t->o.o.flags))
&& tag == LFSR_TAG_BRANCH) {
lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer;
err = lfsr_rbyd_fetchck(lfs, rbyd,
@@ -8606,7 +8606,7 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_mtraversal_t *mt,
}
// validate data blocks?
if (lfsr_t_isck(mt->o.o.flags)
if (lfsr_t_isck(t->o.o.flags)
&& tag == LFSR_TAG_BLOCK) {
err = lfsr_bptr_ck(lfs, &bptr);
if (err) {
@@ -8615,7 +8615,7 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_mtraversal_t *mt,
}
// track in-use blocks
if (lfsr_t_islookahead(mt->o.o.flags)) {
if (lfsr_t_islookahead(t->o.o.flags)) {
if (tag == LFSR_TAG_MDIR) {
lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer;
lfs_alloc_markinuse(lfs, mdir->rbyd.blocks[0]);
@@ -8644,22 +8644,22 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_mtraversal_t *mt,
// high-level mutating traversal, handle extra features that require
// mutation here, upper layers should call lfs_alloc_ckpoint as needed
static int lfsr_mtree_gc(lfs_t *lfs, lfsr_mtraversal_t *mt,
static int lfsr_mtree_gc(lfs_t *lfs, lfsr_traversal_t *t,
lfsr_tag_t *tag_, lfsr_bptr_t *bptr_) {
// traversals need to be enrolled in our opened list for
// lfsr_mtree_gc to work correctly
LFS_ASSERT(lfsr_omdir_isopen(lfs, &mt->o.o));
LFS_ASSERT(lfsr_omdir_isopen(lfs, &t->o.o));
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(lfs, mt,
int err = lfsr_mtree_traverse(lfs, t,
&tag, &bptr);
if (err) {
return err;
}
// compacting mdirs?
if (lfsr_t_iscompact(mt->o.o.flags)
if (lfsr_t_iscompact(t->o.o.flags)
&& tag == LFSR_TAG_MDIR
// exceed compaction threshold?
&& lfsr_rbyd_eoff(&((lfsr_mdir_t*)bptr.data.u.buffer)->rbyd)
@@ -8684,11 +8684,11 @@ static int lfsr_mtree_gc(lfs_t *lfs, lfsr_mtraversal_t *mt,
}
// mark as dirty
mt->o.o.flags |= LFS_F_DIRTY;
t->o.o.flags |= LFS_F_DIRTY;
}
// compacting btree nodes?
if (lfsr_t_iscompact(mt->o.o.flags)
if (lfsr_t_iscompact(t->o.o.flags)
&& tag == LFSR_TAG_BRANCH
// exceed compaction threshold?
&& lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
@@ -8705,43 +8705,43 @@ static int lfsr_mtree_gc(lfs_t *lfs, lfsr_mtraversal_t *mt,
? lfs->cfg->gc_compact_thresh
: lfs->cfg->block_size - lfs->cfg->block_size/8);
if (mt->o.o.state == LFSR_MTSTATE_MTREE) {
int err = lfsr_btree_compact_(lfs, &mt->o.bshrub.u.btree,
if (t->o.o.state == LFSR_TSTATE_MTREE) {
int err = lfsr_btree_compact_(lfs, &t->o.bshrub.u.btree,
// note we may be referencing the btree root here
mt->u.bt.bid, rbyd);
t->u.bt.bid, rbyd);
if (err) {
return err;
}
} else {
int err = lfsr_bshrub_compact_(lfs, &mt->o.o.mdir, &mt->o.bshrub,
int err = lfsr_bshrub_compact_(lfs, &t->o.o.mdir, &t->o.bshrub,
// note we may be referencing the btree root here
mt->u.bt.bid, rbyd);
t->u.bt.bid, rbyd);
if (err) {
return err;
}
}
if (mt->o.o.state == LFSR_MTSTATE_OBTREE) {
if (t->o.o.state == LFSR_TSTATE_OBTREE) {
// just update our opened file
lfsr_file_t *file = (lfsr_file_t*)mt->ot;
lfsr_file_t *file = (lfsr_file_t*)t->ot;
file->o.o.flags |= LFS_F_UNSYNC;
file->o.bshrub = mt->o.bshrub;
file->o.bshrub = t->o.bshrub;
} else {
// commit to mdir
uint8_t buf[LFSR_BTREE_DSIZE];
int err = lfsr_mdir_commit(lfs, &mt->o.o.mdir, LFSR_ATTRS(
(mt->o.o.state == LFSR_MTSTATE_MTREE)
int err = lfsr_mdir_commit(lfs, &t->o.o.mdir, LFSR_ATTRS(
(t->o.o.state == LFSR_TSTATE_MTREE)
? LFSR_ATTR(
LFSR_TAG_SUB | LFSR_TAG_MTREE, 0,
LFSR_DATA_BTREE_(&mt->o.bshrub.u.btree, buf))
: (lfsr_bshrub_isbshrub(&mt->o.o.mdir, &mt->o.bshrub))
LFSR_DATA_BTREE_(&t->o.bshrub.u.btree, buf))
: (lfsr_bshrub_isbshrub(&t->o.o.mdir, &t->o.bshrub))
? LFSR_ATTR_SHRUBTRUNK(
LFSR_TAG_SUB | LFSR_TAG_SHRUBTRUNK, 0,
&mt->o.bshrub.u.bshrub)
&t->o.bshrub.u.bshrub)
: LFSR_ATTR(
LFSR_TAG_SUB | LFSR_TAG_BTREE, 0,
LFSR_DATA_BTREE_(&mt->o.bshrub.u.btree, buf))));
LFSR_DATA_BTREE_(&t->o.bshrub.u.btree, buf))));
if (err) {
return err;
}
@@ -8749,20 +8749,20 @@ static int lfsr_mtree_gc(lfs_t *lfs, lfsr_mtraversal_t *mt,
// update any open files
for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) {
if (o->type == LFS_TYPE_REG
&& o->mdir.mid == mt->o.o.mdir.mid
&& o->mdir.mid == t->o.o.mdir.mid
&& !lfsr_f_isunsync(o->flags)) {
lfsr_file_t *file = (lfsr_file_t*)o;
file->o.bshrub = mt->o.bshrub;
file->o.bshrub = t->o.bshrub;
}
}
}
// reset to btree root
mt->u.bt.branch = &mt->o.bshrub.u.btree;
mt->u.bt.rid = mt->u.bt.bid;
t->u.bt.branch = &t->o.bshrub.u.btree;
t->u.bt.rid = t->u.bt.bid;
// mark as dirty
mt->o.o.flags |= LFS_F_DIRTY;
t->o.o.flags |= LFS_F_DIRTY;
}
if (tag_) {
@@ -8910,9 +8910,9 @@ static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase) {
// traverse the filesystem, building up knowledge of what blocks are
// in use in our lookahead window
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_LOOKAHEAD);
lfsr_traversal_t t = LFSR_TRAVERSAL(LFS_T_LOOKAHEAD);
while (true) {
int err = lfsr_mtree_traverse(lfs, &mt,
int err = lfsr_mtree_traverse(lfs, &t,
NULL, NULL);
if (err) {
LFS_ASSERT(err != LFS_ERR_BUSY);
@@ -12295,12 +12295,11 @@ static int lfsr_mountinited(lfs_t *lfs) {
// we do validate btree inner nodes here, how can we trust our
// mdirs are valid if we haven't checked the btree inner nodes at
// least once?
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
LFS_T_MTREEONLY | LFS_T_CKMETA);
lfsr_traversal_t t = LFSR_TRAVERSAL(LFS_T_MTREEONLY | LFS_T_CKMETA);
while (true) {
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(lfs, &mt,
int err = lfsr_mtree_traverse(lfs, &t,
&tag, &bptr);
if (err) {
if (err == LFS_ERR_NOENT) {
@@ -12607,10 +12606,10 @@ int lfsr_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo) {
lfs_ssize_t lfsr_fs_size(lfs_t *lfs) {
lfs_size_t count = 0;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(0);
lfsr_traversal_t t = LFSR_TRAVERSAL(0);
while (true) {
lfsr_tag_t tag;
int err = lfsr_mtree_traverse(lfs, &mt,
int err = lfsr_mtree_traverse(lfs, &t,
&tag, NULL);
if (err) {
if (err == LFS_ERR_NOENT) {
@@ -12947,23 +12946,23 @@ done:;
static void lfsr_traversal_clobber(lfs_t *lfs, lfsr_traversal_t *t) {
(void)lfs;
// mroot/mtree? transition to mdir iteration
if (t->o.o.state < LFSR_MTSTATE_MDIRS) {
t->o.o.state = LFSR_MTSTATE_MDIRS;
if (t->o.o.state < LFSR_TSTATE_MDIRS) {
t->o.o.state = LFSR_TSTATE_MDIRS;
t->o.o.mdir.mid = 0;
t->o.bshrub.u.bshrub.weight = 0;
t->o.bshrub.u.bshrub.blocks[0] = -1;
t->ot = NULL;
// in-mtree mdir? increment the mid (to make progress) and reset to
// mdir iteration
} else if (t->o.o.state < LFSR_MTSTATE_OMDIRS) {
t->o.o.state = LFSR_MTSTATE_MDIR;
} else if (t->o.o.state < LFSR_TSTATE_OMDIRS) {
t->o.o.state = LFSR_TSTATE_MDIR;
t->o.o.mdir.mid += 1;
t->o.bshrub.u.bshrub.weight = 0;
t->o.bshrub.u.bshrub.blocks[0] = -1;
t->ot = NULL;
// opened mdir? skip to next omdir
} else if (t->o.o.state < LFSR_MTSTATE_DONE) {
t->o.o.state = LFSR_MTSTATE_OMDIRS;
} else if (t->o.o.state < LFSR_TSTATE_DONE) {
t->o.o.state = LFSR_TSTATE_OMDIRS;
t->o.bshrub.u.bshrub.weight = 0;
t->o.bshrub.u.bshrub.blocks[0] = -1;
t->ot = t->ot->next;
@@ -12981,7 +12980,7 @@ static int lfsr_traversal_rewind_(lfs_t *lfs, lfsr_traversal_t *t) {
(void)lfs;
// reset traversal
t->o.o.flags &= ~LFS_F_DIRTY;
t->o.o.state = LFSR_MTSTATE_MROOTANCHOR;
t->o.o.state = LFSR_TSTATE_MROOTANCHOR;
t->o.o.mdir.mid = -1;
t->o.o.mdir.rbyd.weight = 0;
t->o.o.mdir.rbyd.blocks[0] = -1;
lfs.h
+2 -4
View File
@@ -620,7 +620,7 @@ typedef struct lfsr_btraversal {
lfsr_rbyd_t rbyd;
} lfsr_btraversal_t;
typedef struct lfsr_mtraversal {
typedef struct lfsr_traversal {
// mdir/btree state, this also includes our traversal state machine
lfsr_obshrub_t o;
// opened file state
@@ -638,9 +638,7 @@ typedef struct lfsr_mtraversal {
// pending blocks, only used in lfsr_traversal_read
lfs_sblock_t blocks[2];
} lfsr_mtraversal_t;
typedef lfsr_mtraversal_t lfsr_traversal_t;
} lfsr_traversal_t;
//typedef struct lfs_superblock {
tests/test_alloc.toml
+6 -6
View File
@@ -163,7 +163,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
(CKMETA) ? LFS_T_CKMETA : 0);
for (lfs_block_t i = 0;; i++) {
// a bit hacky, but this catches infinite loops
@@ -171,7 +171,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -332,7 +332,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
// a bit hacky, but this catches infinite loops
@@ -340,7 +340,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -487,7 +487,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
// a bit hacky, but this catches infinite loops
@@ -495,7 +495,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
tests/test_mtree.toml
+16 -16
View File
@@ -3362,7 +3362,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -3371,7 +3371,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -3478,7 +3478,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -3487,7 +3487,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -3616,7 +3616,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -3625,7 +3625,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -3775,7 +3775,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -3784,7 +3784,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -3918,7 +3918,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -3927,7 +3927,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -4039,7 +4039,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -4048,7 +4048,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -4202,7 +4202,7 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) {
@@ -4211,7 +4211,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
@@ -4329,7 +4329,7 @@ code = '''
LFSR_DATA_MPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0;
// technically, cycle detection only needs to work when we're validating
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
lfsr_traversal_t t = LFSR_TRAVERSAL(
LFS_T_MTREEONLY | LFS_T_CKMETA);
for (lfs_block_t i = 0;; i++) {
// assert that we detect the cycle in a reasonable number of iterations
@@ -4337,7 +4337,7 @@ code = '''
lfsr_tag_t tag;
lfsr_bptr_t bptr;
int err = lfsr_mtree_traverse(&lfs, &mt,
int err = lfsr_mtree_traverse(&lfs, &t,
&tag, &bptr);
assert(!err || err == LFS_ERR_CORRUPT);
if (err == LFS_ERR_CORRUPT) {
tests/test_traversal.toml
+30 -30
View File
@@ -6076,12 +6076,12 @@ code = '''
while (true) {
// we need internals to check this
// ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
> GC_COMPACT_THRESH) {
@@ -6136,12 +6136,12 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0;
// mtree should have been compacted
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_BRANCH);
assert(lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
<= GC_COMPACT_THRESH);
@@ -6558,12 +6558,12 @@ code = '''
while (true) {
// we need internals to check this
// ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
> GC_COMPACT_THRESH) {
@@ -6605,13 +6605,13 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
while (true) {
int err = lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr);
int err = lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
@@ -6675,12 +6675,12 @@ code = '''
while (true) {
// we need internals to check this
// ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
> GC_COMPACT_THRESH) {
@@ -6722,13 +6722,13 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
while (true) {
int err = lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr);
int err = lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
@@ -6793,12 +6793,12 @@ code = '''
while (true) {
// we need internals to check this
// ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
> GC_COMPACT_THRESH) {
@@ -6838,13 +6838,13 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
while (true) {
int err = lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr);
int err = lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
@@ -6909,12 +6909,12 @@ code = '''
while (true) {
// we need internals to check this
// ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff((lfsr_rbyd_t*)bptr.data.u.buffer)
> GC_COMPACT_THRESH) {
@@ -6975,13 +6975,13 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_traversal_t t_ = LFSR_TRAVERSAL(LFS_T_CKMETA);
lfsr_tag_t tag;
lfsr_bptr_t bptr;
lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr) => 0;
lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr) => 0;
assert(tag == LFSR_TAG_MDIR);
while (true) {
int err = lfsr_mtree_traverse(&lfs, &mt, &tag, &bptr);
int err = lfsr_mtree_traverse(&lfs, &t_, &tag, &bptr);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;