Github/littlefs
1
Fork 0
Code Actions Activity

Renamed mbits/mlimit to mleaf_bits/mleaf_limit

Browse Source 
- mbits -> mleaf_bits
- mlimit -> mleaf_limit
- mweight -> mleaf_weight
- lfsr_mridmask -> lfsr_midrmask
- lfsr_mbidmask -> lfsr_midbmask

This is a bit tricky to name, since we want to clarify it's not the
mtree limit and not the mdir's actual rbyd weight. But this also risks
confusing around the difference between mdirs/mleaves (mdirs are
mtree's leaves).
This commit is contained in:
Christopher Haster
2023-09-14 19:00:28 -05:00
parent 5504936b10
commit 5f3994c83b
6 changed files with 388 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+84 -84
View File
@@ -1534,16 +1534,16 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data,
/// Metadata-id things /// /// Metadata-id things ///
static inline lfsr_mid_t lfsr_mweight(lfs_t *lfs) { static inline lfsr_mid_t lfsr_mleafweight(lfs_t *lfs) {
return 1 << lfs->mbits; return 1 << lfs->mleaf_bits;
} }
static inline lfsr_smid_t lfsr_mridmask(lfs_t *lfs) { static inline lfsr_smid_t lfsr_midrmask(lfs_t *lfs) {
return (1 << lfs->mbits) - 1; return (1 << lfs->mleaf_bits) - 1;
} }
static inline lfsr_smid_t lfsr_mbidmask(lfs_t *lfs) { static inline lfsr_smid_t lfsr_midbmask(lfs_t *lfs) {
return ~lfsr_mridmask(lfs); return ~lfsr_midrmask(lfs);
} }
// we use the root's bookmark at 0.0 to represent root // we use the root's bookmark at 0.0 to represent root
@@ -1693,7 +1693,7 @@ static int lfsr_data_readgrm(lfs_t *lfs, lfsr_data_t *data,
LFS_ASSERT(grm->rms[i] < lfs_smax32( LFS_ASSERT(grm->rms[i] < lfs_smax32(
lfsr_mtree_weight(lfs), lfsr_mtree_weight(lfs),
lfsr_mweight(lfs))); lfsr_mleafweight(lfs)));
} }
return 0; return 0;
@@ -4651,7 +4651,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
// TODO anything better? // TODO anything better?
mid = (mid == -1 mid = (mid == -1
? -1 ? -1
: mid - (lfs_smax32(mdir->mid, 0) & lfsr_mbidmask(lfs))); : mid - (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs)));
lfsr_smid_t mid_; lfsr_smid_t mid_;
lfsr_tag_t tag__; lfsr_tag_t tag__;
@@ -4680,7 +4680,7 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
// TODO anything better? // TODO anything better?
(mid == -1 (mid == -1
? -1 ? -1
: mid - (lfs_smax32(mdir->mid, 0) & lfsr_mbidmask(lfs))), : mid - (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs))),
tag, tag,
tag_, data_); tag_, data_);
} }
@@ -4729,7 +4729,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_mdir_t *mdir_) {
// looking up mroot? // looking up mroot?
if (lfsr_mtree_isinlined(lfs)) { if (lfsr_mtree_isinlined(lfs)) {
LFS_ASSERT(mid >= 0); LFS_ASSERT(mid >= 0);
LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mweight(lfs)); LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mleafweight(lfs));
mdir_->mid = mid; mdir_->mid = mid;
mdir_->u.m = lfs->mroot.u.m; mdir_->u.m = lfs->mroot.u.m;
return 0; return 0;
@@ -4746,7 +4746,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_mdir_t *mdir_) {
if (err) { if (err) {
return err; return err;
} }
LFS_ASSERT((lfsr_smid_t)bid == (mid | lfsr_mridmask(lfs))); LFS_ASSERT((lfsr_smid_t)bid == (mid | lfsr_midrmask(lfs)));
LFS_ASSERT(tag == LFSR_TAG_MDIR); LFS_ASSERT(tag == LFSR_TAG_MDIR);
// decode mdir // decode mdir
@@ -4805,20 +4805,20 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) {
while (true) { while (true) {
// calculate new mid, be careful to avoid rid overflow // calculate new mid, be careful to avoid rid overflow
lfsr_bid_t bid = mdir->mid & lfsr_mbidmask(lfs); lfsr_bid_t bid = mdir->mid & lfsr_midbmask(lfs);
lfsr_srid_t rid = (mdir->mid & lfsr_mridmask(lfs)) + off; lfsr_srid_t rid = (mdir->mid & lfsr_midrmask(lfs)) + off;
// lookup mdirs until we find our rid, we need to do this because // lookup mdirs until we find our rid, we need to do this because
// we don't know how many rids are in each mdir until we fetch // we don't know how many rids are in each mdir until we fetch
while (rid >= mdir->u.m.weight) { while (rid >= mdir->u.m.weight) {
// end of mtree? // end of mtree?
if (bid+lfsr_mweight(lfs) >= lfsr_mtree_weight(lfs)) { if (bid+lfsr_mleafweight(lfs) >= lfsr_mtree_weight(lfs)) {
// if we hit the end of the mtree, park the mdir so all future // if we hit the end of the mtree, park the mdir so all future
// seeks return noent // seeks return noent
mdir->mid = bid + mdir->u.m.weight; mdir->mid = bid + mdir->u.m.weight;
return LFS_ERR_NOENT; return LFS_ERR_NOENT;
} }
bid += lfsr_mweight(lfs); bid += lfsr_mleafweight(lfs);
rid -= mdir->u.m.weight; rid -= mdir->u.m.weight;
int err = lfsr_mtree_lookup(lfs, bid, mdir); int err = lfsr_mtree_lookup(lfs, bid, mdir);
if (err) { if (err) {
@@ -4952,7 +4952,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
lfsr_srid_t rid = (attrs[i].rid == -1 lfsr_srid_t rid = (attrs[i].rid == -1
? -1 ? -1
: attrs[i].rid - ( : attrs[i].rid - (
lfs_smax32(mdir_.mid, 0) & lfsr_mbidmask(lfs))); lfs_smax32(mdir_.mid, 0) & lfsr_midbmask(lfs)));
// don't write tags outside of the requested range // don't write tags outside of the requested range
if (rid >= start_rid if (rid >= start_rid
@@ -5146,7 +5146,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
|| lfsr_mtree_isinlined(lfs) || lfsr_mtree_isinlined(lfs)
|| mdir->u.m.weight > 0); || mdir->u.m.weight > 0);
LFS_ASSERT(mid == -1 LFS_ASSERT(mid == -1
|| (mdir->mid & lfsr_mridmask(lfs)) <= mdir->u.m.weight); || (mdir->mid & lfsr_midrmask(lfs)) <= mdir->u.m.weight);
// parse out any pending gstate, these will get automatically xored // parse out any pending gstate, these will get automatically xored
// with on-disk gdeltas in lower-level functions // with on-disk gdeltas in lower-level functions
@@ -5178,8 +5178,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
for (lfsr_openedmdir_t *opened = lfs->opened[type]; for (lfsr_openedmdir_t *opened = lfs->opened[type];
opened; opened;
opened = opened->next) { opened = opened->next) {
if ((opened->mdir.mid & lfsr_mbidmask(lfs)) if ((opened->mdir.mid & lfsr_midbmask(lfs))
== (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) {
lfsr_mdir_unerase(&opened->mdir); lfsr_mdir_unerase(&opened->mdir);
} }
} }
@@ -5212,7 +5212,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// This makes it so the split logic is the same whether or not // This makes it so the split logic is the same whether or not
// we're uninlining. // we're uninlining.
err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS(
LFSR_ATTR(0, MDIR, +lfsr_mweight(lfs), NULL))); LFSR_ATTR(0, MDIR, +lfsr_mleafweight(lfs), NULL)));
if (err) { if (err) {
return err; return err;
} }
@@ -5270,13 +5270,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} }
// adjust our sibling's mid after committing attrs // adjust our sibling's mid after committing attrs
msibling_.mid += lfsr_mweight(lfs); msibling_.mid += lfsr_mleafweight(lfs);
LFS_DEBUG("Splitting mdir %"PRId32" " LFS_DEBUG("Splitting mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"} " "0x{%"PRIx32",%"PRIx32"} "
"-> 0x{%"PRIx32",%"PRIx32"}, " "-> 0x{%"PRIx32",%"PRIx32"}, "
"0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"}",
mid >> lfs->mbits, mid >> lfs->mleaf_bits,
mdir->u.m.blocks[0], mdir->u.m.blocks[1], mdir->u.m.blocks[0], mdir->u.m.blocks[1],
mdir_.u.m.blocks[0], mdir_.u.m.blocks[1], mdir_.u.m.blocks[0], mdir_.u.m.blocks[1],
msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]);
@@ -5288,11 +5288,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
if (mdir_.u.m.weight == 0 && msibling_.u.m.weight == 0) { if (mdir_.u.m.weight == 0 && msibling_.u.m.weight == 0) {
LFS_DEBUG("Dropping mdir %"PRId32" " LFS_DEBUG("Dropping mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"}",
mdir_.mid >> lfs->mbits, mdir_.mid >> lfs->mleaf_bits,
mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]);
LFS_DEBUG("Dropping mdir %"PRId32" " LFS_DEBUG("Dropping mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"}",
msibling_.mid >> lfs->mbits, msibling_.mid >> lfs->mleaf_bits,
msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]);
goto drop; goto drop;
@@ -5300,7 +5300,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} else if (msibling_.u.m.weight == 0) { } else if (msibling_.u.m.weight == 0) {
LFS_DEBUG("Dropping mdir %"PRId32" " LFS_DEBUG("Dropping mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"}",
msibling_.mid >> lfs->mbits, msibling_.mid >> lfs->mleaf_bits,
msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]);
goto relocate; goto relocate;
@@ -5308,7 +5308,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} else if (mdir_.u.m.weight == 0) { } else if (mdir_.u.m.weight == 0) {
LFS_DEBUG("Dropping mdir %"PRId32" " LFS_DEBUG("Dropping mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"}",
mdir_.mid >> lfs->mbits, mdir_.mid >> lfs->mleaf_bits,
mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]);
mdir_.u.m = msibling_.u.m; mdir_.u.m = msibling_.u.m;
msibling_.u.m.weight = 0; msibling_.u.m.weight = 0;
@@ -5335,12 +5335,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
uint8_t mdir_buf[LFSR_MDIR_DSIZE]; uint8_t mdir_buf[LFSR_MDIR_DSIZE];
uint8_t msibling_buf[LFSR_MDIR_DSIZE]; uint8_t msibling_buf[LFSR_MDIR_DSIZE];
err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS(
LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs),
MDIR, 0, FROMMBLOCKS(lfs, mdir_.u.m.blocks, MDIR, 0, FROMMBLOCKS(lfs, mdir_.u.m.blocks,
mdir_buf)), mdir_buf)),
LFSR_ATTR((mdir_.mid | lfsr_mridmask(lfs))+1, LFSR_ATTR((mdir_.mid | lfsr_midrmask(lfs))+1,
BRANCH, +lfsr_mweight(lfs), DATA(split_data)), BRANCH, +lfsr_mleafweight(lfs), DATA(split_data)),
LFSR_ATTR(msibling_.mid | lfsr_mridmask(lfs), LFSR_ATTR(msibling_.mid | lfsr_midrmask(lfs),
MDIR, 0, FROMMBLOCKS(lfs, msibling_.u.m.blocks, MDIR, 0, FROMMBLOCKS(lfs, msibling_.u.m.blocks,
msibling_buf)))); msibling_buf))));
if (err) { if (err) {
@@ -5351,7 +5351,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} else if (err == LFS_ERR_NOENT) { } else if (err == LFS_ERR_NOENT) {
LFS_DEBUG("Dropping mdir %"PRId32" " LFS_DEBUG("Dropping mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"}",
mid >> lfs->mbits, mid >> lfs->mleaf_bits,
mdir->u.m.blocks[0], mdir->u.m.blocks[1]); mdir->u.m.blocks[0], mdir->u.m.blocks[1]);
// consume gstate so we don't lose any info // consume gstate so we don't lose any info
@@ -5366,8 +5366,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// update our mtree // update our mtree
err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS(
LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs),
RM, -lfsr_mweight(lfs), NULL))); RM, -lfsr_mleafweight(lfs), NULL)));
if (err) { if (err) {
return err; return err;
} }
@@ -5377,7 +5377,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
&& !(mid == -1 || lfsr_mtree_isinlined(lfs))) { && !(mid == -1 || lfsr_mtree_isinlined(lfs))) {
LFS_DEBUG("Relocating mdir %"PRId32" " LFS_DEBUG("Relocating mdir %"PRId32" "
"0x{%"PRIx32",%"PRIx32"} -> 0x{%"PRIx32",%"PRIx32"}", "0x{%"PRIx32",%"PRIx32"} -> 0x{%"PRIx32",%"PRIx32"}",
mid >> lfs->mbits, mid >> lfs->mleaf_bits,
mdir->u.m.blocks[0], mdir->u.m.blocks[1], mdir->u.m.blocks[0], mdir->u.m.blocks[1],
mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]);
@@ -5388,7 +5388,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// update our mtree // update our mtree
uint8_t mdir_buf[LFSR_MDIR_DSIZE]; uint8_t mdir_buf[LFSR_MDIR_DSIZE];
err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS(
LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs),
MDIR, 0, FROMMBLOCKS(lfs, mdir_.u.m.blocks, MDIR, 0, FROMMBLOCKS(lfs, mdir_.u.m.blocks,
mdir_buf)))); mdir_buf))));
if (err) { if (err) {
@@ -5419,11 +5419,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// fix our grm // fix our grm
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
if ((grm->rms[j] & lfsr_mbidmask(lfs)) if ((grm->rms[j] & lfsr_midbmask(lfs))
== (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) {
if ((grm->rms[j] & lfsr_mridmask(lfs)) if ((grm->rms[j] & lfsr_midrmask(lfs))
>= mdir_.u.m.weight) { >= mdir_.u.m.weight) {
grm->rms[j] += lfsr_mweight(lfs) grm->rms[j] += lfsr_mleafweight(lfs)
- mdir_.u.m.weight; - mdir_.u.m.weight;
} }
// update mid if we had a split or drop // update mid if we had a split or drop
@@ -5605,8 +5605,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// first play out any attrs that change our rid // first play out any attrs that change our rid
for (lfs_size_t i = 0; i < attr_count; i++) { for (lfs_size_t i = 0; i < attr_count; i++) {
// adjust opened mdirs? // adjust opened mdirs?
if ((opened->mdir.mid & lfsr_mbidmask(lfs)) if ((opened->mdir.mid & lfsr_midbmask(lfs))
== (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs)) == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))
&& opened->mdir.mid >= attrs[i].rid) { && opened->mdir.mid >= attrs[i].rid) {
// removed? // removed?
if (opened->mdir.mid < attrs[i].rid - attrs[i].delta) { if (opened->mdir.mid < attrs[i].rid - attrs[i].delta) {
@@ -5635,14 +5635,14 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} }
// update any opened mdirs if we had a split or drop // update any opened mdirs if we had a split or drop
if ((opened->mdir.mid & lfsr_mbidmask(lfs)) if ((opened->mdir.mid & lfsr_midbmask(lfs))
== (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) {
if (msibling_.u.m.weight > 0 if (msibling_.u.m.weight > 0
&& (opened->mdir.mid & lfsr_mridmask(lfs)) && (opened->mdir.mid & lfsr_midrmask(lfs))
>= mdir_.u.m.weight) { >= mdir_.u.m.weight) {
LFS_ASSERT(lfsr_btree_weight(&mtree_) LFS_ASSERT(lfsr_btree_weight(&mtree_)
!= lfsr_mtree_weight(lfs)); != lfsr_mtree_weight(lfs));
opened->mdir.mid += lfsr_mweight(lfs) opened->mdir.mid += lfsr_mleafweight(lfs)
- mdir_.u.m.weight; - mdir_.u.m.weight;
opened->mdir.u.m = msibling_.u.m; opened->mdir.u.m = msibling_.u.m;
} else { } else {
@@ -5659,8 +5659,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
for (lfs_size_t i = 0; i < attr_count; i++) { for (lfs_size_t i = 0; i < attr_count; i++) {
// TODO clean this up a bit? // TODO clean this up a bit?
// adjust opened mdirs? // adjust opened mdirs?
if ((dir->bookmark & lfsr_mbidmask(lfs)) if ((dir->bookmark & lfsr_midbmask(lfs))
== (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs)) == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))
&& dir->bookmark >= attrs[i].rid) { && dir->bookmark >= attrs[i].rid) {
// removed? // removed?
if (dir->bookmark < attrs[i].rid - attrs[i].delta) { if (dir->bookmark < attrs[i].rid - attrs[i].delta) {
@@ -5679,14 +5679,14 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} }
} }
if ((dir->bookmark & lfsr_mbidmask(lfs)) if ((dir->bookmark & lfsr_midbmask(lfs))
== (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) {
if (msibling_.u.m.weight > 0 if (msibling_.u.m.weight > 0
&& (dir->bookmark & lfsr_mridmask(lfs)) && (dir->bookmark & lfsr_midrmask(lfs))
>= mdir_.u.m.weight) { >= mdir_.u.m.weight) {
LFS_ASSERT(lfsr_btree_weight(&mtree_) LFS_ASSERT(lfsr_btree_weight(&mtree_)
!= lfsr_mtree_weight(lfs)); != lfsr_mtree_weight(lfs));
dir->bookmark += lfsr_mweight(lfs) dir->bookmark += lfsr_mleafweight(lfs)
- mdir_.u.m.weight; - mdir_.u.m.weight;
} }
} else if (dir->bookmark > mid) { } else if (dir->bookmark > mid) {
@@ -5701,9 +5701,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// update mdir to follow requested rid // update mdir to follow requested rid
if (mid != -1 if (mid != -1
&& msibling_.u.m.weight > 0 && msibling_.u.m.weight > 0
&& (mid & lfsr_mridmask(lfs)) >= mdir_.u.m.weight) { && (mid & lfsr_midrmask(lfs)) >= mdir_.u.m.weight) {
LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs)); LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs));
mdir->mid += lfsr_mweight(lfs) - mdir_.u.m.weight; mdir->mid += lfsr_mleafweight(lfs) - mdir_.u.m.weight;
mdir->u.m = msibling_.u.m; mdir->u.m = msibling_.u.m;
} else { } else {
mdir->u.m = mdir_.u.m; mdir->u.m = mdir_.u.m;
@@ -5760,7 +5760,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs,
return err; return err;
} }
LFS_ASSERT(tag == LFSR_TAG_MDIR); LFS_ASSERT(tag == LFSR_TAG_MDIR);
LFS_ASSERT(weight == lfsr_mweight(lfs)); LFS_ASSERT(weight == lfsr_mleafweight(lfs));
// decode mdir // decode mdir
err = lfsr_data_readmblocks(lfs, &data, mdir.u.m.blocks); err = lfsr_data_readmblocks(lfs, &data, mdir.u.m.blocks);
@@ -6068,7 +6068,7 @@ static int lfsr_mtree_traversal_next(lfs_t *lfs,
lfs->mtree = LFSR_BTREE_NULL; lfs->mtree = LFSR_BTREE_NULL;
} else if (tag == LFSR_TAG_MDIR) { } else if (tag == LFSR_TAG_MDIR) {
err = lfsr_data_readbtreeinlined(lfs, &data, err = lfsr_data_readbtreeinlined(lfs, &data,
LFSR_TAG_MDIR, lfsr_mweight(lfs), LFSR_TAG_MDIR, lfsr_mleafweight(lfs),
&lfs->mtree); &lfs->mtree);
if (err) { if (err) {
return err; return err;
@@ -6235,9 +6235,8 @@ static lfsr_data_t lfsr_data_fromsuperconfig(lfs_t *lfs,
LFS_ASSERT(d_ >= 0); LFS_ASSERT(d_ >= 0);
d += d_; d += d_;
// on-disk mlimit // on-disk mleaf limit
lfsr_mid_t mlimit = lfsr_mweight(lfs)-1; d_ = lfs_toleb128(lfsr_mleafweight(lfs)-1, &buffer[d], 5);
d_ = lfs_toleb128(mlimit, &buffer[d], 5);
LFS_ASSERT(d_ >= 0); LFS_ASSERT(d_ >= 0);
d += d_; d += d_;
@@ -6435,16 +6434,17 @@ static int lfsr_mountinited(lfs_t *lfs) {
// check the on-disk mtree limit // check the on-disk mtree limit
// TODO actually use this // TODO actually use this
lfsr_mid_t mlimit; lfsr_mid_t mleaf_limit;
err = lfsr_data_readleb128(lfs, &data, (int32_t*)&mlimit); err = lfsr_data_readleb128(lfs, &data, (int32_t*)&mleaf_limit);
// treat any leb128 overflows as out-of-range values // treat any leb128 overflows as out-of-range values
if (err && err != LFS_ERR_CORRUPT) { if (err && err != LFS_ERR_CORRUPT) {
return err; return err;
} }
if (err == LFS_ERR_CORRUPT || mlimit != lfsr_mweight(lfs)-1) { if (err == LFS_ERR_CORRUPT
LFS_ERROR("Incompatible mlimit 0x%"PRIx32, || mleaf_limit != lfsr_mleafweight(lfs)-1) {
(err ? (lfsr_mid_t)-1 : mlimit)); LFS_ERROR("Incompatible mleaf limit 0x%"PRIx32,
(err ? (lfsr_mid_t)-1 : mleaf_limit));
return LFS_ERR_INVAL; return LFS_ERR_INVAL;
} }
@@ -6548,14 +6548,14 @@ static int lfsr_mountinited(lfs_t *lfs) {
if (lfsr_grm_count(&lfs->grm) == 2) { if (lfsr_grm_count(&lfs->grm) == 2) {
LFS_DEBUG("Found pending grm " LFS_DEBUG("Found pending grm "
"%"PRId32".%"PRId32" %"PRId32".%"PRId32, "%"PRId32".%"PRId32" %"PRId32".%"PRId32,
lfs->grm.rms[0] >> lfs->mbits, lfs->grm.rms[0] >> lfs->mleaf_bits,
lfs->grm.rms[0] & lfsr_mridmask(lfs), lfs->grm.rms[0] & lfsr_midrmask(lfs),
lfs->grm.rms[1] >> lfs->mbits, lfs->grm.rms[1] >> lfs->mleaf_bits,
lfs->grm.rms[1] & lfsr_mridmask(lfs)); lfs->grm.rms[1] & lfsr_midrmask(lfs));
} else if (lfsr_grm_count(&lfs->grm) == 1) { } else if (lfsr_grm_count(&lfs->grm) == 1) {
LFS_DEBUG("Found pending grm %"PRId32".%"PRId32, LFS_DEBUG("Found pending grm %"PRId32".%"PRId32,
lfs->grm.rms[0] >> lfs->mbits, lfs->grm.rms[0] >> lfs->mleaf_bits,
lfs->grm.rms[0] & lfsr_mridmask(lfs)); lfs->grm.rms[0] & lfsr_midrmask(lfs));
} }
} }
@@ -6961,8 +6961,8 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
} }
// adjust rid if grm is on the same mdir as our dir // adjust rid if grm is on the same mdir as our dir
if ((grm.rms[0] & lfsr_mbidmask(lfs)) if ((grm.rms[0] & lfsr_midbmask(lfs))
== (mdir.mid & lfsr_mbidmask(lfs)) == (mdir.mid & lfsr_midbmask(lfs))
&& grm.rms[0] > mdir.mid) { && grm.rms[0] > mdir.mid) {
grm.rms[0] -= 1; grm.rms[0] -= 1;
} }
@@ -7024,8 +7024,8 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
} }
// adjust old rid if grm is on the same mdir as new rid // adjust old rid if grm is on the same mdir as new rid
if ((grm.rms[0] & lfsr_mbidmask(lfs)) if ((grm.rms[0] & lfsr_midbmask(lfs))
== (new_mdir.mid & lfsr_mbidmask(lfs)) == (new_mdir.mid & lfsr_midbmask(lfs))
&& grm.rms[0] >= new_mdir.mid) { && grm.rms[0] >= new_mdir.mid) {
grm.rms[0] += 1; grm.rms[0] += 1;
} }
@@ -7340,7 +7340,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) {
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
LFS_ASSERT(lfs->grm.rms[0] < lfs_smax32( LFS_ASSERT(lfs->grm.rms[0] < lfs_smax32(
lfsr_mtree_weight(lfs), lfsr_mtree_weight(lfs),
lfsr_mweight(lfs))); lfsr_mleafweight(lfs)));
int err = lfsr_mtree_lookup(lfs, lfs->grm.rms[0], &mdir); int err = lfsr_mtree_lookup(lfs, lfs->grm.rms[0], &mdir);
if (err) { if (err) {
return err; return err;
@@ -7351,15 +7351,15 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) {
lfsr_grm_poprm(&grm); lfsr_grm_poprm(&grm);
// make sure to adjust any remaining grms // make sure to adjust any remaining grms
if ((grm.rms[0] & lfsr_mbidmask(lfs)) if ((grm.rms[0] & lfsr_midbmask(lfs))
== (mdir.mid & lfsr_mbidmask(lfs)) == (mdir.mid & lfsr_midbmask(lfs))
&& grm.rms[0] >= mdir.mid) { && grm.rms[0] >= mdir.mid) {
LFS_ASSERT(grm.rms[0] != mdir.mid); LFS_ASSERT(grm.rms[0] != mdir.mid);
grm.rms[0] -= 1; grm.rms[0] -= 1;
} }
// remove the rid while also updating our grm // remove the rid while also updating our grm
LFS_ASSERT((lfs->grm.rms[0] & lfsr_mridmask(lfs)) < mdir.u.m.weight); LFS_ASSERT((lfs->grm.rms[0] & lfsr_midrmask(lfs)) < mdir.u.m.weight);
err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS(
LFSR_ATTR(mdir.mid, RM, -1, NULL), LFSR_ATTR(mdir.mid, RM, -1, NULL),
LFSR_ATTR(-1, GRM, 0, GRM(&grm)))); LFSR_ATTR(-1, GRM, 0, GRM(&grm))));
@@ -7377,14 +7377,14 @@ static int lfsr_fs_preparemutation(lfs_t *lfs) {
if (lfsr_grm_count(&lfs->grm) == 2) { if (lfsr_grm_count(&lfs->grm) == 2) {
LFS_DEBUG("Fixing pending grm " LFS_DEBUG("Fixing pending grm "
"%"PRId32".%"PRId32" %"PRId32".%"PRId32, "%"PRId32".%"PRId32" %"PRId32".%"PRId32,
lfs->grm.rms[0] >> lfs->mbits, lfs->grm.rms[0] >> lfs->mleaf_bits,
lfs->grm.rms[0] & lfsr_mridmask(lfs), lfs->grm.rms[0] & lfsr_midrmask(lfs),
lfs->grm.rms[1] >> lfs->mbits, lfs->grm.rms[1] >> lfs->mleaf_bits,
lfs->grm.rms[1] & lfsr_mridmask(lfs)); lfs->grm.rms[1] & lfsr_midrmask(lfs));
} else if (lfsr_grm_count(&lfs->grm) == 1) { } else if (lfsr_grm_count(&lfs->grm) == 1) {
LFS_DEBUG("Fixing pending grm %"PRId32".%"PRId32, LFS_DEBUG("Fixing pending grm %"PRId32".%"PRId32,
lfs->grm.rms[0] >> lfs->mbits, lfs->grm.rms[0] >> lfs->mleaf_bits,
lfs->grm.rms[0] & lfsr_mridmask(lfs)); lfs->grm.rms[0] & lfsr_midrmask(lfs));
} }
int err = lfsr_fs_fixgrm(lfs); int err = lfsr_fs_fixgrm(lfs);
@@ -10898,7 +10898,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
// Note we can't assume ~1/2 block utilization here, as an mdir may // Note we can't assume ~1/2 block utilization here, as an mdir may
// temporarily fill with more mids before compaction occurs. // temporarily fill with more mids before compaction occurs.
// //
lfs->mbits = lfs_nlog2(lfs->cfg->block_size/16); lfs->mleaf_bits = lfs_nlog2(lfs->cfg->block_size/16);
// zero linked-lists of opened mdirs // zero linked-lists of opened mdirs
lfs->opened[LFS_TYPE_REG] = NULL; lfs->opened[LFS_TYPE_REG] = NULL;
lfs.h
+1 -1
View File
@@ -514,7 +514,7 @@ typedef struct lfs {
uint8_t ggrm[LFSR_GRM_DSIZE]; uint8_t ggrm[LFSR_GRM_DSIZE];
uint8_t dgrm[LFSR_GRM_DSIZE]; uint8_t dgrm[LFSR_GRM_DSIZE];
uint8_t mbits; uint8_t mleaf_bits;
lfsr_mdir_t mroot; lfsr_mdir_t mroot;
lfsr_btree_t mtree; lfsr_btree_t mtree;
scripts/dbglfs.py
+21 -21
View File
@@ -654,10 +654,10 @@ def superconfig(mroot):
# collect gstate # collect gstate
class GState: class GState:
def __init__(self, mweight): def __init__(self, mleaf_weight):
self.gstate = {} self.gstate = {}
self.gdelta = {} self.gdelta = {}
self.mweight = mweight self.mleaf_weight = mleaf_weight
def xor(self, mbid, mw, mdir): def xor(self, mbid, mw, mdir):
tag = TAG_GSTATE-0x1 tag = TAG_GSTATE-0x1
@@ -691,11 +691,11 @@ class GState:
for _ in range(count): for _ in range(count):
mid, d_ = fromleb128(data[d:]); d += d_ mid, d_ = fromleb128(data[d:]); d += d_
rms.append(( rms.append((
mid - (mid % self.mweight), mid - (mid % self.mleaf_weight),
mid % self.mweight)) mid % self.mleaf_weight))
return rms return rms
def grepr(tag, data, mweight): def grepr(tag, data, mleaf_weight):
if tag == TAG_GRM: if tag == TAG_GRM:
d = 0 d = 0
count, d_ = fromleb128(data[d:]); d += d_ count, d_ = fromleb128(data[d:]); d += d_
@@ -704,11 +704,11 @@ def grepr(tag, data, mweight):
for _ in range(count): for _ in range(count):
mid, d_ = fromleb128(data[d:]); d += d_ mid, d_ = fromleb128(data[d:]); d += d_
rms.append(( rms.append((
mid - (mid % self.mweight), mid - (mid % mleaf_weight),
mid % self.mweight)) mid % mleaf_weight))
return 'grm %s' % ( return 'grm %s' % (
'none' if count == 0 'none' if count == 0
else ' '.join('%d.%d' % (mbid//mweight, rid) else ' '.join('%d.%d' % (mbid//mleaf_weight, rid)
for mbid, rid in rms) for mbid, rid in rms)
if count <= 2 if count <= 2
else '0x%x' % count) else '0x%x' % count)
@@ -738,7 +738,7 @@ def frepr(mdir, rid, tag):
def main(disk, mroots=None, *, def main(disk, mroots=None, *,
block_size=None, block_size=None,
mweight=None, mleaf_weight=None,
color='auto', color='auto',
**args): **args):
# figure out what color should be # figure out what color should be
@@ -761,10 +761,10 @@ def main(disk, mroots=None, *,
f.seek(0, os.SEEK_END) f.seek(0, os.SEEK_END)
block_size = f.tell() block_size = f.tell()
# determine the mweight from the block_size, this is just for # determine the mleaf_weight from the block_size, this is just for
# printing purposes # printing purposes
if mweight is None: if mleaf_weight is None:
mweight = 1 << m.ceil(m.log2(block_size // 16)) mleaf_weight = 1 << m.ceil(m.log2(block_size // 16))
# before we print, we need to do a pass for a few things: # before we print, we need to do a pass for a few things:
# - find the actual mroot # - find the actual mroot
@@ -776,7 +776,7 @@ def main(disk, mroots=None, *,
bweight = 0 bweight = 0
rweight = 0 rweight = 0
corrupted = False corrupted = False
gstate = GState(mweight) gstate = GState(mleaf_weight)
config = {} config = {}
dir_dids = [(0, b'', -1, 0, None, -1, TAG_DID, 0)] dir_dids = [(0, b'', -1, 0, None, -1, TAG_DID, 0)]
bookmark_dids = [] bookmark_dids = []
@@ -944,10 +944,10 @@ def main(disk, mroots=None, *,
print('littlefs v%s.%s %s, rev %d, weight %d.%d' % ( print('littlefs v%s.%s %s, rev %d, weight %d.%d' % (
config.get('major_version', ('?',))[0], config.get('major_version', ('?',))[0],
config.get('minor_version', ('?',))[0], config.get('minor_version', ('?',))[0],
mroot.addr(), mroot.rev, bweight//mweight, 1*mweight)) mroot.addr(), mroot.rev, bweight//mleaf_weight, 1*mleaf_weight))
# print header # print header
w_width = (m.ceil(m.log10(max(1, bweight//mweight)+1)) w_width = (m.ceil(m.log10(max(1, bweight//mleaf_weight)+1))
+ 2*m.ceil(m.log10(max(1, rweight)+1)) + 2*m.ceil(m.log10(max(1, rweight)+1))
+ 2) + 2)
if dtree: if dtree:
@@ -1002,7 +1002,7 @@ def main(disk, mroots=None, *,
print('%12s %-*s %s' % ( print('%12s %-*s %s' % (
'gstate:' if i == 0 else '', 'gstate:' if i == 0 else '',
w_width + 23, w_width + 23,
grepr(tag, data, mweight), grepr(tag, data, mleaf_weight),
next(xxd(data, 8), '') next(xxd(data, 8), '')
if not args.get('no_truncate') else '')) if not args.get('no_truncate') else ''))
@@ -1037,7 +1037,7 @@ def main(disk, mroots=None, *,
','.join('%04x' % block ','.join('%04x' % block
for block in it.chain([mdir.block], for block in it.chain([mdir.block],
mdir.redund_blocks)), mdir.redund_blocks)),
w_width, mbid//mweight, w_width, mbid//mleaf_weight,
tagrepr(tag, 0, len(data)), tagrepr(tag, 0, len(data)),
next(xxd(data, 8), '') next(xxd(data, 8), '')
if not args.get('no_truncate') else '', if not args.get('no_truncate') else '',
@@ -1140,8 +1140,8 @@ def main(disk, mroots=None, *,
mdir.redund_blocks)) mdir.redund_blocks))
if mbid != pmbid else '', if mbid != pmbid else '',
w_width, '%d.%d-%d' % ( w_width, '%d.%d-%d' % (
mbid//mweight, rid-(w-1), rid) mbid//mleaf_weight, rid-(w-1), rid)
if w > 1 else '%d.%d' % (mbid//mweight, rid) if w > 1 else '%d.%d' % (mbid//mleaf_weight, rid)
if w > 0 else '', if w > 0 else '',
f_width, '%s%s' % ( f_width, '%s%s' % (
prefixes[0+(i==len(dir)-1)], prefixes[0+(i==len(dir)-1)],
@@ -1243,9 +1243,9 @@ if __name__ == "__main__":
type=lambda x: int(x, 0), type=lambda x: int(x, 0),
help="Block size in bytes.") help="Block size in bytes.")
parser.add_argument( parser.add_argument(
'-M', '--mweight', '-M', '--mleaf-weight',
type=lambda x: int(x, 0), type=lambda x: int(x, 0),
help="Weight of mtree leaves for mid decoding. Defaults to a " help="Maximum weight of mdirs for mid decoding. Defaults to a "
"block_size derived value.") "block_size derived value.")
parser.add_argument( parser.add_argument(
'--color', '--color',
scripts/dbgmtree.py
+15 -13
View File
@@ -739,7 +739,7 @@ class Rbyd:
def main(disk, mroots=None, *, def main(disk, mroots=None, *,
block_size=None, block_size=None,
mweight=None, mleaf_weight=None,
color='auto', color='auto',
**args): **args):
# figure out what color should be # figure out what color should be
@@ -762,10 +762,10 @@ def main(disk, mroots=None, *,
f.seek(0, os.SEEK_END) f.seek(0, os.SEEK_END)
block_size = f.tell() block_size = f.tell()
# determine the mweight from the block_size, this is just for # determine the mleaf_weight from the block_size, this is just for
# printing purposes # printing purposes
if mweight is None: if mleaf_weight is None:
mweight = 1 << m.ceil(m.log2(block_size // 16)) mleaf_weight = 1 << m.ceil(m.log2(block_size // 16))
# before we print, we need to do a pass for a few things: # before we print, we need to do a pass for a few things:
# - find the actual mroot # - find the actual mroot
@@ -1309,8 +1309,8 @@ def main(disk, mroots=None, *,
if args.get('tree') or args.get('btree') else '', if args.get('tree') or args.get('btree') else '',
'%*s %-22s%s' % ( '%*s %-22s%s' % (
w_width, '%d.%d-%d' % ( w_width, '%d.%d-%d' % (
mbid//mweight, rid-(w-1), rid) mbid//mleaf_weight, rid-(w-1), rid)
if w > 1 else '%d.%d' % (mbid//mweight, rid) if w > 1 else '%d.%d' % (mbid//mleaf_weight, rid)
if w > 0 or i == 0 else '', if w > 0 or i == 0 else '',
tagrepr(tag, w, len(data), j), tagrepr(tag, w, len(data), j),
' %s' % next(xxd(data, 8), '') ' %s' % next(xxd(data, 8), '')
@@ -1366,9 +1366,11 @@ def main(disk, mroots=None, *,
treerepr(bid, w, bd, rid, 0, tag) treerepr(bid, w, bd, rid, 0, tag)
if args.get('tree') or args.get('btree') else '', if args.get('tree') or args.get('btree') else '',
w_width, '' if i != 0 w_width, '' if i != 0
else '%d-%d' % ((bid-(w-1))//mweight, bid//mweight) else '%d-%d' % (
if (w//mweight) > 1 (bid-(w-1))//mleaf_weight,
else bid//mweight if w > 0 bid//mleaf_weight)
if (w//mleaf_weight) > 1
else bid//mleaf_weight if w > 0
else '', else '',
tagrepr(tag, w if i == 0 else 0, len(data), None), tagrepr(tag, w if i == 0 else 0, len(data), None),
# note we render names a bit different here # note we render names a bit different here
@@ -1409,10 +1411,10 @@ def main(disk, mroots=None, *,
# print some information about the mtree # print some information about the mtree
print('mtree %s, rev %d, weight %d.%d' % ( print('mtree %s, rev %d, weight %d.%d' % (
mroot.addr(), mroot.rev, bweight//mweight, 1*mweight)) mroot.addr(), mroot.rev, bweight//mleaf_weight, 1*mleaf_weight))
# print header # print header
w_width = (m.ceil(m.log10(max(1, bweight//mweight)+1)) w_width = (m.ceil(m.log10(max(1, bweight//mleaf_weight)+1))
+ 2*m.ceil(m.log10(max(1, rweight)+1)) + 2*m.ceil(m.log10(max(1, rweight)+1))
+ 2) + 2)
print('%-11s %*s%-*s %-22s %s' % ( print('%-11s %*s%-*s %-22s %s' % (
@@ -1603,9 +1605,9 @@ if __name__ == "__main__":
type=lambda x: int(x, 0), type=lambda x: int(x, 0),
help="Block size in bytes.") help="Block size in bytes.")
parser.add_argument( parser.add_argument(
'-M', '--mweight', '-M', '--mleaf-weight',
type=lambda x: int(x, 0), type=lambda x: int(x, 0),
help="Weight of mtree leaves for mid decoding. Defaults to a " help="Maximum weight of mdirs for mid decoding. Defaults to a "
"block_size derived value.") "block_size derived value.")
parser.add_argument( parser.add_argument(
'--color', '--color',
tests/test_alloc.toml
+4 -4
View File
@@ -109,7 +109,7 @@ code = '''
LFSR_ATTR(0, RM, -1, NULL))) => 0; LFSR_ATTR(0, RM, -1, NULL))) => 0;
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0,
&mdir) => 0; &mdir) => 0;
lfs_size_t count = 0; lfs_size_t count = 0;
@@ -146,11 +146,11 @@ code = '''
for (lfs_ssize_t mid = 0; for (lfs_ssize_t mid = 0;
mid < lfs_smax32( mid < lfs_smax32(
lfsr_mtree_weight(&lfs), lfsr_mtree_weight(&lfs),
lfsr_mweight(&lfs)); lfsr_mleafweight(&lfs));
mid += lfsr_mweight(&lfs)) { mid += lfsr_mleafweight(&lfs)) {
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
for (; (mdir.mid & lfsr_mridmask(&lfs)) for (; (mdir.mid & lfsr_midrmask(&lfs))
< (lfs_ssize_t)mdir.u.m.weight; < (lfs_ssize_t)mdir.u.m.weight;
mdir.mid += 1) { mdir.mid += 1) {
uint8_t buffer[4]; uint8_t buffer[4];
tests/test_mtree.toml
+263 -263
View File
File diff suppressed because it is too large Load Diff