diff --git a/lfs3.c b/lfs3.c index 019365de..bcc8b021 100644 --- a/lfs3.c +++ b/lfs3.c @@ -1044,7 +1044,7 @@ enum lfs3_tag { LFS3_TAG_BOOKMARK = 0x0204, // in-device only name tags, these should never get written to disk LFS3_TAG_ORPHAN = 0x0205, - LFS3_TAG_TRAVERSAL = 0x0206, + LFS3_TAG_TRV = 0x0206, LFS3_TAG_UNKNOWN = 0x0207, // non-file name tags LFS3_TAG_MNAME = 0x0220, @@ -6318,25 +6318,25 @@ static lfs3_scmp_t lfs3_btree_namelookup(lfs3_t *lfs3, // lfs3_btree_lookupnext, traversal includes inner btree nodes #ifndef LFS3_2BONLY -static void lfs3_btraversal_init(lfs3_btraversal_t *bt) { - bt->bid = 0; - bt->branch = NULL; - bt->rid = 0; +static void lfs3_btrv_init(lfs3_btrv_t *btrv) { + btrv->bid = 0; + btrv->branch = NULL; + btrv->rid = 0; } #endif #ifndef LFS3_2BONLY static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, const lfs3_btree_t *btree, - lfs3_btraversal_t *bt, + lfs3_btrv_t *btrv, lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) { // explicitly traverse the root even if weight=0 - if (!bt->branch) { - bt->branch = btree; - bt->rid = bt->bid; + if (!btrv->branch) { + btrv->branch = btree; + btrv->rid = btrv->bid; // traverse the root - if (bt->bid == 0 + if (btrv->bid == 0 // unless we don't even have a root yet && lfs3_rbyd_trunk(btree) != 0 // or are a shrub @@ -6348,16 +6348,16 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, *weight_ = btree->weight; } if (data_) { - data_->u.buffer = (const uint8_t*)bt->branch; + data_->u.buffer = (const uint8_t*)btrv->branch; } return LFS3_TAG_BRANCH; } } // need to restart from the root? - if (bt->rid >= (lfs3_srid_t)bt->branch->weight) { - bt->branch = btree; - bt->rid = bt->bid; + if (btrv->rid >= (lfs3_srid_t)btrv->branch->weight) { + btrv->branch = btree; + btrv->rid = btrv->bid; } // descend down the tree @@ -6365,8 +6365,8 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, lfs3_srid_t rid__; lfs3_rid_t weight__; lfs3_data_t data__; - lfs3_stag_t tag__ = lfs3_rbyd_lookupnext(lfs3, bt->branch, - bt->rid, 0, + lfs3_stag_t tag__ = lfs3_rbyd_lookupnext(lfs3, btrv->branch, + btrv->rid, 0, &rid__, &weight__, &data__); if (tag__ < 0) { return tag__; @@ -6374,7 +6374,7 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, // if we found a bname, lookup the branch if (tag__ == LFS3_TAG_BNAME) { - tag__ = lfs3_rbyd_lookup(lfs3, bt->branch, rid__, LFS3_TAG_BRANCH, + tag__ = lfs3_rbyd_lookup(lfs3, btrv->branch, rid__, LFS3_TAG_BRANCH, &data__); if (tag__ < 0) { LFS3_ASSERT(tag__ != LFS3_ERR_NOENT); @@ -6385,27 +6385,27 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, // found another branch if (tag__ == LFS3_TAG_BRANCH) { // adjust rid with subtree's weight - bt->rid -= (rid__ - (weight__-1)); + btrv->rid -= (rid__ - (weight__-1)); // fetch the next branch int err = lfs3_data_fetchbranch(lfs3, &data__, weight__, - &bt->rbyd); + &btrv->rbyd); if (err) { return err; } - bt->branch = &bt->rbyd; + btrv->branch = &btrv->rbyd; // return inner btree nodes if this is the first time we've // seen them - if (bt->rid == 0) { + if (btrv->rid == 0) { if (bid_) { - *bid_ = bt->bid + (rid__ - bt->rid); + *bid_ = btrv->bid + (rid__ - btrv->rid); } if (weight_) { *weight_ = weight__; } if (data_) { - data_->u.buffer = (const uint8_t*)bt->branch; + data_->u.buffer = (const uint8_t*)btrv->branch; } return LFS3_TAG_BRANCH; } @@ -6416,9 +6416,9 @@ static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, // // note this effectively traverses a full leaf without redoing // the btree walk - lfs3_bid_t bid__ = bt->bid + (rid__ - bt->rid); - bt->bid = bid__ + 1; - bt->rid = rid__ + 1; + lfs3_bid_t bid__ = btrv->bid + (rid__ - btrv->rid); + btrv->bid = bid__ + 1; + btrv->rid = rid__ + 1; if (bid_) { *bid_ = bid__; @@ -6789,9 +6789,9 @@ static lfs3_stag_t lfs3_bshrub_lookup(lfs3_t *lfs3, #ifndef LFS3_2BONLY static lfs3_stag_t lfs3_bshrub_traverse(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, - lfs3_btraversal_t *bt, + lfs3_btrv_t *btrv, lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) { - return lfs3_btree_traverse(lfs3, &bshrub->shrub, bt, + return lfs3_btree_traverse(lfs3, &bshrub->shrub, btrv, bid_, weight_, data_); } #endif @@ -7180,7 +7180,7 @@ static inline void lfs3_o_settype(uint32_t *flags, uint8_t type) { static inline bool lfs3_o_isbshrub(uint32_t flags) { return lfs3_o_type(flags) == LFS3_TYPE_REG - || lfs3_o_type(flags) == LFS3_type_TRAVERSAL; + || lfs3_o_type(flags) == LFS3_type_TRV; } static inline bool lfs3_o_iszombie(uint32_t flags) { @@ -7460,18 +7460,18 @@ static bool lfs3_mid_isopen(const lfs3_t *lfs3, // traversal invalidation things // needed in lfs3_handle_clobber -static void lfs3_traversal_clobber(lfs3_t *lfs3, lfs3_traversal_t *t); +static void lfs3_trv_clobber(lfs3_t *lfs3, lfs3_trv_t *trv); // clobber any traversals referencing our mdir #ifndef LFS3_RDONLY static void lfs3_handle_clobber(lfs3_t *lfs3, const lfs3_handle_t *h, uint32_t flags) { for (lfs3_handle_t *h_ = lfs3->handles; h_; h_ = h_->next) { - if (lfs3_o_type(h_->flags) == LFS3_type_TRAVERSAL) { + if (lfs3_o_type(h_->flags) == LFS3_type_TRV) { h_->flags |= flags; - if (h && ((lfs3_traversal_t*)h_)->ht == h) { - lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h_); + if (h && ((lfs3_trv_t*)h_)->htrv == h) { + lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h_); } } } @@ -9370,12 +9370,12 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir, if (lfs3_mdir_cmp(&mroot_, &lfs3->mroot) != 0 || lfs3_btree_cmp(&mtree_, &lfs3->mtree) != 0) { for (lfs3_handle_t *h = lfs3->handles; h; h = h->next) { - if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL + if (lfs3_o_type(h->flags) == LFS3_type_TRV && h->mdir.mid == -1 // don't clobber the current mdir, assume upper layers // know what they're doing && &h->mdir != mdir) { - lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h); + lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h); } } } @@ -9761,46 +9761,46 @@ enum lfs3_tstate { LFS3_TSTATE_DONE = 8, }; -static void lfs3_traversal_init(lfs3_traversal_t *t, uint32_t flags) { - t->b.h.flags = lfs3_o_typeflags(LFS3_type_TRAVERSAL) +static void lfs3_trv_init(lfs3_trv_t *trv, uint32_t flags) { + trv->b.h.flags = lfs3_o_typeflags(LFS3_type_TRV) | lfs3_t_tstateflags(LFS3_TSTATE_MROOTANCHOR) | flags; - t->b.h.mdir.mid = -1; - t->b.h.mdir.r.weight = 0; - t->b.h.mdir.r.blocks[0] = -1; - t->b.h.mdir.r.blocks[1] = -1; - lfs3_bshrub_init(&t->b); - t->ht = NULL; - t->u.mtortoise.blocks[0] = -1; - t->u.mtortoise.blocks[1] = -1; - t->u.mtortoise.step = 0; - t->u.mtortoise.power = 0; - t->gcksum = 0; + trv->b.h.mdir.mid = -1; + trv->b.h.mdir.r.weight = 0; + trv->b.h.mdir.r.blocks[0] = -1; + trv->b.h.mdir.r.blocks[1] = -1; + lfs3_bshrub_init(&trv->b); + trv->htrv = NULL; + trv->u.mtortoise.blocks[0] = -1; + trv->u.mtortoise.blocks[1] = -1; + trv->u.mtortoise.step = 0; + trv->u.mtortoise.power = 0; + trv->gcksum = 0; } // low-level traversal _only_ finds blocks -static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, +static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_trv_t *trv, lfs3_bptr_t *bptr_) { while (true) { - switch (lfs3_t_tstate(t->b.h.flags)) { + switch (lfs3_t_tstate(trv->b.h.flags)) { // start with the mrootanchor 0x{0,1} // // note we make sure to include all mroots in our mroot chain! // case LFS3_TSTATE_MROOTANCHOR:; // fetch the first mroot 0x{0,1} - int err = lfs3_mdir_fetch(lfs3, &t->b.h.mdir, + int err = lfs3_mdir_fetch(lfs3, &trv->b.h.mdir, -1, LFS3_MPTR_MROOTANCHOR()); if (err) { return err; } // transition to traversing the mroot chain - lfs3_t_settstate(&t->b.h.flags, LFS3_IFDEF_2BONLY( + lfs3_t_settstate(&trv->b.h.flags, LFS3_IFDEF_2BONLY( LFS3_TSTATE_DONE, LFS3_TSTATE_MROOTCHAIN)); - bptr_->d.u.buffer = (const uint8_t*)&t->b.h.mdir; + bptr_->d.u.buffer = (const uint8_t*)&trv->b.h.mdir; return LFS3_TAG_MDIR; // traverse the mroot chain, checking for mroots/mtrees @@ -9808,15 +9808,15 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, case LFS3_TSTATE_MROOTCHAIN:; // lookup mroot, if we find one this is not the active mroot lfs3_data_t data; - lfs3_stag_t tag = lfs3_mdir_lookup(lfs3, &t->b.h.mdir, + lfs3_stag_t tag = lfs3_mdir_lookup(lfs3, &trv->b.h.mdir, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &data); if (tag < 0) { // if we have no mtree (inlined mdir), we need to // traverse any files in our mroot next if (tag == LFS3_ERR_NOENT) { - t->b.h.mdir.mid = 0; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR); + trv->b.h.mdir.mid = 0; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR); continue; } return tag; @@ -9826,7 +9826,7 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, if (tag == LFS3_TAG_MROOT) { // fetch this mroot err = lfs3_data_fetchmdir(lfs3, &data, -1, - &t->b.h.mdir); + &trv->b.h.mdir); if (err) { return err; } @@ -9838,37 +9838,37 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, // so creating a valid cycle is actually quite difficult // if (lfs3_mptr_cmp( - t->b.h.mdir.r.blocks, - t->u.mtortoise.blocks) == 0) { + trv->b.h.mdir.r.blocks, + trv->u.mtortoise.blocks) == 0) { LFS3_ERROR("Cycle detected during mtree traversal " "0x{%"PRIx32",%"PRIx32"}", - t->b.h.mdir.r.blocks[0], - t->b.h.mdir.r.blocks[1]); + trv->b.h.mdir.r.blocks[0], + trv->b.h.mdir.r.blocks[1]); return LFS3_ERR_CORRUPT; } - if (t->u.mtortoise.step == (1U << t->u.mtortoise.power)) { - t->u.mtortoise.blocks[0] = t->b.h.mdir.r.blocks[0]; - t->u.mtortoise.blocks[1] = t->b.h.mdir.r.blocks[1]; - t->u.mtortoise.step = 0; - t->u.mtortoise.power += 1; + if (trv->u.mtortoise.step == (1U << trv->u.mtortoise.power)) { + trv->u.mtortoise.blocks[0] = trv->b.h.mdir.r.blocks[0]; + trv->u.mtortoise.blocks[1] = trv->b.h.mdir.r.blocks[1]; + trv->u.mtortoise.step = 0; + trv->u.mtortoise.power += 1; } - t->u.mtortoise.step += 1; + trv->u.mtortoise.step += 1; - bptr_->d.u.buffer = (const uint8_t*)&t->b.h.mdir; + bptr_->d.u.buffer = (const uint8_t*)&trv->b.h.mdir; return LFS3_TAG_MDIR; // found an mtree? } else if (tag == LFS3_TAG_MTREE) { // fetch the root of the mtree err = lfs3_data_fetchbtree(lfs3, &data, - &t->b.shrub); + &trv->b.shrub); if (err) { return err; } // transition to traversing the mtree - lfs3_btraversal_init(&t->u.bt); - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MTREE); + lfs3_btrv_init(&trv->u.btrv); + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MTREE); continue; } else { @@ -9882,21 +9882,21 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, #ifndef LFS3_2BONLY case LFS3_TSTATE_MDIRS:; // find the next mdir - err = lfs3_mtree_lookup(lfs3, t->b.h.mdir.mid, - &t->b.h.mdir); + err = lfs3_mtree_lookup(lfs3, trv->b.h.mdir.mid, + &trv->b.h.mdir); if (err) { // end of mtree? guess we're done if (err == LFS3_ERR_NOENT) { - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_DONE); + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_DONE); continue; } return err; } // transition to traversing the mdir - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR); + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR); - bptr_->d.u.buffer = (const uint8_t*)&t->b.h.mdir; + bptr_->d.u.buffer = (const uint8_t*)&trv->b.h.mdir; return LFS3_TAG_MDIR; #endif @@ -9905,16 +9905,16 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, case LFS3_TSTATE_MDIR:; // not traversing all blocks? have we exceeded our mdir's weight? // return to mtree iteration - if (lfs3_t_ismtreeonly(t->b.h.flags) - || lfs3_mrid(lfs3, t->b.h.mdir.mid) - >= (lfs3_srid_t)t->b.h.mdir.r.weight) { - t->b.h.mdir.mid = lfs3_mbid(lfs3, t->b.h.mdir.mid) + 1; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS); + if (lfs3_t_ismtreeonly(trv->b.h.flags) + || lfs3_mrid(lfs3, trv->b.h.mdir.mid) + >= (lfs3_srid_t)trv->b.h.mdir.r.weight) { + trv->b.h.mdir.mid = lfs3_mbid(lfs3, trv->b.h.mdir.mid) + 1; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS); continue; } // do we have a bshrub/btree? - err = lfs3_bshrub_fetch(lfs3, &t->b); + err = lfs3_bshrub_fetch(lfs3, &trv->b); if (err && err != LFS3_ERR_NOENT) { return err; } @@ -9923,14 +9923,14 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, // here, lfs3_bshrub_fetch ignores these for us if (err != LFS3_ERR_NOENT) { // start traversing - lfs3_btraversal_init(&t->u.bt); - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_BTREE); + lfs3_btrv_init(&trv->u.btrv); + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_BTREE); continue; // no? next we need to check any opened files } else { - t->ht = lfs3->handles; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OMDIRS); + trv->htrv = lfs3->handles; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OMDIRS); continue; } LFS3_UNREACHABLE(); @@ -9943,10 +9943,10 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, // // note we can skip checking opened files if mounted rdonly, // this saves a bit of code when compiled rdonly - if (lfs3_m_isrdonly(lfs3->flags) || !t->ht) { - t->ht = NULL; - t->b.h.mdir.mid += 1; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR); + if (lfs3_m_isrdonly(lfs3->flags) || !trv->htrv) { + trv->htrv = NULL; + trv->b.h.mdir.mid += 1; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR); continue; } @@ -9958,18 +9958,18 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, // literally every file open, but other things grow O(n^2) with // this list anyways // - if (t->ht->mdir.mid != t->b.h.mdir.mid - || lfs3_o_type(t->ht->flags) != LFS3_TYPE_REG - || !lfs3_o_isunsync(t->ht->flags)) { - t->ht = t->ht->next; + if (trv->htrv->mdir.mid != trv->b.h.mdir.mid + || lfs3_o_type(trv->htrv->flags) != LFS3_TYPE_REG + || !lfs3_o_isunsync(trv->htrv->flags)) { + trv->htrv = trv->htrv->next; continue; } // transition to traversing the file - const lfs3_file_t *file = (const lfs3_file_t*)t->ht; - t->b.shrub = file->b.shrub; - lfs3_btraversal_init(&t->u.bt); - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OBTREE); + const lfs3_file_t *file = (const lfs3_file_t*)trv->htrv; + trv->b.shrub = file->b.shrub; + lfs3_btrv_init(&trv->u.btrv); + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OBTREE); continue; #endif @@ -9980,30 +9980,30 @@ static lfs3_stag_t lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, case LFS3_TSTATE_BTREE:; case LFS3_TSTATE_OBTREE:; // traverse through our bshrub/btree - tag = lfs3_bshrub_traverse(lfs3, &t->b, &t->u.bt, + tag = lfs3_bshrub_traverse(lfs3, &trv->b, &trv->u.btrv, NULL, NULL, &data); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { // clear the bshrub state - lfs3_bshrub_init(&t->b); + lfs3_bshrub_init(&trv->b); // end of mtree? start iterating over mdirs - if (lfs3_t_tstate(t->b.h.flags) + if (lfs3_t_tstate(trv->b.h.flags) == LFS3_TSTATE_MTREE) { - t->b.h.mdir.mid = 0; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS); + trv->b.h.mdir.mid = 0; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS); continue; // end of mdir btree? start iterating over opened files - } else if (lfs3_t_tstate(t->b.h.flags) + } else if (lfs3_t_tstate(trv->b.h.flags) == LFS3_TSTATE_BTREE) { - t->ht = lfs3->handles; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OMDIRS); + trv->htrv = lfs3->handles; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OMDIRS); continue; // end of opened btree? go to next opened file } else if (lfs3_m_isrdonly(lfs3->flags) - || lfs3_t_tstate(t->b.h.flags) + || lfs3_t_tstate(trv->b.h.flags) == LFS3_TSTATE_OBTREE) { - t->ht = t->ht->next; - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_OMDIRS); + trv->htrv = trv->htrv->next; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_OMDIRS); continue; } else { LFS3_UNREACHABLE(); @@ -10049,9 +10049,9 @@ static void lfs3_alloc_markinuse(lfs3_t *lfs3, // high-level immutable traversal, handle extra features here, // but no mutation! (we're called in lfs3_alloc, so things would end up // recursive, which would be a bit bad!) -static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, +static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_trv_t *trv, lfs3_bptr_t *bptr_) { - lfs3_stag_t tag = lfs3_mtree_traverse_(lfs3, t, + lfs3_stag_t tag = lfs3_mtree_traverse_(lfs3, trv, bptr_); if (tag < 0) { // end of traversal? @@ -10071,8 +10071,8 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, // // we also compare mdir checksums with any open mdirs to try to // avoid traversing any outdated bshrubs/btrees - if ((lfs3_t_isckmeta(t->b.h.flags) - || lfs3_t_isckdata(t->b.h.flags)) + if ((lfs3_t_isckmeta(trv->b.h.flags) + || lfs3_t_isckdata(trv->b.h.flags)) && tag == LFS3_TAG_MDIR) { lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr_->d.u.buffer; @@ -10106,7 +10106,7 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, } // recalculate gcksum - t->gcksum ^= mdir->r.cksum; + trv->gcksum ^= mdir->r.cksum; } // validate btree nodes? @@ -10114,8 +10114,8 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, // this may end up revalidating some btree nodes when ckfetches // is enabled, but we need to revalidate cached btree nodes or // we risk missing errors in ckmeta scans - if ((lfs3_t_isckmeta(t->b.h.flags) - || lfs3_t_isckdata(t->b.h.flags)) + if ((lfs3_t_isckmeta(trv->b.h.flags) + || lfs3_t_isckdata(trv->b.h.flags)) && tag == LFS3_TAG_BRANCH) { lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr_->d.u.buffer; int err = lfs3_rbyd_fetchck(lfs3, rbyd, @@ -10128,7 +10128,7 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, // validate data blocks? #ifndef LFS3_2BONLY - if (lfs3_t_isckdata(t->b.h.flags) + if (lfs3_t_isckdata(trv->b.h.flags) && tag == LFS3_TAG_BLOCK) { int err = lfs3_bptr_ck(lfs3, bptr_); if (err) { @@ -10141,30 +10141,30 @@ static lfs3_stag_t lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, eot:; // compare gcksum with in-RAM gcksum - if ((lfs3_t_isckmeta(t->b.h.flags) - || lfs3_t_isckdata(t->b.h.flags)) - && !lfs3_t_isdirty(t->b.h.flags) - && !lfs3_t_ismutated(t->b.h.flags) - && t->gcksum != lfs3->gcksum) { + if ((lfs3_t_isckmeta(trv->b.h.flags) + || lfs3_t_isckdata(trv->b.h.flags)) + && !lfs3_t_isdirty(trv->b.h.flags) + && !lfs3_t_ismutated(trv->b.h.flags) + && trv->gcksum != lfs3->gcksum) { LFS3_ERROR("Found gcksum mismatch, cksum %08"PRIx32" (!= %08"PRIx32")", - t->gcksum, + trv->gcksum, lfs3->gcksum); return LFS3_ERR_CORRUPT; } // was ckmeta/ckdata successful? we only consider our filesystem // checked if we weren't mutated - if ((lfs3_t_isckmeta(t->b.h.flags) - || lfs3_t_isckdata(t->b.h.flags)) - && !lfs3_t_ismtreeonly(t->b.h.flags) - && !lfs3_t_isdirty(t->b.h.flags) - && !lfs3_t_ismutated(t->b.h.flags)) { + if ((lfs3_t_isckmeta(trv->b.h.flags) + || lfs3_t_isckdata(trv->b.h.flags)) + && !lfs3_t_ismtreeonly(trv->b.h.flags) + && !lfs3_t_isdirty(trv->b.h.flags) + && !lfs3_t_ismutated(trv->b.h.flags)) { lfs3->flags &= ~LFS3_I_CKMETA; } - if (lfs3_t_isckdata(t->b.h.flags) - && !lfs3_t_ismtreeonly(t->b.h.flags) - && !lfs3_t_isdirty(t->b.h.flags) - && !lfs3_t_ismutated(t->b.h.flags)) { + if (lfs3_t_isckdata(trv->b.h.flags) + && !lfs3_t_ismtreeonly(trv->b.h.flags) + && !lfs3_t_isdirty(trv->b.h.flags) + && !lfs3_t_ismutated(trv->b.h.flags)) { lfs3->flags &= ~LFS3_I_CKDATA; } @@ -10177,10 +10177,10 @@ static void lfs3_alloc_markfree(lfs3_t *lfs3); // high-level mutating traversal, handle extra features that require // mutation here, upper layers should call lfs3_alloc_ckpoint as needed -static lfs3_stag_t lfs3_mtree_gc(lfs3_t *lfs3, lfs3_traversal_t *t, +static lfs3_stag_t lfs3_mtree_gc(lfs3_t *lfs3, lfs3_trv_t *trv, lfs3_bptr_t *bptr_) { dropped:; - lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, t, + lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, trv, bptr_); if (tag < 0) { // end of traversal? @@ -10194,18 +10194,18 @@ dropped:; #ifndef LFS3_RDONLY // swap dirty/mutated flags while in lfs3_mtree_gc - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); int err; // track in-use blocks? #ifndef LFS3_2BONLY - if (lfs3_t_islookahead(t->b.h.flags)) { + if (lfs3_t_islookahead(trv->b.h.flags)) { lfs3_alloc_markinuse(lfs3, tag, bptr_); } #endif // mkconsistencing mdirs? - if (lfs3_t_ismkconsistent(t->b.h.flags) + if (lfs3_t_ismkconsistent(trv->b.h.flags) && lfs3_t_ismkconsistent(lfs3->flags) && tag == LFS3_TAG_MDIR) { lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr_->d.u.buffer; @@ -10215,22 +10215,22 @@ dropped:; } // make sure we clear any zombie flags - t->b.h.flags &= ~LFS3_o_ZOMBIE; + trv->b.h.flags &= ~LFS3_o_ZOMBIE; // did this drop our mdir? #ifndef LFS3_2BONLY if (mdir->mid != -1 && mdir->r.weight == 0) { // swap back dirty/mutated flags - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); // continue traversal - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS); + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS); goto dropped; } #endif } // compacting mdirs? - if (lfs3_t_iscompact(t->b.h.flags) + if (lfs3_t_iscompact(trv->b.h.flags) && tag == LFS3_TAG_MDIR // exceed compaction threshold? && lfs3_rbyd_eoff(&((lfs3_mdir_t*)bptr_->d.u.buffer)->r) @@ -10258,14 +10258,14 @@ dropped:; } // swap back dirty/mutated flags - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); #endif return tag; #ifndef LFS3_RDONLY failed:; // swap back dirty/mutated flags - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); return err; #endif @@ -10273,25 +10273,25 @@ eot:; #ifndef LFS3_RDONLY // was lookahead scan successful? #ifndef LFS3_2BONLY - if (lfs3_t_islookahead(t->b.h.flags) - && !lfs3_t_ismtreeonly(t->b.h.flags) - && !lfs3_t_isdirty(t->b.h.flags) - && !lfs3_t_ismutated(t->b.h.flags)) { + if (lfs3_t_islookahead(trv->b.h.flags) + && !lfs3_t_ismtreeonly(trv->b.h.flags) + && !lfs3_t_isdirty(trv->b.h.flags) + && !lfs3_t_ismutated(trv->b.h.flags)) { lfs3_alloc_markfree(lfs3); } #endif // was mkconsistent successful? - if (lfs3_t_ismkconsistent(t->b.h.flags) - && !lfs3_t_isdirty(t->b.h.flags)) { + if (lfs3_t_ismkconsistent(trv->b.h.flags) + && !lfs3_t_isdirty(trv->b.h.flags)) { lfs3->flags &= ~LFS3_I_MKCONSISTENT; } // was compaction successful? note we may need multiple passes if // we want to be sure everything is compacted - if (lfs3_t_iscompact(t->b.h.flags) - && !lfs3_t_isdirty(t->b.h.flags) - && !lfs3_t_ismutated(t->b.h.flags)) { + if (lfs3_t_iscompact(trv->b.h.flags) + && !lfs3_t_isdirty(trv->b.h.flags) + && !lfs3_t_ismutated(trv->b.h.flags)) { lfs3->flags &= ~LFS3_I_COMPACT; } #endif @@ -10506,11 +10506,11 @@ static lfs3_sblock_t lfs3_alloc(lfs3_t *lfs3, uint32_t flags) { // traverse the filesystem, building up knowledge of what blocks are // in-use in the next lookahead window // - lfs3_traversal_t t; - lfs3_traversal_init(&t, LFS3_T_RDONLY | LFS3_T_LOOKAHEAD); + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_LOOKAHEAD); while (true) { lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t, + lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv, &bptr); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { @@ -10876,11 +10876,11 @@ int lfs3_remove(lfs3_t *lfs3, const char *path) { } // clobber entangled traversals - } else if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL) { + } else if (lfs3_o_type(h->flags) == LFS3_type_TRV) { if (lfs3_o_iszombie(h->flags)) { h->flags &= ~LFS3_o_ZOMBIE; h->mdir.mid -= 1; - lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h); + lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h); } } } @@ -11061,10 +11061,10 @@ int lfs3_rename(lfs3_t *lfs3, const char *old_path, const char *new_path) { } // clobber entangled traversals - } else if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL + } else if (lfs3_o_type(h->flags) == LFS3_type_TRV && ((new_tag != LFS3_ERR_NOENT && h->mdir.mid == new_mdir.mid) || h->mdir.mid == lfs3->grm.queue[0])) { - lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h); + lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h); } } @@ -13706,9 +13706,9 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, #endif // clobber entangled traversals - if (lfs3_o_type(h->flags) == LFS3_type_TRAVERSAL + if (lfs3_o_type(h->flags) == LFS3_type_TRV && h->mdir.mid == file->b.h.mdir.mid) { - lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)h); + lfs3_trv_clobber(lfs3, (lfs3_trv_t*)h); } } @@ -14084,11 +14084,11 @@ failed:; static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file, uint32_t flags) { // traverse the file's bshrub/btree - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); while (true) { lfs3_data_t data; - lfs3_stag_t tag = lfs3_bshrub_traverse(lfs3, &file->b, &bt, + lfs3_stag_t tag = lfs3_bshrub_traverse(lfs3, &file->b, &btrv, NULL, NULL, &data); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { @@ -14965,11 +14965,11 @@ static int lfs3_mountinited(lfs3_t *lfs3) { // 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? - lfs3_traversal_t t; - lfs3_traversal_init(&t, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA); + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA); while (true) { lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t, + lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv, &bptr); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { @@ -15126,7 +15126,7 @@ static int lfs3_mountinited(lfs3_t *lfs3) { } // needed in lfs3_mount -static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, +static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_trv_t *trv, uint32_t flags, lfs3_soff_t steps); int lfs3_mount(lfs3_t *lfs3, uint32_t flags, @@ -15225,8 +15225,8 @@ int lfs3_mount(lfs3_t *lfs3, uint32_t flags, | LFS3_IFDEF_RDONLY(0, LFS3_M_COMPACT) | LFS3_M_CKMETA | LFS3_M_CKDATA)) { - lfs3_traversal_t t; - err = lfs3_fs_gc_(lfs3, &t, + lfs3_trv_t trv; + err = lfs3_fs_gc_(lfs3, &trv, flags & ( LFS3_IFDEF_RDONLY(0, LFS3_M_MKCONSISTENT) | LFS3_IFDEF_RDONLY(0, LFS3_M_LOOKAHEAD) @@ -15267,8 +15267,8 @@ int lfs3_unmount(lfs3_t *lfs3) { LFS3_ASSERT(lfs3->handles == NULL // special case for our gc traversal handle || LFS3_IFDEF_GC( - (lfs3->handles == &lfs3->gc.t.b.h - && lfs3->gc.t.b.h.next == NULL), + (lfs3->handles == &lfs3->gc.trv.b.h + && lfs3->gc.trv.b.h.next == NULL), false)); return lfs3_deinit(lfs3); @@ -15439,8 +15439,8 @@ int lfs3_format(lfs3_t *lfs3, uint32_t flags, if (flags & ( LFS3_F_CKMETA | LFS3_F_CKDATA)) { - lfs3_traversal_t t; - err = lfs3_fs_gc_(lfs3, &t, + lfs3_trv_t trv; + err = lfs3_fs_gc_(lfs3, &trv, flags & ( LFS3_F_CKMETA | LFS3_F_CKDATA), @@ -15496,11 +15496,11 @@ int lfs3_fs_stat(lfs3_t *lfs3, struct lfs3_fsinfo *fsinfo) { lfs3_ssize_t lfs3_fs_usage(lfs3_t *lfs3) { lfs3_size_t count = 0; - lfs3_traversal_t t; - lfs3_traversal_init(&t, LFS3_T_RDONLY); + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY); while (true) { lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t, + lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv, &bptr); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { @@ -15640,12 +15640,12 @@ failed:; #ifndef LFS3_RDONLY static int lfs3_fs_fixorphans(lfs3_t *lfs3) { // LFS3_T_MKCONSISTENT really just removes orphans - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDWR | LFS3_T_MTREEONLY | LFS3_T_MKCONSISTENT); while (true) { lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_gc(lfs3, &t, + lfs3_stag_t tag = lfs3_mtree_gc(lfs3, &trv, &bptr); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { @@ -15692,11 +15692,11 @@ int lfs3_fs_mkconsistent(lfs3_t *lfs3) { // filesystem check functions static int lfs3_fs_ck(lfs3_t *lfs3, uint32_t flags) { // we leave this up to lfs3_mtree_traverse - lfs3_traversal_t t; - lfs3_traversal_init(&t, flags); + lfs3_trv_t trv; + lfs3_trv_init(&trv, flags); while (true) { lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &t, + lfs3_stag_t tag = lfs3_mtree_traverse(lfs3, &trv, &bptr); if (tag < 0) { if (tag == LFS3_ERR_NOENT) { @@ -15727,7 +15727,7 @@ int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum) { // // runs the traversal until all work is completed, which may take // multiple passes -static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, +static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_trv_t *trv, uint32_t flags, lfs3_soff_t steps) { // unknown gc flags? // @@ -15774,41 +15774,41 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, #endif // start a new traversal? - if (!lfs3_handle_isopen(lfs3, &t->b.h)) { - lfs3_traversal_init(t, pending); - lfs3_handle_open(lfs3, &t->b.h); + if (!lfs3_handle_isopen(lfs3, &trv->b.h)) { + lfs3_trv_init(trv, pending); + lfs3_handle_open(lfs3, &trv->b.h); } // don't bother with lookahead if we've mutated #ifndef LFS3_RDONLY - if (lfs3_t_isdirty(t->b.h.flags) - || lfs3_t_ismutated(t->b.h.flags)) { - t->b.h.flags &= ~LFS3_T_LOOKAHEAD; + if (lfs3_t_isdirty(trv->b.h.flags) + || lfs3_t_ismutated(trv->b.h.flags)) { + trv->b.h.flags &= ~LFS3_T_LOOKAHEAD; } #endif // will this traversal still make progress? no? start over - if (!(t->b.h.flags & ( + if (!(trv->b.h.flags & ( LFS3_IFDEF_RDONLY(0, LFS3_T_MKCONSISTENT) | LFS3_IFDEF_RDONLY(0, LFS3_T_LOOKAHEAD) | LFS3_IFDEF_RDONLY(0, LFS3_T_COMPACT) | LFS3_T_CKMETA | LFS3_T_CKDATA))) { - lfs3_handle_close(lfs3, &t->b.h); + lfs3_handle_close(lfs3, &trv->b.h); continue; } // do we really need a full traversal? - if (!(t->b.h.flags & ( + if (!(trv->b.h.flags & ( LFS3_IFDEF_RDONLY(0, LFS3_T_LOOKAHEAD) | LFS3_T_CKMETA | LFS3_T_CKDATA))) { - t->b.h.flags |= LFS3_T_MTREEONLY; + trv->b.h.flags |= LFS3_T_MTREEONLY; } // progress gc lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_gc(lfs3, t, + lfs3_stag_t tag = lfs3_mtree_gc(lfs3, trv, &bptr); if (tag < 0 && tag != LFS3_ERR_NOENT) { return tag; @@ -15816,7 +15816,7 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, // end of traversal? if (tag == LFS3_ERR_NOENT) { - lfs3_handle_close(lfs3, &t->b.h); + lfs3_handle_close(lfs3, &trv->b.h); // clear any pending flags we make progress on pending &= lfs3->flags & ( @@ -15841,7 +15841,7 @@ static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, // perform any pending janitorial work #ifdef LFS3_GC int lfs3_fs_gc(lfs3_t *lfs3) { - return lfs3_fs_gc_(lfs3, &lfs3->gc.t, + return lfs3_fs_gc_(lfs3, &lfs3->gc.trv, lfs3->cfg->gc_flags, (lfs3->cfg->gc_steps) ? lfs3->cfg->gc_steps @@ -15867,7 +15867,7 @@ int lfs3_fs_unck(lfs3_t *lfs3, uint32_t flags) { // lfs3_fs_gc will terminate early if it discovers it can no longer // make progress #ifdef LFS3_GC - lfs3->gc.t.b.h.flags &= ~flags; + lfs3->gc.trv.b.h.flags &= ~flags; #endif return 0; @@ -15937,12 +15937,12 @@ failed:; /// High-level filesystem traversal /// -// needed in lfs3_traversal_open -static int lfs3_traversal_rewind_(lfs3_t *lfs3, lfs3_traversal_t *t); +// needed in lfs3_trv_open +static int lfs3_trv_rewind_(lfs3_t *lfs3, lfs3_trv_t *trv); -int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags) { +int lfs3_trv_open(lfs3_t *lfs3, lfs3_trv_t *trv, uint32_t flags) { // already open? - LFS3_ASSERT(!lfs3_handle_isopen(lfs3, &t->b.h)); + LFS3_ASSERT(!lfs3_handle_isopen(lfs3, &trv->b.h)); // unknown flags? LFS3_ASSERT((flags & ~( LFS3_IFDEF_RDONLY(0, LFS3_T_RDWR) @@ -15964,46 +15964,46 @@ int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags) { LFS3_ASSERT(!lfs3_t_ismtreeonly(flags) || !lfs3_t_isckdata(flags)); // setup traversal state - t->b.h.flags = flags | lfs3_o_typeflags(LFS3_type_TRAVERSAL); + trv->b.h.flags = flags | lfs3_o_typeflags(LFS3_type_TRV); // let rewind initialize/reset things - int err = lfs3_traversal_rewind_(lfs3, t); + int err = lfs3_trv_rewind_(lfs3, trv); if (err) { return err; } // add to tracked mdirs - lfs3_handle_open(lfs3, &t->b.h); + lfs3_handle_open(lfs3, &trv->b.h); return 0; } -int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t) { - LFS3_ASSERT(lfs3_handle_isopen(lfs3, &t->b.h)); +int lfs3_trv_close(lfs3_t *lfs3, lfs3_trv_t *trv) { + LFS3_ASSERT(lfs3_handle_isopen(lfs3, &trv->b.h)); // remove from tracked mdirs - lfs3_handle_close(lfs3, &t->b.h); + lfs3_handle_close(lfs3, &trv->b.h); return 0; } -int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, +int lfs3_trv_read(lfs3_t *lfs3, lfs3_trv_t *trv, struct lfs3_tinfo *tinfo) { - LFS3_ASSERT(lfs3_handle_isopen(lfs3, &t->b.h)); + LFS3_ASSERT(lfs3_handle_isopen(lfs3, &trv->b.h)); // check for pending grms every step, just in case some other // operation introduced new grms #ifndef LFS3_RDONLY - if (lfs3_t_ismkconsistent(t->b.h.flags) + if (lfs3_t_ismkconsistent(trv->b.h.flags) && lfs3_grm_count(lfs3) > 0) { // swap dirty/mutated flags while mutating - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); int err = lfs3_fs_fixgrm(lfs3); if (err) { - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); return err; } - t->b.h.flags = lfs3_t_swapdirty(t->b.h.flags); + trv->b.h.flags = lfs3_t_swapdirty(trv->b.h.flags); } #endif @@ -16014,19 +16014,19 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, while (true) { // some redund blocks left over? - if (t->blocks[0] != -1) { + if (trv->blocks[0] != -1) { // write our traversal info - tinfo->btype = lfs3_t_btype(t->b.h.flags); - tinfo->block = t->blocks[0]; + tinfo->btype = lfs3_t_btype(trv->b.h.flags); + tinfo->block = trv->blocks[0]; - t->blocks[0] = t->blocks[1]; - t->blocks[1] = -1; + trv->blocks[0] = trv->blocks[1]; + trv->blocks[1] = -1; return 0; } // find next block lfs3_bptr_t bptr; - lfs3_stag_t tag = lfs3_mtree_gc(lfs3, t, + lfs3_stag_t tag = lfs3_mtree_gc(lfs3, trv, &bptr); if (tag < 0) { return tag; @@ -16035,20 +16035,20 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, // figure out type/blocks if (tag == LFS3_TAG_MDIR) { lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.d.u.buffer; - lfs3_t_setbtype(&t->b.h.flags, LFS3_BTYPE_MDIR); - t->blocks[0] = mdir->r.blocks[0]; - t->blocks[1] = mdir->r.blocks[1]; + lfs3_t_setbtype(&trv->b.h.flags, LFS3_BTYPE_MDIR); + trv->blocks[0] = mdir->r.blocks[0]; + trv->blocks[1] = mdir->r.blocks[1]; } else if (tag == LFS3_TAG_BRANCH) { - lfs3_t_setbtype(&t->b.h.flags, LFS3_BTYPE_BTREE); + lfs3_t_setbtype(&trv->b.h.flags, LFS3_BTYPE_BTREE); lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.d.u.buffer; - t->blocks[0] = rbyd->blocks[0]; - t->blocks[1] = -1; + trv->blocks[0] = rbyd->blocks[0]; + trv->blocks[1] = -1; } else if (tag == LFS3_TAG_BLOCK) { - lfs3_t_setbtype(&t->b.h.flags, LFS3_BTYPE_DATA); - t->blocks[0] = lfs3_bptr_block(&bptr); - t->blocks[1] = -1; + lfs3_t_setbtype(&trv->b.h.flags, LFS3_BTYPE_DATA); + trv->blocks[0] = lfs3_bptr_block(&bptr); + trv->blocks[1] = -1; } else { LFS3_UNREACHABLE(); @@ -16057,68 +16057,68 @@ int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, } #ifndef LFS3_RDONLY -static void lfs3_traversal_clobber(lfs3_t *lfs3, lfs3_traversal_t *t) { +static void lfs3_trv_clobber(lfs3_t *lfs3, lfs3_trv_t *trv) { (void)lfs3; // mroot/mtree? transition to mdir iteration if (LFS3_IFDEF_2BONLY( false, - lfs3_t_tstate(t->b.h.flags) < LFS3_TSTATE_MDIRS)) { + lfs3_t_tstate(trv->b.h.flags) < LFS3_TSTATE_MDIRS)) { #ifndef LFS3_2BONLY - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIRS); - t->b.h.mdir.mid = 0; - lfs3_bshrub_init(&t->b); - t->ht = NULL; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIRS); + trv->b.h.mdir.mid = 0; + lfs3_bshrub_init(&trv->b); + trv->htrv = NULL; #endif // in-mtree mdir? increment the mid (to make progress) and reset to // mdir iteration } else if (LFS3_IFDEF_2BONLY( false, - lfs3_t_tstate(t->b.h.flags) < LFS3_TSTATE_OMDIRS)) { + lfs3_t_tstate(trv->b.h.flags) < LFS3_TSTATE_OMDIRS)) { #ifndef LFS3_2BONLY - lfs3_t_settstate(&t->b.h.flags, LFS3_TSTATE_MDIR); - t->b.h.mdir.mid += 1; - lfs3_bshrub_init(&t->b); - t->ht = NULL; + lfs3_t_settstate(&trv->b.h.flags, LFS3_TSTATE_MDIR); + trv->b.h.mdir.mid += 1; + lfs3_bshrub_init(&trv->b); + trv->htrv = NULL; #endif // opened mdir? skip to next omdir - } else if (lfs3_t_tstate(t->b.h.flags) < LFS3_TSTATE_DONE) { - lfs3_t_settstate(&t->b.h.flags, LFS3_IFDEF_2BONLY( + } else if (lfs3_t_tstate(trv->b.h.flags) < LFS3_TSTATE_DONE) { + lfs3_t_settstate(&trv->b.h.flags, LFS3_IFDEF_2BONLY( LFS3_TSTATE_DONE, LFS3_TSTATE_OMDIRS)); - lfs3_bshrub_init(&t->b); - t->ht = (t->ht) ? t->ht->next : NULL; + lfs3_bshrub_init(&trv->b); + trv->htrv = (trv->htrv) ? trv->htrv->next : NULL; // done traversals should never need clobbering } else { LFS3_UNREACHABLE(); } // and clear any pending blocks - t->blocks[0] = -1; - t->blocks[1] = -1; + trv->blocks[0] = -1; + trv->blocks[1] = -1; } #endif -static int lfs3_traversal_rewind_(lfs3_t *lfs3, lfs3_traversal_t *t) { +static int lfs3_trv_rewind_(lfs3_t *lfs3, lfs3_trv_t *trv) { (void)lfs3; // reset traversal - lfs3_traversal_init(t, - t->b.h.flags + lfs3_trv_init(trv, + trv->b.h.flags & ~LFS3_t_DIRTY & ~LFS3_t_MUTATED & ~LFS3_t_TSTATE); // and clear any pending blocks - t->blocks[0] = -1; - t->blocks[1] = -1; + trv->blocks[0] = -1; + trv->blocks[1] = -1; return 0; } -int lfs3_traversal_rewind(lfs3_t *lfs3, lfs3_traversal_t *t) { - LFS3_ASSERT(lfs3_handle_isopen(lfs3, &t->b.h)); +int lfs3_trv_rewind(lfs3_t *lfs3, lfs3_trv_t *trv) { + LFS3_ASSERT(lfs3_handle_isopen(lfs3, &trv->b.h)); - return lfs3_traversal_rewind_(lfs3, t); + return lfs3_trv_rewind_(lfs3, trv); } diff --git a/lfs3.h b/lfs3.h index 4bc29f17..f94b780c 100644 --- a/lfs3.h +++ b/lfs3.h @@ -108,7 +108,7 @@ enum lfs3_type { // internally used types, don't use these LFS3_type_BOOKMARK = 4, // Directory bookmark LFS3_type_ORPHAN = 5, // An orphaned stickynote - LFS3_type_TRAVERSAL = 6, // An open traversal object + LFS3_type_TRV = 6, // An open traversal object }; // File open flags @@ -757,20 +757,20 @@ typedef struct lfs3_dir { lfs3_off_t pos; } lfs3_dir_t; -typedef struct lfs3_btraversal { +typedef struct lfs3_btrv { lfs3_bid_t bid; const lfs3_rbyd_t *branch; lfs3_srid_t rid; lfs3_rbyd_t rbyd; -} lfs3_btraversal_t; +} lfs3_btrv_t; // littlefs traversal type -typedef struct lfs3_traversal { +typedef struct lfs3_trv { // mdir/bshrub/btree state, this also includes our traversal // state machine lfs3_bshrub_t b; // opened file state - lfs3_handle_t *ht; + lfs3_handle_t *htrv; union { // cycle detection state, only valid when traversing the mroot chain struct { @@ -779,16 +779,16 @@ typedef struct lfs3_traversal { uint8_t power; } mtortoise; // btree traversal state - lfs3_btraversal_t bt; + lfs3_btrv_t btrv; // graft traversal state - lfs3_size_t gt; + lfs3_size_t gtrv; } u; // recalculate gcksum when traversing with ckmeta uint32_t gcksum; - // pending blocks, only used in lfs3_traversal_read + // pending blocks, only used in lfs3_trv_read lfs3_sblock_t blocks[2]; -} lfs3_traversal_t; +} lfs3_trv_t; // grm encoding: // .- -+- -+- -+- -+- -. mids: 2 leb128s <=2x5 bytes @@ -886,7 +886,7 @@ typedef struct lfs3 { // optional incremental gc state #ifdef LFS3_GC struct { - lfs3_traversal_t t; + lfs3_trv_t trv; } gc; #endif } lfs3_t; @@ -1241,13 +1241,13 @@ int lfs3_dir_rewind(lfs3_t *lfs3, lfs3_dir_t *dir); // the filesystem. // // Returns a negative error code on failure. -int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags); +int lfs3_trv_open(lfs3_t *lfs3, lfs3_trv_t *trv, uint32_t flags); // Close a traversal // // Releases any allocated resources. // Returns a negative error code on failure. -int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t); +int lfs3_trv_close(lfs3_t *lfs3, lfs3_trv_t *trv); // Progress the traversal and read an entry // @@ -1255,13 +1255,13 @@ int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t); // // Returns 0 on success, LFS3_ERR_NOENT at the end of traversal, or a // negative error code on failure. -int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, +int lfs3_trv_read(lfs3_t *lfs3, lfs3_trv_t *trv, struct lfs3_tinfo *tinfo); // Reset the traversal // // Returns a negative error code on failure. -int lfs3_traversal_rewind(lfs3_t *lfs3, lfs3_traversal_t *t); +int lfs3_trv_rewind(lfs3_t *lfs3, lfs3_trv_t *trv); /// Filesystem-level filesystem operations diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml index ced52afe..c88ea52a 100644 --- a/tests/test_alloc.toml +++ b/tests/test_alloc.toml @@ -180,8 +180,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); for (lfs3_block_t i = 0;; i++) { @@ -190,7 +190,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -351,8 +351,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); for (lfs3_block_t i = 0;; i++) { @@ -361,7 +361,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -508,8 +508,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); for (lfs3_block_t i = 0;; i++) { @@ -518,7 +518,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index dcaf4fed..ae220b78 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -4,7 +4,7 @@ after = [ 'test_files', 'test_fwrite', 'test_stickynotes', - 'test_traversal', + 'test_trvs', 'test_gc', 'test_mount', 'test_ck', diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 9e77b7b3..92c381d1 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -4305,8 +4305,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i <= 2*N); @@ -4315,7 +4315,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_btree_traverse(&lfs3, &btree, &bt, + tag = lfs3_btree_traverse(&lfs3, &btree, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -4463,8 +4463,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i <= 2*N); @@ -4473,7 +4473,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_btree_traverse(&lfs3, &btree, &bt, + tag = lfs3_btree_traverse(&lfs3, &btree, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { diff --git a/tests/test_ck.toml b/tests/test_ck.toml index 7fdc2bf5..699086a9 100644 --- a/tests/test_ck.toml +++ b/tests/test_ck.toml @@ -1,5 +1,5 @@ # Test checksum validation things -after = ['test_traversal', 'test_gc', 'test_mount'] +after = ['test_trvs', 'test_gc', 'test_mount'] code = ''' @@ -182,7 +182,7 @@ code = ''' [cases.test_ck_ckmeta_easy] # METHOD=0 => lfs3_fs_ckmeta # METHOD=1 => lfs3_fs_gc -# METHOD=2 => lfs3_traversal_read +# METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS3_GC_CKMETA' @@ -230,17 +230,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -259,7 +259,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -280,22 +280,22 @@ code = ''' LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfs3_traversal_read + // find clobbered blocks with lfs3_trv_read } else if (METHOD == 2) { - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { @@ -319,7 +319,7 @@ done:; [cases.test_ck_ckdata_easy] # METHOD=0 => lfs3_fs_ckdata # METHOD=1 => lfs3_fs_gc -# METHOD=2 => lfs3_traversal_read +# METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS3_GC_CKDATA' @@ -367,17 +367,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -397,7 +397,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -418,22 +418,22 @@ code = ''' LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfs3_traversal_read + // find clobbered blocks with lfs3_trv_read } else if (METHOD == 2) { - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { @@ -458,7 +458,7 @@ done:; [cases.test_ck_ckmeta_hard] # METHOD=0 => lfs3_fs_ckmeta # METHOD=1 => lfs3_fs_gc -# METHOD=2 => lfs3_traversal_read +# METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS3_GC_CKMETA' @@ -509,18 +509,18 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; lfs3_block_t badblock; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -530,7 +530,7 @@ code = ''' // found an interesting block? if (k == i) { badblock = tinfo.block; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobber; } k += 1; @@ -570,17 +570,17 @@ code = ''' LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfs3_traversal_read + // find clobbered blocks with lfs3_trv_read } else if (METHOD == 2) { - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -588,11 +588,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto detected; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { @@ -713,7 +713,7 @@ done:; [cases.test_ck_ckdata_hard] # METHOD=0 => lfs3_fs_ckdata # METHOD=1 => lfs3_fs_gc -# METHOD=2 => lfs3_traversal_read +# METHOD=2 => lfs3_trv_read # METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] defines.GC_FLAGS = 'LFS3_GC_CKDATA' @@ -764,18 +764,18 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; lfs3_block_t badblock; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -786,7 +786,7 @@ code = ''' // found an interesting block? if (k == i) { badblock = tinfo.block; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobber; } k += 1; @@ -826,17 +826,17 @@ code = ''' LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfs3_traversal_read + // find clobbered blocks with lfs3_trv_read } else if (METHOD == 2) { - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -844,11 +844,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto detected; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { @@ -1007,17 +1007,17 @@ code = ''' lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_file_close(&lfs3, &file) => 0; lfs3_unmount(&lfs3) => 0; goto done; @@ -1032,7 +1032,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1104,17 +1104,17 @@ code = ''' lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_file_close(&lfs3, &file) => 0; lfs3_unmount(&lfs3) => 0; goto done; @@ -1130,7 +1130,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1208,18 +1208,18 @@ code = ''' lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; lfs3_block_t badblock; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_file_close(&lfs3, &file) => 0; lfs3_unmount(&lfs3) => 0; goto done; @@ -1229,7 +1229,7 @@ code = ''' // found an interesting block? if (k == i) { badblock = tinfo.block; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobber; } k += 1; @@ -1356,18 +1356,18 @@ code = ''' lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; lfs3_block_t badblock; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_file_close(&lfs3, &file) => 0; lfs3_unmount(&lfs3) => 0; goto done; @@ -1378,7 +1378,7 @@ code = ''' // found an interesting block? if (k == i) { badblock = tinfo.block; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobber; } k += 1; @@ -1578,18 +1578,18 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // find the data block - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t badblock; while (true) { struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; if (tinfo.btype == LFS3_BTYPE_DATA) { badblock = tinfo.block; break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; @@ -1689,18 +1689,18 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // find the btree block - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t badblock; while (true) { struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; if (tinfo.btype == LFS3_BTYPE_BTREE) { badblock = tinfo.block; break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; @@ -2088,18 +2088,18 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // find the data block - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t badblock; while (true) { struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; if (tinfo.btype == LFS3_BTYPE_DATA) { badblock = tinfo.block; break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; @@ -2199,18 +2199,18 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // find the btree block - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t badblock; while (true) { struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; if (tinfo.btype == LFS3_BTYPE_BTREE) { badblock = tinfo.block; break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; @@ -2462,18 +2462,18 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // find the btree block - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t badblock; while (true) { struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; if (tinfo.btype == LFS3_BTYPE_BTREE) { badblock = tinfo.block; break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; @@ -2606,18 +2606,18 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // find the data block - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t badblock; while (true) { struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; if (tinfo.btype == LFS3_BTYPE_DATA) { badblock = tinfo.block; break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; @@ -2834,15 +2834,15 @@ code = ''' // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -2850,11 +2850,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto corrupt_mounted; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } } @@ -3152,15 +3152,15 @@ code = ''' // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -3168,11 +3168,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto corrupt_mounted; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } } @@ -3568,15 +3568,15 @@ code = ''' // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -3584,11 +3584,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto corrupt_open; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } } @@ -3851,15 +3851,15 @@ code = ''' // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -3867,11 +3867,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto corrupt_mounted; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } } @@ -4451,15 +4451,15 @@ code = ''' // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops LFS3_ASSERT(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT || err == LFS3_ERR_CORRUPT); @@ -4467,11 +4467,11 @@ code = ''' break; } if (err == LFS3_ERR_CORRUPT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto corrupt_mounted; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } } diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml index b8c39631..c437aa41 100644 --- a/tests/test_fwrite.toml +++ b/tests/test_fwrite.toml @@ -183,8 +183,8 @@ code = ''' lfs3_size_t fragments = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -193,7 +193,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -331,8 +331,8 @@ code = ''' lfs3_block_t blocks = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -341,7 +341,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -597,8 +597,8 @@ code = ''' lfs3_size_t fragments = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -607,7 +607,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -760,8 +760,8 @@ code = ''' lfs3_block_t blocks = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -770,7 +770,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -2088,8 +2088,8 @@ code = ''' lfs3_size_t fragments = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -2098,7 +2098,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -2240,8 +2240,8 @@ code = ''' lfs3_size_t fragments = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -2250,7 +2250,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -2539,8 +2539,8 @@ code = ''' lfs3_size_t fragments = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -2549,7 +2549,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -2706,8 +2706,8 @@ code = ''' lfs3_block_t blocks = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -2716,7 +2716,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -2999,8 +2999,8 @@ code = ''' lfs3_size_t fragments = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -3009,7 +3009,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -3170,8 +3170,8 @@ code = ''' lfs3_block_t blocks = 0; lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; - lfs3_btraversal_t bt; - lfs3_btraversal_init(&bt); + lfs3_btrv_t btrv; + lfs3_btrv_init(&btrv); for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); @@ -3180,7 +3180,7 @@ code = ''' lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &btrv, &bid, &weight, &data); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { diff --git a/tests/test_gc.toml b/tests/test_gc.toml index bb32e44c..d77a2526 100644 --- a/tests/test_gc.toml +++ b/tests/test_gc.toml @@ -1,8 +1,8 @@ # Test GC things -# most of the GC logic is tested in test_traversal, we just test +# most of the GC logic is tested in test_trvs, we just test # GC-API specific things here -after = ['test_traversal'] +after = ['test_trvs'] # test that lookahead can make progress in isolation [cases.test_gc_lookahead_progress] @@ -45,7 +45,7 @@ code = ''' struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags & LFS3_I_LOOKAHEAD); - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); // run GC until we make progress for (lfs3_block_t i = 0;; i++) { @@ -112,11 +112,11 @@ code = ''' struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags & LFS3_I_LOOKAHEAD); - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); // run GC one step lfs3_fs_gc(&lfs3) => 0; - assert(lfs3.handles == &lfs3.gc.t.b.h); + assert(lfs3.handles == &lfs3.gc.trv.b.h); // mutate the filesystem lfs3_file_open(&lfs3, &file, "spider", @@ -128,7 +128,7 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // run GC until our traversal is done - while (lfs3.handles == &lfs3.gc.t.b.h) { + while (lfs3.handles == &lfs3.gc.trv.b.h) { lfs3_fs_gc(&lfs3) => 0; } @@ -197,7 +197,7 @@ code = ''' struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags & LFS3_I_COMPACT); - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); // run GC until we make progress for (lfs3_block_t i = 0;; i++) { @@ -286,19 +286,19 @@ code = ''' struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags & LFS3_I_COMPACT); - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); // run GC one traversal + one step while (true) { lfs3_fs_gc(&lfs3) => 0; // internal traversal done? - if (lfs3.handles != &lfs3.gc.t.b.h) { + if (lfs3.handles != &lfs3.gc.trv.b.h) { break; } } lfs3_fs_gc(&lfs3) => 0; - assert(lfs3.handles == &lfs3.gc.t.b.h); + assert(lfs3.handles == &lfs3.gc.trv.b.h); // mutate the filesystem lfs3_file_rewind(&lfs3, &file) => 0; @@ -309,7 +309,7 @@ code = ''' lfs3_file_sync(&lfs3, &file) => 0; // run GC until our traversal is done (twice for compact) - while (lfs3.handles == &lfs3.gc.t.b.h) { + while (lfs3.handles == &lfs3.gc.trv.b.h) { lfs3_fs_gc(&lfs3) => 0; } @@ -410,7 +410,7 @@ code = ''' struct lfs3_fsinfo fsinfo; lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags & LFS3_I_MKCONSISTENT); - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); // run GC until we make progress for (lfs3_block_t i = 0;; i++) { @@ -513,7 +513,7 @@ code = ''' lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags & LFS3_I_MKCONSISTENT); #ifdef LFS3_GC - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); #endif // call lfs3_fs_mkconsistent @@ -614,9 +614,9 @@ code = ''' } // run GC one step - assert(lfs3.handles != &lfs3.gc.t.b.h); + assert(lfs3.handles != &lfs3.gc.trv.b.h); lfs3_fs_gc(&lfs3) => 0; - assert(lfs3.handles == &lfs3.gc.t.b.h); + assert(lfs3.handles == &lfs3.gc.trv.b.h); // create the rest of the orphans after GC has started for (lfs3_size_t i = 0; i < ORPHANS; i++) { @@ -638,7 +638,7 @@ code = ''' assert(fsinfo.flags & LFS3_I_MKCONSISTENT); // run GC until our traversal is done - while (lfs3.handles == &lfs3.gc.t.b.h) { + while (lfs3.handles == &lfs3.gc.trv.b.h) { lfs3_fs_gc(&lfs3) => 0; } @@ -721,17 +721,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -750,7 +750,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -821,17 +821,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -851,7 +851,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -923,17 +923,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -952,7 +952,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -1010,17 +1010,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1040,7 +1040,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -1062,7 +1062,7 @@ done:; [cases.test_gc_ckmeta_unck] # AFTER=0 => after running lfs3_fs_gc once # AFTER=1 => after running lfs3_fs_gc to completion -# AFTER=2 => after running lfs3_traversal_t +# AFTER=2 => after running lfs3_trv_t # AFTER=3 => after lfs3_fs_ckmeta # AFTER=4 => after remounting with LFS3_M_CKMETA defines.AFTER = [0, 1, 2, 3, 4] @@ -1127,19 +1127,19 @@ code = ''' lfs3_fs_gc(&lfs3) => 0; } - // run lfs3_traversal_t + // run lfs3_trv_t } else if (AFTER == 2) { - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // run lfs3_fs_ckmeta } else if (AFTER == 3) { @@ -1163,17 +1163,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1192,7 +1192,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -1225,7 +1225,7 @@ done:; [cases.test_gc_ckdata_unck] # AFTER=0 => after running lfs3_fs_gc once # AFTER=1 => after running lfs3_fs_gc to completion -# AFTER=2 => after running lfs3_traversal_t +# AFTER=2 => after running lfs3_trv_t # AFTER=3 => after lfs3_fs_ckdata # AFTER=4 => after remounting with LFS3_M_CKDATA defines.AFTER = [0, 1, 2, 3, 4] @@ -1290,19 +1290,19 @@ code = ''' lfs3_fs_gc(&lfs3) => 0; } - // run lfs3_traversal_t + // run lfs3_trv_t } else if (AFTER == 2) { - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // run lfs3_fs_ckdata } else if (AFTER == 3) { @@ -1326,17 +1326,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1356,7 +1356,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -1392,7 +1392,7 @@ done:; # test that gc work clears flags in lfs3_fs_stat [cases.test_gc_iflags] # AFTER=0 => after running lfs3_fs_gc -# AFTER=1 => after running lfs3_traversal_t +# AFTER=1 => after running lfs3_trv_t # AFTER=2 => after explicit operations # AFTER=3 => after remounting defines.AFTER = [0, 1, 2, 3] @@ -1468,7 +1468,7 @@ code = ''' assert(false); #endif - // run lfs3_traversal_t + // run lfs3_trv_t } else if (AFTER == 1) { while (true) { // it may take multiple traversals to do all pending work @@ -1482,17 +1482,17 @@ code = ''' break; } - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } // run explicit operations @@ -1517,34 +1517,34 @@ code = ''' if (LOOKAHEAD) { // we need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } if (COMPACT) { // we need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } if (CKMETA) { @@ -1581,7 +1581,7 @@ code = ''' # test that gc work clears flags in lfs3_fs_stat after lfs3_fs_unck [cases.test_gc_iflags_unck] # AFTER=0 => after running lfs3_fs_gc -# AFTER=1 => after running lfs3_traversal_t +# AFTER=1 => after running lfs3_trv_t # AFTER=2 => after explicit operations # AFTER=3 => after remounting defines.AFTER = [0, 1, 2, 3] @@ -1657,7 +1657,7 @@ code = ''' assert(false); #endif - // run lfs3_traversal_t + // run lfs3_trv_t } else if (AFTER == 1) { while (true) { // it may take multiple traversals to do all pending work @@ -1671,17 +1671,17 @@ code = ''' break; } - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } // run explicit operations @@ -1706,34 +1706,34 @@ code = ''' if (LOOKAHEAD) { // we need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } if (COMPACT) { // we need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } if (CKMETA) { @@ -1786,7 +1786,7 @@ code = ''' assert(false); #endif - // run lfs3_traversal_t + // run lfs3_trv_t } else if (AFTER == 1) { while (true) { // it may take multiple traversals to do all pending work @@ -1800,17 +1800,17 @@ code = ''' break; } - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } // run explicit operations @@ -1835,34 +1835,34 @@ code = ''' if (LOOKAHEAD) { // we need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } if (COMPACT) { // we need an explicit traversal for this - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT) => 0; while (true) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(err == 0 || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; } if (CKMETA) { diff --git a/tests/test_mount.toml b/tests/test_mount.toml index 9e4324f2..f996a3ab 100644 --- a/tests/test_mount.toml +++ b/tests/test_mount.toml @@ -1,5 +1,5 @@ # Advanced mount tests -after = ['test_mtree', 'test_traversal'] +after = ['test_mtree', 'test_trvs'] # test we can mount @@ -405,17 +405,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -434,7 +434,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto clobbered; } @@ -494,17 +494,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -524,7 +524,7 @@ code = ''' clobber_buf, BLOCK_SIZE) => 0; if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto clobbered; } diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 4b892869..c7a34bdf 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -3665,8 +3665,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -3676,7 +3676,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -3787,8 +3787,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -3798,7 +3798,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -3935,8 +3935,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -3946,7 +3946,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -4106,8 +4106,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -4117,7 +4117,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -4257,8 +4257,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -4268,7 +4268,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -4383,8 +4383,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -4394,7 +4394,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -4553,8 +4553,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | ((CKMETA) ? LFS3_T_CKMETA : 0)); @@ -4564,7 +4564,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_NOENT); if (tag == LFS3_ERR_NOENT) { @@ -4686,8 +4686,8 @@ code = ''' LFS3_MPTR_MROOTANCHOR()))) => 0; // technically, cycle detection only needs to work when we're validating - lfs3_traversal_t t; - lfs3_traversal_init(&t, + lfs3_trv_t trv; + lfs3_trv_init(&trv, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA); for (lfs3_block_t i = 0;; i++) { // assert that we detect the cycle in a reasonable number of iterations @@ -4695,7 +4695,7 @@ code = ''' lfs3_stag_t tag; lfs3_bptr_t bptr; - tag = lfs3_mtree_traverse(&lfs3, &t, + tag = lfs3_mtree_traverse(&lfs3, &trv, &bptr); assert(tag >= 0 || tag == LFS3_ERR_CORRUPT); if (tag == LFS3_ERR_CORRUPT) { diff --git a/tests/test_powerloss.toml b/tests/test_powerloss.toml index cbe89500..abf15cb0 100644 --- a/tests/test_powerloss.toml +++ b/tests/test_powerloss.toml @@ -8,7 +8,7 @@ after = [ 'test_dirs', 'test_files', 'test_stickynotes', - 'test_traversal', + 'test_trvs', 'test_gc', 'test_mount', 'test_ck', diff --git a/tests/test_traversal.toml b/tests/test_trvs.toml similarity index 88% rename from tests/test_traversal.toml rename to tests/test_trvs.toml index 619955c2..01d34d22 100644 --- a/tests/test_traversal.toml +++ b/tests/test_trvs.toml @@ -8,7 +8,7 @@ after = [ ] # a simple traversal test -[cases.test_traversal_simple] +[cases.test_trvs_simple] defines.MKCONSISTENT = [false, true] defines.LOOKAHEAD = [false, true] defines.COMPACT = [false, true] @@ -20,8 +20,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -29,20 +29,20 @@ code = ''' | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; ''' # can we rewind? -[cases.test_traversal_rewind] +[cases.test_trvs_rewind] defines.MKCONSISTENT = [false, true] defines.LOOKAHEAD = [false, true] defines.COMPACT = [false, true] @@ -54,8 +54,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -63,29 +63,29 @@ code = ''' | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_rewind(&lfs3, &t) => 0; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; ''' # test that we don't get extra anything after end of traversal -[cases.test_traversal_idempotent] +[cases.test_trvs_idempotent] defines.MKCONSISTENT = [false, true] defines.LOOKAHEAD = [false, true] defines.COMPACT = [false, true] @@ -97,8 +97,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -106,22 +106,22 @@ code = ''' | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; ''' @@ -129,7 +129,7 @@ code = ''' # some simple traversal tests with clobbering -[cases.test_traversal_clobber_dirs] +[cases.test_trvs_clobber_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -149,8 +149,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; @@ -159,7 +159,7 @@ code = ''' assert(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; @@ -173,7 +173,7 @@ code = ''' // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; @@ -230,7 +230,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_clobber_files] +[cases.test_trvs_clobber_files] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -271,8 +271,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; @@ -281,7 +281,7 @@ code = ''' assert(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; @@ -296,7 +296,7 @@ code = ''' // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; @@ -346,7 +346,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_clobber_files_opened] +[cases.test_trvs_clobber_files_opened] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -386,8 +386,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; @@ -396,7 +396,7 @@ code = ''' assert(i < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; @@ -411,7 +411,7 @@ code = ''' // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; @@ -483,7 +483,7 @@ code = ''' # a bit more aggressive rewind tests -[cases.test_traversal_rewind_clobber_dirs] +[cases.test_trvs_rewind_clobber_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -503,8 +503,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; @@ -514,7 +514,7 @@ code = ''' assert(i < 2*BLOCK_COUNT); if (i == r) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; memset(seen, 0, (BLOCK_COUNT+7)/8); r += 1; i = -1; @@ -522,7 +522,7 @@ code = ''' } struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; @@ -536,7 +536,7 @@ code = ''' // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; @@ -593,7 +593,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_rewind_clobber_files] +[cases.test_trvs_rewind_clobber_files] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -634,8 +634,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; @@ -645,7 +645,7 @@ code = ''' assert(i < 2*BLOCK_COUNT); if (i == r) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; memset(seen, 0, (BLOCK_COUNT+7)/8); r += 1; i = -1; @@ -653,7 +653,7 @@ code = ''' } struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; @@ -668,7 +668,7 @@ code = ''' // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; @@ -718,7 +718,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_rewind_clobber_files_opened] +[cases.test_trvs_rewind_clobber_files_opened] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -758,8 +758,8 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; @@ -769,7 +769,7 @@ code = ''' assert(i < 2*BLOCK_COUNT); if (i == r) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; memset(seen, 0, (BLOCK_COUNT+7)/8); r += 1; i = -1; @@ -777,7 +777,7 @@ code = ''' } struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; @@ -792,7 +792,7 @@ code = ''' // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; @@ -864,7 +864,7 @@ code = ''' # check that we can detect every clobbered mdir -[cases.test_traversal_ckmdir_dirs] +[cases.test_trvs_ckmdir_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' for (lfs3_block_t i = 0;; i += 2) { @@ -883,17 +883,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -908,7 +908,7 @@ code = ''' CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (k == i+1) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -918,26 +918,26 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; } done:; ''' -[cases.test_traversal_ckmdir_files] +[cases.test_trvs_ckmdir_files] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -979,17 +979,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1004,7 +1004,7 @@ code = ''' CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (k == i+1) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -1014,26 +1014,26 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; } done:; ''' -[cases.test_traversal_ckmdir_files_opened] +[cases.test_trvs_ckmdir_files_opened] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -1074,17 +1074,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_file_close(&lfs3, &files[i]) => 0; } @@ -1102,7 +1102,7 @@ code = ''' CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (k == i+1) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } } @@ -1112,19 +1112,19 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_file_desync(&lfs3, &files[i]) => 0; @@ -1138,7 +1138,7 @@ done:; # check that we can detect every clobbered btree -[cases.test_traversal_ckbtree_dirs] +[cases.test_trvs_ckbtree_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' for (lfs3_block_t i = 0;; i++) { @@ -1157,17 +1157,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1181,7 +1181,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1190,26 +1190,26 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; } done:; ''' -[cases.test_traversal_ckbtree_files] +[cases.test_trvs_ckbtree_files] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -1251,17 +1251,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1275,7 +1275,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1284,26 +1284,26 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; } done:; ''' -[cases.test_traversal_ckbtree_files_opened] +[cases.test_trvs_ckbtree_files_opened] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -1344,17 +1344,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_file_close(&lfs3, &files[i]) => 0; } @@ -1371,7 +1371,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1380,19 +1380,19 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_file_desync(&lfs3, &files[i]) => 0; @@ -1406,7 +1406,7 @@ done:; # check that we can detect every clobbered data block -[cases.test_traversal_ckdata_dirs] +[cases.test_trvs_ckdata_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' for (lfs3_block_t i = 0;; i++) { @@ -1425,17 +1425,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1449,7 +1449,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1458,26 +1458,26 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; } done:; ''' -[cases.test_traversal_ckdata_files] +[cases.test_trvs_ckdata_files] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -1519,17 +1519,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; goto done; } @@ -1543,7 +1543,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1552,26 +1552,26 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; } done:; ''' -[cases.test_traversal_ckdata_files_opened] +[cases.test_trvs_ckdata_files_opened] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -1612,17 +1612,17 @@ code = ''' } // traverse to find blocks - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY) => 0; lfs3_block_t k = 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_file_close(&lfs3, &files[i]) => 0; } @@ -1639,7 +1639,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; goto clobbered; } k += 1; @@ -1648,19 +1648,19 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? if (err == LFS3_ERR_CORRUPT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_file_desync(&lfs3, &files[i]) => 0; @@ -1674,7 +1674,7 @@ done:; # test that in general fsinfo flags work -[cases.test_traversal_flags] +[cases.test_trvs_flags] defines.MKCONSISTENT = [false, true] defines.LOOKAHEAD = [false, true] defines.COMPACT = [false, true] @@ -1696,8 +1696,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -1705,14 +1705,14 @@ code = ''' | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // check flags after lfs3_fs_stat(&lfs3, &fsinfo) => 0; @@ -1728,7 +1728,7 @@ code = ''' ''' # test that we detect filesystem mutation during traversal -[cases.test_traversal_mutation] +[cases.test_trvs_mutation] defines.WHEN = [0, 1, 2] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] @@ -1739,8 +1739,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -1754,7 +1754,7 @@ code = ''' } struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1765,7 +1765,7 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1776,8 +1776,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -1792,7 +1792,7 @@ code = ''' ''' # test that we don't get extra anything after end of traversal -[cases.test_traversal_mutation_idempotent] +[cases.test_trvs_mutation_idempotent] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -1802,14 +1802,14 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1819,17 +1819,17 @@ code = ''' LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; lfs3_file_close(&lfs3, &file) => 0; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -1845,12 +1845,12 @@ code = ''' LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; lfs3_file_close(&lfs3, &file) => 0; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // we should _not_ update lookahead/compact/ckmeta/ckdata lfs3_fs_stat(&lfs3, &fsinfo) => 0; @@ -1860,12 +1860,12 @@ code = ''' | LFS3_I_CKMETA | LFS3_I_CKDATA)); - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mkdir] +[cases.test_trvs_mutation_mkdir] defines.WHEN = [0, 1, 2] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] @@ -1876,8 +1876,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -1888,7 +1888,7 @@ code = ''' } struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1896,7 +1896,7 @@ code = ''' lfs3_mkdir(&lfs3, "spider") => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1904,8 +1904,8 @@ code = ''' lfs3_mkdir(&lfs3, "spider") => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -1919,7 +1919,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_rm] +[cases.test_trvs_mutation_rm] defines.WHEN = [0, 1, 2] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] @@ -1936,8 +1936,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -1948,7 +1948,7 @@ code = ''' } struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1956,7 +1956,7 @@ code = ''' lfs3_remove(&lfs3, "spider") => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -1964,8 +1964,8 @@ code = ''' lfs3_remove(&lfs3, "spider") => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -1979,7 +1979,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mv] +[cases.test_trvs_mutation_mv] defines.WHEN = [0, 1, 2] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] @@ -1996,8 +1996,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2008,7 +2008,7 @@ code = ''' } struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -2016,7 +2016,7 @@ code = ''' lfs3_rename(&lfs3, "spider", "scorpion") => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -2024,8 +2024,8 @@ code = ''' lfs3_rename(&lfs3, "spider", "scorpion") => 0; } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2040,7 +2040,7 @@ code = ''' ''' # some more complex mutation tests -[cases.test_traversal_mutation_fwrite] +[cases.test_trvs_mutation_fwrite] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2071,8 +2071,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2090,14 +2090,14 @@ code = ''' // step traversal struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2118,7 +2118,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_fwrite_opened] +[cases.test_trvs_mutation_fwrite_opened] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2153,8 +2153,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2173,14 +2173,14 @@ code = ''' // step traversal struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2212,7 +2212,7 @@ code = ''' # # these assume quite a bit more and may be a bit fragile... # -[cases.test_traversal_mutation_file_bsprout] +[cases.test_trvs_mutation_file_bsprout] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2246,8 +2246,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2255,10 +2255,10 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -2273,8 +2273,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2300,7 +2300,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_file_btree] +[cases.test_trvs_mutation_file_btree] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2335,8 +2335,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2344,17 +2344,17 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file @@ -2368,16 +2368,16 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2403,7 +2403,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_file_bshrub] +[cases.test_trvs_mutation_file_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2437,8 +2437,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2446,14 +2446,14 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file @@ -2467,13 +2467,13 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2499,7 +2499,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_uncreat_bsprout] +[cases.test_trvs_mutation_uncreat_bsprout] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2533,8 +2533,8 @@ code = ''' lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2542,10 +2542,10 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -2558,8 +2558,8 @@ code = ''' lfs3_file_flush(&lfs3, &file1) => 0; // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2589,7 +2589,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_uncreat_btree] +[cases.test_trvs_mutation_uncreat_btree] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2624,8 +2624,8 @@ code = ''' lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2633,17 +2633,17 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file @@ -2655,16 +2655,16 @@ code = ''' lfs3_file_flush(&lfs3, &file1) => 0; // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2694,7 +2694,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_uncreat_bshrub] +[cases.test_trvs_mutation_uncreat_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2728,8 +2728,8 @@ code = ''' lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2737,14 +2737,14 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file @@ -2756,13 +2756,13 @@ code = ''' lfs3_file_flush(&lfs3, &file1) => 0; // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -2792,7 +2792,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_close_bsprout] +[cases.test_trvs_mutation_close_bsprout] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2827,8 +2827,8 @@ code = ''' lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2836,10 +2836,10 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -2850,8 +2850,8 @@ code = ''' lfs3_file_close(&lfs3, &file1) => 0; // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced struct lfs3_fsinfo fsinfo; @@ -2889,7 +2889,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_close_btree] +[cases.test_trvs_mutation_close_btree] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -2925,8 +2925,8 @@ code = ''' lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -2934,17 +2934,17 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // close the file @@ -2954,16 +2954,16 @@ code = ''' lfs3_file_close(&lfs3, &file1) => 0; // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced struct lfs3_fsinfo fsinfo; @@ -3001,7 +3001,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_close_bshrub] +[cases.test_trvs_mutation_close_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3036,8 +3036,8 @@ code = ''' lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3045,14 +3045,14 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // close the file @@ -3062,13 +3062,13 @@ code = ''' lfs3_file_close(&lfs3, &file1) => 0; // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced struct lfs3_fsinfo fsinfo; @@ -3106,7 +3106,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_rm_bshrub] +[cases.test_trvs_mutation_rm_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3139,8 +3139,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3148,27 +3148,27 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // remove the file lfs3_remove(&lfs3, "spider") => 0; // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced struct lfs3_fsinfo fsinfo; @@ -3195,7 +3195,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mv_src_bshrub] +[cases.test_trvs_mutation_mv_src_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3237,8 +3237,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3246,32 +3246,32 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rename one file over another lfs3_rename(&lfs3, "spider", "tarantula") => 0; // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3299,7 +3299,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mv_dst_bshrub] +[cases.test_trvs_mutation_mv_dst_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3341,8 +3341,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3350,27 +3350,27 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rename one file over another lfs3_rename(&lfs3, "tarantula", "spider") => 0; // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3398,7 +3398,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_split] +[cases.test_trvs_mutation_mroot_split] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3431,8 +3431,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3440,7 +3440,7 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -3456,28 +3456,28 @@ code = ''' } // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3503,7 +3503,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_split_bshrub_l] +[cases.test_trvs_mutation_mroot_split_bshrub_l] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3545,8 +3545,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3554,14 +3554,14 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse a data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mroot to split @@ -3576,26 +3576,26 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3626,7 +3626,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_split_bshrub_r] +[cases.test_trvs_mutation_mroot_split_bshrub_r] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3668,8 +3668,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3677,19 +3677,19 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // and another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mroot to split @@ -3704,16 +3704,16 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3744,7 +3744,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_extend] +[cases.test_trvs_mutation_mroot_extend] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3779,8 +3779,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3788,7 +3788,7 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -3802,23 +3802,23 @@ code = ''' } // traverse mroot - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3844,7 +3844,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_extend_bshrub] +[cases.test_trvs_mutation_mroot_extend_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3879,8 +3879,8 @@ code = ''' lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3888,14 +3888,14 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse a data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to extend @@ -3908,16 +3908,16 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -3943,7 +3943,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_relocate] +[cases.test_trvs_mutation_mroot_relocate] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -3987,8 +3987,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -3996,7 +3996,7 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -4015,23 +4015,23 @@ code = ''' // I wouldn't worry too much about it // // traverse mroot - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -4057,7 +4057,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mroot_relocate_bshrub] +[cases.test_trvs_mutation_mroot_relocate_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -4101,8 +4101,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -4110,18 +4110,18 @@ code = ''' // traverse mroots struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse a data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to relocate @@ -4135,16 +4135,16 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -4170,7 +4170,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_split] +[cases.test_trvs_mutation_mtree_split] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -4243,8 +4243,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -4252,7 +4252,7 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -4269,48 +4269,48 @@ code = ''' } // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -4346,7 +4346,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_split_bshrub_l] +[cases.test_trvs_mutation_mtree_split_bshrub_l] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -4419,8 +4419,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -4428,32 +4428,32 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mdir to split again @@ -4469,31 +4469,31 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -4529,7 +4529,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_split_bshrub_r] +[cases.test_trvs_mutation_mtree_split_bshrub_r] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -4602,8 +4602,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -4611,37 +4611,37 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mdir to split again @@ -4656,21 +4656,21 @@ code = ''' i += 1; } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -4706,7 +4706,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_extend] +[cases.test_trvs_mutation_mtree_extend] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -4785,8 +4785,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -4794,7 +4794,7 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -4808,43 +4808,43 @@ code = ''' } // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -4880,7 +4880,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_extend_bshrub] +[cases.test_trvs_mutation_mtree_extend_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -4959,8 +4959,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -4968,32 +4968,32 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to extend @@ -5006,26 +5006,26 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -5061,7 +5061,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_relocate] +[cases.test_trvs_mutation_mtree_relocate] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -5145,8 +5145,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -5154,7 +5154,7 @@ code = ''' // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -5169,43 +5169,43 @@ code = ''' } // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -5241,7 +5241,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mutation_mtree_relocate_bshrub] +[cases.test_trvs_mutation_mtree_relocate_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -5325,8 +5325,8 @@ code = ''' } // try traversing - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) | ((CKMETA) ? LFS3_T_CKMETA : 0) @@ -5334,36 +5334,36 @@ code = ''' // traverse mroots struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse one data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to relocate @@ -5377,26 +5377,26 @@ code = ''' } // traverse another data block - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata struct lfs3_fsinfo fsinfo; @@ -5435,7 +5435,7 @@ code = ''' # test traversals with mdir compaction -[cases.test_traversal_compact] +[cases.test_trvs_compact] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -5475,8 +5475,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing and compacting - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -5484,13 +5484,13 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // mdir should have been compacted assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -5504,15 +5504,15 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mdir should have been compacted assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -5545,7 +5545,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_compact_mrootchain] +[cases.test_trvs_compact_mrootchain] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -5606,8 +5606,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing and compacting - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -5615,18 +5615,18 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mrootanchor struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mroot - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // mrootanchor should have been compacted lfs3_mdir_t mrootanchor; @@ -5643,15 +5643,15 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mrootanchor should have been compacted lfs3_mdir_fetch(&lfs3, &mrootanchor, @@ -5686,7 +5686,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_compact_mroot_extend] +[cases.test_trvs_compact_mroot_extend] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -5729,8 +5729,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing and compacting - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -5742,11 +5742,11 @@ code = ''' // // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // mdir should have been compacted assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -5760,15 +5760,15 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mdir should have been compacted assert((file.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -5801,7 +5801,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_compact_mroot_split] +[cases.test_trvs_compact_mroot_split] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -5871,8 +5871,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing and compacting - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -5880,26 +5880,26 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // should have split, traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // mdirs should have been compacted assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -5914,15 +5914,15 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mdirs should have been compacted assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -5963,7 +5963,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_compact_mtree] +[cases.test_trvs_compact_mtree] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -6080,8 +6080,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing and compacting - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -6089,31 +6089,31 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; if (COMPACTSET) { // mdirs should have been compacted @@ -6130,16 +6130,16 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mdirs should have been compacted assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -6188,7 +6188,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_compact_mtree_split] +[cases.test_trvs_compact_mtree_split] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -6303,8 +6303,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing and compacting - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_COMPACT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -6312,36 +6312,36 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // should have split, traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // mdirs should have been compacted assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -6358,15 +6358,15 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mdirs should have been compacted assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -6429,7 +6429,7 @@ code = ''' # test traversals with mkconsistent -[cases.test_traversal_mkconsistent] +[cases.test_trvs_mkconsistent] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -6497,8 +6497,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -6506,28 +6506,28 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS > 3) { // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should have cleaned up all grms/orphans assert(lfs3.grm.queue[0] == 0); @@ -6575,7 +6575,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_conflict] +[cases.test_trvs_mkconsistent_conflict] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -6621,8 +6621,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -6630,7 +6630,7 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -6658,22 +6658,22 @@ code = ''' // keep traversing if (ORPHANS <= 3) { // traverse mroot - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); } else { // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should be able to clean up grms assert(lfs3.grm.queue[0] == 0); @@ -6720,7 +6720,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_btree] +[cases.test_trvs_mkconsistent_btree] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -6792,8 +6792,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -6801,42 +6801,42 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should have cleaned up all grms/orphans assert(lfs3.grm.queue[0] == 0); @@ -6884,7 +6884,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_btree_uncreat] +[cases.test_trvs_mkconsistent_btree_uncreat] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -6956,8 +6956,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -6965,42 +6965,42 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should have cleaned up all grms/orphans assert(lfs3.grm.queue[0] == 0); @@ -7048,7 +7048,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_bshrub] +[cases.test_trvs_mkconsistent_bshrub] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -7121,8 +7121,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -7130,50 +7130,50 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should have cleaned up all grms/orphans assert(lfs3.grm.queue[0] == 0); @@ -7221,7 +7221,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_bshrub_uncreat] +[cases.test_trvs_mkconsistent_bshrub_uncreat] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -7294,8 +7294,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -7303,50 +7303,50 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should have cleaned up all grms/orphans assert(lfs3.grm.queue[0] == 0); @@ -7394,7 +7394,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_compact] +[cases.test_trvs_mkconsistent_compact] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -7485,8 +7485,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | LFS3_T_COMPACT @@ -7495,27 +7495,27 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS > 3) { // traverse mtree - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; // we should have cleaned up all grms/orphans assert(lfs3.grm.queue[0] == 0); @@ -7541,15 +7541,15 @@ code = ''' | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; while (true) { - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); if (err == LFS3_ERR_NOENT) { break; } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // mdirs should have been compacted assert((file1.b.h.mdir.r.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -7590,7 +7590,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_mkconsistent_compact_conflict] +[cases.test_trvs_mkconsistent_compact_conflict] defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] @@ -7659,8 +7659,8 @@ code = ''' | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | LFS3_T_MKCONSISTENT | LFS3_T_COMPACT @@ -7669,7 +7669,7 @@ code = ''' | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot struct lfs3_tinfo tinfo; - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); @@ -7697,22 +7697,22 @@ code = ''' // keep traversing if (ORPHANS <= 3) { // traverse mroot - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); } else { // traverse mdirs - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); - lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => 0; assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_read(&lfs3, &trv, &tinfo) => LFS3_ERR_NOENT; + lfs3_trv_close(&lfs3, &trv) => 0; // we should be able to clean up grms assert(lfs3.grm.queue[0] == 0); @@ -7772,7 +7772,7 @@ code = ''' # these should hopefully test a bunch of messy traversal state # -[cases.test_traversal_spam_dir_many] +[cases.test_trvs_spam_dir_many] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -7790,8 +7790,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -7809,16 +7809,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - err = lfs3_traversal_read(&lfs3, &t, &tinfo); + err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (int remount = 0; remount < 2; remount++) { // remount? @@ -7883,7 +7883,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_spam_dir_fuzz] +[cases.test_trvs_spam_dir_fuzz] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -7908,8 +7908,8 @@ code = ''' lfs3_size_t sim_size = 0; // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -8003,16 +8003,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (int remount = 0; remount < 2; remount++) { // remount? @@ -8065,7 +8065,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_spam_file_many] +[cases.test_trvs_spam_file_many] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -8093,8 +8093,8 @@ code = ''' lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -8122,16 +8122,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (int remount = 0; remount < 2; remount++) { // remount? @@ -8170,7 +8170,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_spam_file_fuzz] +[cases.test_trvs_spam_file_fuzz] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -8206,8 +8206,8 @@ code = ''' lfs3_size_t sim_size = 0; // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -8337,16 +8337,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; for (int remount = 0; remount < 2; remount++) { // remount? @@ -8414,7 +8414,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_spam_fwrite_fuzz] +[cases.test_trvs_spam_fwrite_fuzz] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -8482,8 +8482,8 @@ code = ''' } // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -8517,16 +8517,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; lfs3_file_close(&lfs3, &file) => 0; @@ -8578,7 +8578,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_spam_uz_fuzz] +[cases.test_trvs_spam_uz_fuzz] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -8625,8 +8625,8 @@ code = ''' lfs3_size_t sim_file_count = 0; // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -8927,16 +8927,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // check that disk matches our simulation for (lfs3_size_t j = 0; j < sim_size; j++) { @@ -9029,7 +9029,7 @@ code = ''' lfs3_unmount(&lfs3) => 0; ''' -[cases.test_traversal_spam_uzd_fuzz] +[cases.test_trvs_spam_uzd_fuzz] # traverse steps between each op defines.STEPS = [1, 2, 4, 8, 16, 32, 64, 128] defines.MKCONSISTENT = [false, true] @@ -9077,8 +9077,8 @@ code = ''' lfs3_size_t sim_file_count = 0; // open a traversal - lfs3_traversal_t t; - lfs3_traversal_open(&lfs3, &t, + lfs3_trv_t trv; + lfs3_trv_open(&lfs3, &trv, LFS3_T_RDWR | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) @@ -9458,16 +9458,16 @@ code = ''' // step the traversal for (lfs3_size_t s = 0; s < STEPS; s++) { struct lfs3_tinfo tinfo; - int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + int err = lfs3_trv_read(&lfs3, &trv, &tinfo); assert(!err || err == LFS3_ERR_NOENT); // restart traversal if (err == LFS3_ERR_NOENT) { - lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_trv_rewind(&lfs3, &trv) => 0; } } } - lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_trv_close(&lfs3, &trv) => 0; // check that disk matches our simulation for (lfs3_size_t j = 0; j < sim_size; j++) {