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;