From 8f1ccf089e2ba35daf276b39e34767eaf25d116c Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Thu, 17 Apr 2025 16:53:20 -0500 Subject: [PATCH] Adopted lookupleaf, reworked internal btree APIs This was a surprising side-effect the script rework: Realizing the internal btree/rbyd lookup APIs were awkwardly inconsistent and could be improved with a couple tweaks: - Adopted lookupleaf name for functions that return leaf rbyds/mdirs. There's an argument this should be called lookupnextleaf, since it returns the next bid, unlike lookup, but I'm going to ignore that argument because: 1. A non-next lookupleaf doesn't really make sense for trees where you don't have to fetch the leaf (the mtree) 2. It would be a bit too verbose - Adopted commitleaf name for functions that accept leaf rbyds. This makes the lfsr_bshrub_commit -> lfsr_btree_commit__ mess a bit more readable. - Strictly limited lookup and lookupnext to return rattrs, even in complex trees like the mtree. Most use cases will probably stick to the lookupleaf variants, but at least the behavior will be consistent. - Strictly limited lookup to expect a known bid/rid. This only really matters for lfsr_btree/bshrub_lookup, which as a quirk of their implementation _can_ lookup both bid + rattr at the same time. But I don't think we'll need this functionality, and limited the behavior may allow for future optimizations. Note there is no lfsr_file_lookup. File btrees currently only ever have a single leaf rattr, so this API doesn't really make sense. Internal API changes: - lfsr_btree_lookupnext_ -> lfsr_btree_lookupleaf - lfsr_btree_lookupnext -> lfsr_btree_lookupnext - lfsr_btree_lookup -> lfsr_btree_lookup - added lfsr_btree_namelookupleaf - lfsr_btree_namelookup -> lfsr_btree_namelookup - lfsr_btree_commit__ -> lfsr_btree_commit_ - lfsr_btree_commit_ -> lfsr_btree_commitleaf - lfsr_btree_commit -> lfsr_btree_commit - added lfsr_bshrub_lookupleaf - lfsr_bshrub_lookupnext -> lfsr_bshrub_lookupnext - lfsr_bshrub_lookup -> lfsr_bshrub_lookup - lfsr_bshrub_commit_ -> lfsr_bshrub_commitleaf - lfsr_bshrub_commit -> lfsr_bshrub_commit - lfsr_mtree_lookup -> lfsr_mtree_lookupleaf - added lfsr_mtree_lookupnext - added lfsr_mtree_lookup - added lfsr_mtree_namelookupleaf - lfsr_mtree_namelookup -> lfsr_mtree_namelookup - added lfsr_file_lookupleaf - lfsr_file_lookupnext -> lfsr_file_lookupnext - added lfsr_file_commitleaf - lfsr_file_commit -> lfsr_file_commit Also added lookupnext to Mdir/Mtree in the dbg scripts. Unfortunately this did add both code and stack, but only because of the optional mdir returns in the mtree lookups: code stack ctx before: 35520 2440 636 after: 35548 (+0.1%) 2472 (+1.3%) 636 (+0.0%) --- lfs.c | 228 +++++++++++++---- scripts/dbgbmap.py | 72 +++++- scripts/dbgbmapd3.py | 72 +++++- scripts/dbglfs.py | 72 +++++- scripts/dbgmtree.py | 72 +++++- tests/test_badblocks.toml | 30 ++- tests/test_btree.toml | 527 ++++++++++++++++++++------------------ tests/test_forphans.toml | 8 +- tests/test_mtree.toml | 206 +++++++-------- 9 files changed, 836 insertions(+), 451 deletions(-) diff --git a/lfs.c b/lfs.c index 039b1e4b..84c64406 100644 --- a/lfs.c +++ b/lfs.c @@ -3197,6 +3197,9 @@ static int lfsr_rbyd_fetchck(lfs_t *lfs, lfsr_rbyd_t *rbyd, } +// our core rbyd lookup algorithm +// +// finds the next rid+tag such that rid_+tag_ >= rid+tag static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfsr_srid_t rid, lfsr_tag_t tag, lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_rid_t *weight_, @@ -3308,6 +3311,8 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } } + +// finds the next rid+tag such that rid_+tag_ >= rid+tag static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfsr_srid_t rid, lfsr_tag_t tag, lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_rid_t *weight_, @@ -3317,6 +3322,7 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, NULL, NULL); } +// lookup assumes a known rid static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfsr_srid_t rid, lfsr_tag_t tag, lfsr_data_t *data_) { @@ -3464,6 +3470,7 @@ static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree, static lfsr_data_t lfsr_data_frommptr(const lfs_block_t mptr[static 2], uint8_t buffer[static LFSR_MPTR_DSIZE]); +// our core rbyd append algorithm static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_rattr_t rattr) { // tag must not be internal at this point @@ -5256,7 +5263,8 @@ static int lfsr_data_fetchbtree(lfs_t *lfs, lfsr_data_t *data, btree->cksum); } -static int lfsr_btree_lookupnext_(lfs_t *lfs, const lfsr_btree_t *btree, +// lookup rbyd/rid containing a given bid +static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree, lfsr_bid_t bid, lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { @@ -5322,20 +5330,28 @@ static int lfsr_btree_lookupnext_(lfs_t *lfs, const lfsr_btree_t *btree, } } +// non-leaf lookups discard the rbyd info, which can be a bit more +// convenient, but may make commits more costly static int lfsr_btree_lookupnext(lfs_t *lfs, const lfsr_btree_t *btree, lfsr_bid_t bid, lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { - return lfsr_btree_lookupnext_(lfs, btree, bid, + return lfsr_btree_lookupleaf(lfs, btree, bid, bid_, NULL, NULL, tag_, weight_, data_); } +// lfsr_btree_lookup assumes a known bid, matching lfsr_rbyd_lookup's +// behavior, if you don't care about the exact bid either first call +// lfsr_btree_lookupnext, or lfsr_btree_lookupleaf + lfsr_rbyd_lookup static int lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree, - lfsr_bid_t bid, - lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { + lfsr_bid_t bid, lfsr_tag_t tag, + lfsr_data_t *data_) { + // lookup rbyd in btree lfsr_bid_t bid_; - int err = lfsr_btree_lookupnext(lfs, btree, bid, - &bid_, tag_, weight_, data_); + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; + int err = lfsr_btree_lookupleaf(lfs, btree, bid, + &bid_, &rbyd_, &rid_, NULL, NULL, NULL); if (err) { return err; } @@ -5346,7 +5362,9 @@ static int lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree, return LFS_ERR_NOENT; } - return 0; + // lookup tag in rbyd + return lfsr_rbyd_lookup(lfs, &rbyd_, rid_, tag, + data_); } // TODO should lfsr_btree_lookupnext/lfsr_btree_parent be deduplicated? @@ -5421,7 +5439,7 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, } -// extra state needed for non-terminating lfsr_btree_commit__ calls +// extra state needed for non-terminating lfsr_btree_commit_ calls typedef struct lfsr_bctx { lfsr_rattr_t rattrs[4]; lfsr_data_t split_name; @@ -5434,7 +5452,7 @@ typedef struct lfsr_bctx { // 1. we need a new root // 2. we have a shrub root // -static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, +static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bctx_t *bctx, lfsr_bid_t *bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, const lfsr_rattr_t **rattrs, lfs_size_t *rattr_count) { @@ -5445,7 +5463,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // if rbyd is NULL, lookup which leaf our bid resides // - // for lfsr_btree_commit operations to work out, we need to + // for lfsr_btree_commit_ operations to work out, we need to // limit our bid to an rid in the tree, which is what this min // is doing lfsr_rbyd_t rbyd_; @@ -5455,7 +5473,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, rid_ = bid_; if (btree->weight > 0) { lfsr_srid_t rid__; - int err = lfsr_btree_lookupnext_(lfs, btree, + int err = lfsr_btree_lookupleaf(lfs, btree, lfs_min(bid_, btree->weight-1), &bid_, &rbyd_, &rid__, NULL, NULL, NULL); if (err) { @@ -5986,13 +6004,13 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, } } -// commit to btree with optional rbyd -static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, +// commit to specific leaf rbyd in a btree +static int lfsr_btree_commitleaf(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // try to commit to the btree lfsr_bctx_t bctx; - int err = lfsr_btree_commit__(lfs, btree, &bctx, + int err = lfsr_btree_commit_(lfs, btree, &bctx, &bid, rbyd, rid, &rattrs, &rattr_count); if (err && err != LFS_ERR_RANGE) { return err; @@ -6036,14 +6054,15 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // commit to a btree, this is atomic static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { - return lfsr_btree_commit_(lfs, btree, bid, NULL, -1, + return lfsr_btree_commitleaf(lfs, btree, bid, NULL, -1, rattrs, rattr_count); } // lookup in a btree by name -static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree, +static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs, + const lfsr_btree_t *btree, lfsr_did_t did, const char *name, lfs_size_t name_len, - lfsr_bid_t *bid_, + lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { // an empty tree? if (btree->weight == 0) { @@ -6093,6 +6112,12 @@ static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree, if (bid_) { *bid_ = bid + rid__; } + if (rbyd_) { + *rbyd_ = branch; + } + if (rid_) { + *rid_ = rid__; + } if (tag_) { *tag_ = tag__; } @@ -6107,6 +6132,16 @@ static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree, } } +static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, + const lfsr_btree_t *btree, + lfsr_did_t did, const char *name, lfs_size_t name_len, + lfsr_bid_t *bid_, + lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { + return lfsr_btree_namelookupleaf(lfs, btree, + did, name, name_len, + bid_, NULL, NULL, tag_, weight_, data_); +} + // incremental btree traversal // // note this is different from iteration, iteration should use @@ -6478,6 +6513,15 @@ static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs, return estimate; } +// bshrub lookup functions +static int lfsr_bshrub_lookupleaf(lfs_t *lfs, const lfsr_bshrub_t *bshrub, + lfsr_bid_t bid, + lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_, + lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { + return lfsr_btree_lookupleaf(lfs, &bshrub->shrub, bid, + bid_, rbyd_, rid_, tag_, weight_, data_); +} + static int lfsr_bshrub_lookupnext(lfs_t *lfs, const lfsr_bshrub_t *bshrub, lfsr_bid_t bid, lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bid_t *weight_, @@ -6487,10 +6531,10 @@ static int lfsr_bshrub_lookupnext(lfs_t *lfs, const lfsr_bshrub_t *bshrub, } static int lfsr_bshrub_lookup(lfs_t *lfs, const lfsr_bshrub_t *bshrub, - lfsr_bid_t bid, - lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { - return lfsr_btree_lookup(lfs, &bshrub->shrub, bid, - tag_, weight_, data_); + lfsr_bid_t bid, lfsr_tag_t tag, + lfsr_data_t *data_) { + return lfsr_btree_lookup(lfs, &bshrub->shrub, bid, tag, + data_); } static int lfsr_bshrub_traverse(lfs_t *lfs, const lfsr_bshrub_t *bshrub, @@ -6500,12 +6544,12 @@ static int lfsr_bshrub_traverse(lfs_t *lfs, const lfsr_bshrub_t *bshrub, bid_, tag_, data_); } -// needed in lfsr_bshrub_commit_ +// needed in lfsr_bshrub_commitleaf static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count); // commit to bshrub with optional rbyd -static int lfsr_bshrub_commit_(lfs_t *lfs, lfsr_bshrub_t *bshrub, +static int lfsr_bshrub_commitleaf(lfs_t *lfs, lfsr_bshrub_t *bshrub, lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // before we touch anything, we need to mark all other btree references @@ -6523,7 +6567,7 @@ static int lfsr_bshrub_commit_(lfs_t *lfs, lfsr_bshrub_t *bshrub, // try to commit to the btree lfsr_bctx_t bctx; - int err = lfsr_btree_commit__(lfs, &bshrub->shrub, &bctx, + int err = lfsr_btree_commit_(lfs, &bshrub->shrub, &bctx, &bid, rbyd, rid, &rattrs, &rattr_count); if (err && err != LFS_ERR_RANGE) { return err; @@ -6531,7 +6575,7 @@ static int lfsr_bshrub_commit_(lfs_t *lfs, lfsr_bshrub_t *bshrub, LFS_ASSERT(!err || rattr_count > 0); bool alloc = (err == LFS_ERR_RANGE); - // when btree is shrubbed, lfsr_btree_commit__ stops at the root + // when btree is shrubbed, lfsr_btree_commit_ stops at the root // and returns with pending rattrs if (rattr_count > 0) { // we need to prevent our shrub from overflowing our mdir somehow @@ -6667,7 +6711,7 @@ relocate:; // commit to a bshrub, this is atomic static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub, lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { - return lfsr_bshrub_commit_(lfs, bshrub, bid, NULL, -1, + return lfsr_bshrub_commitleaf(lfs, bshrub, bid, NULL, -1, rattrs, rattr_count); } @@ -7444,7 +7488,8 @@ static inline lfsr_mid_t lfsr_mtree_weight(lfs_t *lfs) { 1 << lfs->mbits); } -static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, +// lookup mdir containing a given mid +static int lfsr_mtree_lookupleaf(lfs_t *lfs, lfsr_smid_t mid, lfsr_mdir_t *mdir_) { // looking up mid=-1 is probably a mistake LFS_ASSERT(mid >= 0); @@ -7455,10 +7500,11 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, } // looking up mroot? + lfsr_mdir_t mdir; if (lfs->mtree.weight == 0) { - mdir_->mid = mid; - lfsr_mdir_sync(mdir_, &lfs->mroot); - return 0; + // treat inlined mdir as mid=0 + mdir.mid = mid; + lfsr_mdir_sync(&mdir, &lfs->mroot); // look up mdir in actual mtree } else { @@ -7475,9 +7521,60 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, LFS_ASSERT(tag == LFSR_TAG_MDIR); // fetch mdir - return lfsr_data_fetchmdir(lfs, &data, mid, - mdir_); + err = lfsr_data_fetchmdir(lfs, &data, mid, + &mdir); + if (err) { + return err; + } } + + if (mdir_) { + *mdir_ = mdir; + } + return 0; +} + +// in-mdir lookups for convenience/possible code sharing +static int lfsr_mtree_lookupnext(lfs_t *lfs, lfsr_smid_t mid, lfsr_tag_t tag, + lfsr_mdir_t *mdir_, lfsr_tag_t *tag_, lfsr_data_t *data_) { + lfsr_mdir_t mdir; + int err = lfsr_mtree_lookupleaf(lfs, mid, + &mdir); + if (err) { + return err; + } + + err = lfsr_mdir_lookupnext(lfs, &mdir, tag, + tag_, data_); + if (err) { + return err; + } + + if (mdir_) { + *mdir_ = mdir; + } + return 0; +} + +static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_tag_t tag, + lfsr_mdir_t *mdir_, lfsr_data_t *data_) { + lfsr_mdir_t mdir; + int err = lfsr_mtree_lookupleaf(lfs, mid, + &mdir); + if (err) { + return err; + } + + err = lfsr_mdir_lookup(lfs, &mdir, tag, + data_); + if (err) { + return err; + } + + if (mdir_) { + *mdir_ = mdir; + } + return 0; } @@ -8921,15 +9018,15 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, // lookup names in our mtree // // if not found, rid will be the best place to insert -static int lfsr_mtree_namelookup(lfs_t *lfs, +static int lfsr_mtree_namelookupleaf(lfs_t *lfs, lfsr_did_t did, const char *name, lfs_size_t name_len, - lfsr_mdir_t *mdir_, lfsr_tag_t *tag_, lfsr_data_t *data_) { + lfsr_mdir_t *mdir_) { // do we only have mroot? lfsr_mdir_t mdir; if (lfs->mtree.weight == 0) { - mdir = lfs->mroot; // treat inlined mdir as mid=0 mdir.mid = 0; + lfsr_mdir_sync(&mdir, &lfs->mroot); // lookup name in actual mtree } else { @@ -8955,9 +9052,27 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, } } - // and finally lookup name in our mdir + if (mdir_) { + *mdir_ = mdir; + } + return 0; +} + +static int lfsr_mtree_namelookup(lfs_t *lfs, + lfsr_did_t did, const char *name, lfs_size_t name_len, + lfsr_mdir_t *mdir_, lfsr_tag_t *tag_, lfsr_data_t *data_) { + // lookup name in our mtree + lfsr_mdir_t mdir; + int err = lfsr_mtree_namelookupleaf(lfs, + did, name, name_len, + &mdir); + if (err) { + return err; + } + + // and lookup name in our mdir lfsr_smid_t mid; - int err = lfsr_mdir_namelookup(lfs, &mdir, + err = lfsr_mdir_namelookup(lfs, &mdir, did, name, name_len, &mid, tag_, data_); if (err && err != LFS_ERR_NOENT) { @@ -8966,10 +9081,10 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, // update mdir with best place to insert even if we fail mdir.mid = mid; + if (mdir_) { *mdir_ = mdir; } - return err; } @@ -9286,7 +9401,7 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, // iterate over mdirs in the mtree case LFSR_TSTATE_MDIRS:; // find the next mdir - err = lfsr_mtree_lookup(lfs, t->b.o.mdir.mid, + err = lfsr_mtree_lookupleaf(lfs, t->b.o.mdir.mid, &t->b.o.mdir); if (err) { // end of mtree? guess we're done @@ -10120,7 +10235,7 @@ static int lfsr_grm_pushdid(lfs_t *lfs, lfsr_did_t did) { bookmark_mdir.mid += 1; if (lfsr_mrid(lfs, bookmark_mdir.mid) >= (lfsr_srid_t)bookmark_mdir.rbyd.weight) { - err = lfsr_mtree_lookup(lfs, + err = lfsr_mtree_lookupleaf(lfs, lfsr_mbid(lfs, bookmark_mdir.mid-1) + 1, &bookmark_mdir); if (err) { @@ -10624,7 +10739,7 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) { // next mdir? if (lfsr_mrid(lfs, dir->o.mdir.mid) >= (lfsr_srid_t)dir->o.mdir.rbyd.weight) { - int err = lfsr_mtree_lookup(lfs, + int err = lfsr_mtree_lookupleaf(lfs, lfsr_mbid(lfs, dir->o.mdir.mid-1) + 1, &dir->o.mdir); if (err) { @@ -10696,7 +10811,7 @@ int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off) { // next mdir? if (lfsr_mrid(lfs, dir->o.mdir.mid) >= (lfsr_srid_t)dir->o.mdir.rbyd.weight) { - int err = lfsr_mtree_lookup(lfs, + int err = lfsr_mtree_lookupleaf(lfs, lfsr_mbid(lfs, dir->o.mdir.mid-1) + 1, &dir->o.mdir); if (err) { @@ -11269,13 +11384,14 @@ int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file) { // low-level file reading -static int lfsr_file_lookupnext(lfs_t *lfs, const lfsr_file_t *file, +static int lfsr_file_lookupleaf(lfs_t *lfs, const lfsr_file_t *file, lfsr_bid_t bid, - lfsr_bid_t *bid_, lfsr_bid_t *weight_, lfsr_bptr_t *bptr_) { + lfsr_bid_t *bid_, lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_, + lfsr_bid_t *weight_, lfsr_bptr_t *bptr_) { lfsr_tag_t tag; lfsr_data_t data; - int err = lfsr_bshrub_lookupnext(lfs, &file->b, bid, - bid_, &tag, weight_, &data); + int err = lfsr_bshrub_lookupleaf(lfs, &file->b, bid, + bid_, rbyd_, rid_, &tag, weight_, &data); if (err) { return err; } @@ -11296,6 +11412,13 @@ static int lfsr_file_lookupnext(lfs_t *lfs, const lfsr_file_t *file, return 0; } +static int lfsr_file_lookupnext(lfs_t *lfs, const lfsr_file_t *file, + lfsr_bid_t bid, + lfsr_bid_t *bid_, lfsr_bid_t *weight_, lfsr_bptr_t *bptr_) { + return lfsr_file_lookupleaf(lfs, file, bid, + bid_, NULL, NULL, weight_, bptr_); +} + static lfs_ssize_t lfsr_file_readnext(lfs_t *lfs, const lfsr_file_t *file, lfs_off_t pos, uint8_t *buffer, lfs_size_t size) { lfs_off_t pos_ = pos; @@ -11449,10 +11572,17 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, // low-level file writing +static int lfsr_file_commitleaf(lfs_t *lfs, lfsr_file_t *file, + lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { + return lfsr_bshrub_commitleaf(lfs, &file->b, + bid, rbyd, rid, rattrs, rattr_count); +} + static int lfsr_file_commit(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { + lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { return lfsr_bshrub_commit(lfs, &file->b, - pos, rattrs, rattr_count); + bid, rattrs, rattr_count); } static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, @@ -14102,7 +14232,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { // find our mdir lfsr_mdir_t mdir; - int err = lfsr_mtree_lookup(lfs, lfs->grm.mids[0], + int err = lfsr_mtree_lookupleaf(lfs, lfs->grm.mids[0], &mdir); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); diff --git a/scripts/dbgbmap.py b/scripts/dbgbmap.py index 0782394e..dd2f1689 100755 --- a/scripts/dbgbmap.py +++ b/scripts/dbgbmap.py @@ -1554,6 +1554,30 @@ class Mdir: rbyd = Rbyd.fetch(bd, blocks, trunk) return cls(mid, rbyd, mbits=Mtree.mbits_(bd)) + def lookupnext(self, mid, tag=None, *, + path=False): + # this is similar to rbyd lookupnext, we just error if + # lookupnext changes mids + if not isinstance(mid, Mid): + mid = Mid(mid, mbits=self.mbits) + r = self.rbyd.lookupnext(mid.mrid, tag, + path=path) + if path: + rid, rattr, path_ = r + else: + rid, rattr = r + + if rid != mid.mrid: + if path: + return None, path_ + else: + return None + + if path: + return rattr, path_ + else: + return rattr + def lookup(self, mid, tag=None, mask=None, *, path=False): if not isinstance(mid, Mid): @@ -1854,6 +1878,40 @@ class Mtree: else: return mdir + def lookupnext(self, mid, *, + path=False, + depth=None): + if not isinstance(mid, Mid): + mid = self.mid(mid) + + # lookup the relevant mdir + r = self.lookupleaf(mid, + path=path, + depth=depth) + if path: + mdir, path_ = r + else: + mdir = r + if mdir is None: + if path: + return None, None, path_ + else: + return None, None + + # not in mdir? + if mid.mrid >= mdir.weight: + if path: + return None, None, path_ + else: + return None, None + + # lookup mid in mdir + rattr = mdir.lookupnext(mid) + if path: + return mdir, rattr, path_+[(mid, mdir, rattr)] + else: + return mdir, rattr + def lookup(self, mid, *, path=False, depth=None): @@ -1881,18 +1939,12 @@ class Mtree: else: return None, None - # lookup name in mdir - name = mdir.lookup(mid) - # name tag missing? weird - if name is None: - if path: - return None, None, path_ - else: - return None, None + # lookup mid in mdir + rattr = mdir.lookup(mid) if path: - return mdir, name, path_+[(mid, mdir, name)] + return mdir, rattr, path_+[(mid, mdir, rattr)] else: - return mdir, name + return mdir, rattr # iterate over all mdirs, this includes the mrootchain def _leaves(self, *, diff --git a/scripts/dbgbmapd3.py b/scripts/dbgbmapd3.py index 04a92be5..a5d47115 100755 --- a/scripts/dbgbmapd3.py +++ b/scripts/dbgbmapd3.py @@ -1584,6 +1584,30 @@ class Mdir: rbyd = Rbyd.fetch(bd, blocks, trunk) return cls(mid, rbyd, mbits=Mtree.mbits_(bd)) + def lookupnext(self, mid, tag=None, *, + path=False): + # this is similar to rbyd lookupnext, we just error if + # lookupnext changes mids + if not isinstance(mid, Mid): + mid = Mid(mid, mbits=self.mbits) + r = self.rbyd.lookupnext(mid.mrid, tag, + path=path) + if path: + rid, rattr, path_ = r + else: + rid, rattr = r + + if rid != mid.mrid: + if path: + return None, path_ + else: + return None + + if path: + return rattr, path_ + else: + return rattr + def lookup(self, mid, tag=None, mask=None, *, path=False): if not isinstance(mid, Mid): @@ -1884,6 +1908,40 @@ class Mtree: else: return mdir + def lookupnext(self, mid, *, + path=False, + depth=None): + if not isinstance(mid, Mid): + mid = self.mid(mid) + + # lookup the relevant mdir + r = self.lookupleaf(mid, + path=path, + depth=depth) + if path: + mdir, path_ = r + else: + mdir = r + if mdir is None: + if path: + return None, None, path_ + else: + return None, None + + # not in mdir? + if mid.mrid >= mdir.weight: + if path: + return None, None, path_ + else: + return None, None + + # lookup mid in mdir + rattr = mdir.lookupnext(mid) + if path: + return mdir, rattr, path_+[(mid, mdir, rattr)] + else: + return mdir, rattr + def lookup(self, mid, *, path=False, depth=None): @@ -1911,18 +1969,12 @@ class Mtree: else: return None, None - # lookup name in mdir - name = mdir.lookup(mid) - # name tag missing? weird - if name is None: - if path: - return None, None, path_ - else: - return None, None + # lookup mid in mdir + rattr = mdir.lookup(mid) if path: - return mdir, name, path_+[(mid, mdir, name)] + return mdir, rattr, path_+[(mid, mdir, rattr)] else: - return mdir, name + return mdir, rattr # iterate over all mdirs, this includes the mrootchain def _leaves(self, *, diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py index d9d76d26..211e12d4 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs.py @@ -1511,6 +1511,30 @@ class Mdir: rbyd = Rbyd.fetch(bd, blocks, trunk) return cls(mid, rbyd, mbits=Mtree.mbits_(bd)) + def lookupnext(self, mid, tag=None, *, + path=False): + # this is similar to rbyd lookupnext, we just error if + # lookupnext changes mids + if not isinstance(mid, Mid): + mid = Mid(mid, mbits=self.mbits) + r = self.rbyd.lookupnext(mid.mrid, tag, + path=path) + if path: + rid, rattr, path_ = r + else: + rid, rattr = r + + if rid != mid.mrid: + if path: + return None, path_ + else: + return None + + if path: + return rattr, path_ + else: + return rattr + def lookup(self, mid, tag=None, mask=None, *, path=False): if not isinstance(mid, Mid): @@ -1811,6 +1835,40 @@ class Mtree: else: return mdir + def lookupnext(self, mid, *, + path=False, + depth=None): + if not isinstance(mid, Mid): + mid = self.mid(mid) + + # lookup the relevant mdir + r = self.lookupleaf(mid, + path=path, + depth=depth) + if path: + mdir, path_ = r + else: + mdir = r + if mdir is None: + if path: + return None, None, path_ + else: + return None, None + + # not in mdir? + if mid.mrid >= mdir.weight: + if path: + return None, None, path_ + else: + return None, None + + # lookup mid in mdir + rattr = mdir.lookupnext(mid) + if path: + return mdir, rattr, path_+[(mid, mdir, rattr)] + else: + return mdir, rattr + def lookup(self, mid, *, path=False, depth=None): @@ -1838,18 +1896,12 @@ class Mtree: else: return None, None - # lookup name in mdir - name = mdir.lookup(mid) - # name tag missing? weird - if name is None: - if path: - return None, None, path_ - else: - return None, None + # lookup mid in mdir + rattr = mdir.lookup(mid) if path: - return mdir, name, path_+[(mid, mdir, name)] + return mdir, rattr, path_+[(mid, mdir, rattr)] else: - return mdir, name + return mdir, rattr # iterate over all mdirs, this includes the mrootchain def _leaves(self, *, diff --git a/scripts/dbgmtree.py b/scripts/dbgmtree.py index 8a560f7e..192da568 100755 --- a/scripts/dbgmtree.py +++ b/scripts/dbgmtree.py @@ -1477,6 +1477,30 @@ class Mdir: rbyd = Rbyd.fetch(bd, blocks, trunk) return cls(mid, rbyd, mbits=Mtree.mbits_(bd)) + def lookupnext(self, mid, tag=None, *, + path=False): + # this is similar to rbyd lookupnext, we just error if + # lookupnext changes mids + if not isinstance(mid, Mid): + mid = Mid(mid, mbits=self.mbits) + r = self.rbyd.lookupnext(mid.mrid, tag, + path=path) + if path: + rid, rattr, path_ = r + else: + rid, rattr = r + + if rid != mid.mrid: + if path: + return None, path_ + else: + return None + + if path: + return rattr, path_ + else: + return rattr + def lookup(self, mid, tag=None, mask=None, *, path=False): if not isinstance(mid, Mid): @@ -1777,6 +1801,40 @@ class Mtree: else: return mdir + def lookupnext(self, mid, *, + path=False, + depth=None): + if not isinstance(mid, Mid): + mid = self.mid(mid) + + # lookup the relevant mdir + r = self.lookupleaf(mid, + path=path, + depth=depth) + if path: + mdir, path_ = r + else: + mdir = r + if mdir is None: + if path: + return None, None, path_ + else: + return None, None + + # not in mdir? + if mid.mrid >= mdir.weight: + if path: + return None, None, path_ + else: + return None, None + + # lookup mid in mdir + rattr = mdir.lookupnext(mid) + if path: + return mdir, rattr, path_+[(mid, mdir, rattr)] + else: + return mdir, rattr + def lookup(self, mid, *, path=False, depth=None): @@ -1804,18 +1862,12 @@ class Mtree: else: return None, None - # lookup name in mdir - name = mdir.lookup(mid) - # name tag missing? weird - if name is None: - if path: - return None, None, path_ - else: - return None, None + # lookup mid in mdir + rattr = mdir.lookup(mid) if path: - return mdir, name, path_+[(mid, mdir, name)] + return mdir, rattr, path_+[(mid, mdir, rattr)] else: - return mdir, name + return mdir, rattr # iterate over all mdirs, this includes the mrootchain def _leaves(self, *, diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index 1b6c0707..a63399d3 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -104,21 +104,23 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + assert(bid_ == i); assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -1879,21 +1881,23 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + assert(bid_ == i); assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -3654,21 +3658,23 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + assert(bid_ == i); assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); diff --git a/tests/test_btree.toml b/tests/test_btree.toml index b340f865..ccd329c6 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -29,12 +29,13 @@ code = ''' assert(btree.weight == 0); // try looking up tags + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' # test an inlined tree @@ -64,19 +65,21 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + assert(bid_ == 0); assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' # test a single-rbyd tree @@ -108,26 +111,27 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_two_backwards] @@ -158,26 +162,27 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' # still a single-rbyd tree, just making sure it works @@ -211,33 +216,34 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 3, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_three_backwards] @@ -270,33 +276,34 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 3, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' # try larger trees, when exactly a tree splits depends on the disk geometry, so @@ -334,13 +341,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -348,8 +356,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_push_backwards] @@ -385,13 +393,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, n-1-i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, n-1-i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -399,8 +408,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_push_fuzz] @@ -466,12 +475,13 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -479,8 +489,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -521,13 +531,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, i*W+W-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); @@ -535,11 +546,11 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n*W, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n*W, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; @@ -643,6 +654,7 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -653,8 +665,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -662,11 +674,11 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, total_weight, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space lfs_size_t weighted_bid = 0; @@ -725,19 +737,20 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_update_two] @@ -777,26 +790,27 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_update_three] @@ -842,33 +856,34 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 3, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_update] @@ -909,13 +924,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -923,8 +939,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, N, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, N, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_update_fuzz] @@ -995,12 +1011,13 @@ code = ''' assert(btree.weight == N); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -1008,8 +1025,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, N, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, N, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -1054,13 +1071,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookup(&lfs, &btree, i*W+W-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); @@ -1068,11 +1086,11 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, N*W, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, N*W, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; @@ -1182,6 +1200,7 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -1192,8 +1211,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -1201,11 +1220,11 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, total_weight, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < N; i++) { // calculate actual bid in btree space lfs_size_t weighted_bid = 0; @@ -1263,12 +1282,13 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( @@ -1280,15 +1300,15 @@ code = ''' assert(btree.weight == 1); // try looking up tags - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop_two] @@ -1322,19 +1342,20 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( @@ -1346,22 +1367,22 @@ code = ''' assert(btree.weight == 2); // try looking up tags - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop_two_other] @@ -1395,19 +1416,20 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( @@ -1419,22 +1441,22 @@ code = ''' assert(btree.weight == 2); // try looking up tags - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop_three] @@ -1470,26 +1492,27 @@ code = ''' // try looking up tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( @@ -1501,29 +1524,29 @@ code = ''' assert(btree.weight == 3); // try looking up tags - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 2, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 2, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, 3, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop] @@ -1565,13 +1588,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -1579,31 +1603,31 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, REMAINING, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "R", 1))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_btree_lookup(&lfs, &btree, REMAINING, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, REMAINING+1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop_backwards] @@ -1644,13 +1668,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -1659,23 +1684,23 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, REMAINING, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try recovering lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "R", 1))) => 0; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookup(&lfs, &btree, i+1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i+1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -1683,8 +1708,8 @@ code = ''' &(uint8_t){'a'+((i+(N-REMAINING)) % 26)}, 1) == 0); } - lfsr_btree_lookup(&lfs, &btree, REMAINING+1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop_fuzz] @@ -1757,12 +1782,13 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -1770,8 +1796,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -1816,13 +1842,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookup(&lfs, &btree, i*W+W-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); @@ -1830,34 +1857,34 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, REMAINING*W+W-1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING*W+W-1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, +W, "R", 1))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookup(&lfs, &btree, i*W+W-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_btree_lookup(&lfs, &btree, REMAINING*W+W-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, REMAINING*W+W-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, "R", 1) == 0); - lfsr_btree_lookup(&lfs, &btree, (REMAINING+1)*W+W-1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, (REMAINING+1)*W+W-1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; @@ -1988,6 +2015,7 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -1998,8 +2026,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2007,11 +2035,11 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, total_weight, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space lfs_size_t weighted_bid = 0; @@ -2077,13 +2105,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -2091,8 +2120,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_split_fuzz] @@ -2165,12 +2194,13 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -2178,8 +2208,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -2227,13 +2257,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, i*W+W-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); @@ -2241,8 +2272,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n*W, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n*W, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_split_sparse_fuzz] @@ -2324,6 +2355,7 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -2334,8 +2366,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2373,6 +2405,7 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -2383,8 +2416,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2392,11 +2425,11 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, total_weight, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space lfs_size_t weighted_bid = 0; @@ -2475,19 +2508,20 @@ code = ''' assert(btree.weight == 1); // check that our other entry is fine + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_drop_compact] @@ -2546,19 +2580,20 @@ code = ''' assert(btree.weight == 1); // check that our other entry is fine + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_drop_split] @@ -2610,19 +2645,20 @@ code = ''' assert(btree.weight == 1); // check that our other entry is fine + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_drop_merge] @@ -2689,19 +2725,20 @@ code = ''' assert(btree.weight == 1); // check that our other entry is fine + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_lookup(&lfs, &btree, 0, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, 0, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buf1, SIZE) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookup(&lfs, &btree, 1, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' @@ -2792,12 +2829,13 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -2805,8 +2843,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -2932,6 +2970,7 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -2942,8 +2981,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_lookup(&lfs, &btree, weighted_bid+sim_weights[i]-1, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2951,11 +2990,11 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, total_weight, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t bid_ = -1; + bid_ = -1; for (lfs_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space lfs_size_t weighted_bid = 0; @@ -3004,8 +3043,8 @@ code = ''' assert(btree.weight == 0); // try to find tags + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3044,8 +3083,8 @@ code = ''' // try to find tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3103,8 +3142,8 @@ code = ''' // try to find tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3176,8 +3215,8 @@ code = ''' // try to find tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3257,8 +3296,8 @@ code = ''' // try to find tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3349,8 +3388,8 @@ code = ''' // try to find tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3463,8 +3502,8 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { @@ -3538,8 +3577,8 @@ code = ''' // try to find tags uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3687,8 +3726,8 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { @@ -3852,8 +3891,8 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { @@ -4047,8 +4086,8 @@ code = ''' assert(btree.weight == total_weight); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; - lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { @@ -4110,13 +4149,14 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -4124,8 +4164,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); @@ -4187,8 +4227,8 @@ code = ''' // check that the elements are in the tree for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -4196,8 +4236,8 @@ code = ''' } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookup(&lfs, &btree, n, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_traversal_fuzz] @@ -4263,12 +4303,13 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; + lfsr_bid_t bid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -4276,8 +4317,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // test that we can traverse the tree, keeping track of all blocks // we see @@ -4356,8 +4397,8 @@ code = ''' assert(btree.weight == sim_size); for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookup(&lfs, &btree, i, - &tag_, &weight_, &data_) => 0; + lfsr_btree_lookupnext(&lfs, &btree, i, + &bid_, &tag_, &weight_, &data_) => 0; lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); @@ -4365,8 +4406,8 @@ code = ''' } // and no extra elements - lfsr_btree_lookup(&lfs, &btree, sim_size, - &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); diff --git a/tests/test_forphans.toml b/tests/test_forphans.toml index 9816f3ba..38e2a719 100644 --- a/tests/test_forphans.toml +++ b/tests/test_forphans.toml @@ -5325,7 +5325,7 @@ code = ''' assert(lfsr_mtree_weight(&lfs) <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); // check that other files are unaffected @@ -5461,7 +5461,7 @@ code = ''' assert(lfsr_mtree_weight(&lfs) <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); // check that other files are unaffected @@ -5611,7 +5611,7 @@ code = ''' assert(lfsr_mtree_weight(&lfs) <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); // check that other files are unaffected @@ -5767,7 +5767,7 @@ code = ''' assert(lfsr_mtree_weight(&lfs) <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); // check that other files are unaffected diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 93bb860e..c99543e6 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -177,7 +177,7 @@ code = ''' memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; @@ -196,7 +196,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -220,7 +220,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -277,13 +277,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -303,13 +303,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -386,13 +386,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -402,7 +402,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -422,13 +422,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -438,7 +438,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -488,7 +488,7 @@ code = ''' // try looking up each entry lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_data_t data; uint8_t buffer[256]; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; @@ -499,7 +499,7 @@ code = ''' sprintf(name+1, "%03x", i); mdir.mid += 1; if (lfsr_mrid(&lfs, mdir.mid) >= (lfsr_srid_t)mdir.rbyd.weight) { - lfsr_mtree_lookup(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, + lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, &mdir) => 0; } lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -512,7 +512,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; for (lfs_size_t i = 0; i < N; i++) { @@ -521,7 +521,7 @@ code = ''' sprintf(name+1, "%03x", i); mdir.mid += 1; if (lfsr_mrid(&lfs, mdir.mid) >= (lfsr_srid_t)mdir.rbyd.weight) { - lfsr_mtree_lookup(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, + lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, &mdir) => 0; } lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -587,7 +587,7 @@ code = ''' // try looking up each entry lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_data_t data; uint8_t buffer[256]; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; @@ -613,7 +613,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; for (lfs_size_t i = 0; i < N; i++) { @@ -696,7 +696,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -716,7 +716,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -788,7 +788,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -808,7 +808,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -871,7 +871,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -887,7 +887,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -965,7 +965,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -975,7 +975,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -991,7 +991,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1001,7 +1001,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1079,13 +1079,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1105,13 +1105,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1204,7 +1204,7 @@ code = ''' // try looking up each entry lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_data_t data; uint8_t buffer[256]; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; @@ -1230,7 +1230,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; for (lfs_size_t i = 0; i < N; i++) { @@ -1277,7 +1277,7 @@ code = ''' memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; @@ -1292,7 +1292,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // force mdir to compact twice, this should relocate - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( @@ -1313,7 +1313,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1323,7 +1323,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -1347,7 +1347,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1357,7 +1357,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -1435,13 +1435,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1451,7 +1451,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -1471,13 +1471,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1487,7 +1487,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -1565,13 +1565,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1581,7 +1581,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -1601,13 +1601,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1617,7 +1617,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -1668,7 +1668,7 @@ code = ''' assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our entry is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1687,7 +1687,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1763,7 +1763,7 @@ code = ''' assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1798,7 +1798,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1880,7 +1880,7 @@ code = ''' assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our entry is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -1907,7 +1907,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2002,13 +2002,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2018,7 +2018,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -2038,13 +2038,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2054,7 +2054,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 1) => 1; @@ -2144,13 +2144,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2160,7 +2160,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2184,13 +2184,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2200,7 +2200,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2287,7 +2287,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2307,7 +2307,7 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2346,7 +2346,7 @@ code = ''' memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; @@ -2368,7 +2368,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2392,7 +2392,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2459,13 +2459,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2485,13 +2485,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -2615,7 +2615,7 @@ code = ''' // try looking up each entry lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_data_t data; uint8_t buffer[256]; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; @@ -2641,7 +2641,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; for (lfs_size_t i = 0; i < N; i++) { @@ -3579,7 +3579,7 @@ code = ''' memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; @@ -3663,7 +3663,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -3683,7 +3683,7 @@ code = ''' lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -3802,13 +3802,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -3824,13 +3824,13 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -3968,19 +3968,19 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -3996,19 +3996,19 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -4233,7 +4233,7 @@ code = ''' // try looking up each entry lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_data_t data; uint8_t buffer[256]; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; @@ -4244,7 +4244,7 @@ code = ''' sprintf(name+1, "%03x", i); mdir.mid += 1; if (lfsr_mrid(&lfs, mdir.mid) >= (lfsr_srid_t)mdir.rbyd.weight) { - lfsr_mtree_lookup(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, + lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, &mdir) => 0; } lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -4257,7 +4257,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; for (lfs_size_t i = 0; i < N; i++) { @@ -4266,7 +4266,7 @@ code = ''' sprintf(name+1, "%03x", i); mdir.mid += 1; if (lfsr_mrid(&lfs, mdir.mid) >= (lfsr_srid_t)mdir.rbyd.weight) { - lfsr_mtree_lookup(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, + lfsr_mtree_lookupleaf(&lfs, lfsr_mbid(&lfs, mdir.mid) + 1, &mdir) => 0; } lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -4397,7 +4397,7 @@ code = ''' // try looking up each entry lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_data_t data; uint8_t buffer[256]; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; @@ -4423,7 +4423,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, 0, &mdir) => 0; lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, &data) => 0; lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; for (lfs_size_t i = 0; i < N; i++) { @@ -4801,7 +4801,7 @@ code = ''' assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our entry is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; @@ -4874,7 +4874,7 @@ code = ''' assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfsr_mtree_lookupleaf(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE;