Github/littlefs
1
Fork 0
Code Actions Activity

Renamed left/right -> l/r

Browse Source
This commit is contained in:
Christopher Haster
2025-02-11 03:05:39 -06:00
parent eaf24b81be
commit 2a3705dca0
1 changed files with 35 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+35 -35
View File
@@ -8258,22 +8258,22 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
// order the split compacts so that that mdir containing our mid // order the split compacts so that that mdir containing our mid
// is committed last, this is a bit of a hack but necessary so // is committed last, this is a bit of a hack but necessary so
// shrubs are staged correctly // shrubs are staged correctly
bool left = lfsr_mid_rid(lfs, mdir->mid) < split_rid; bool l = lfsr_mid_rid(lfs, mdir->mid) < split_rid;
bool relocated = false;; bool relocated = false;;
split_relocate:; split_relocate:;
// alloc and compact into new mdirs // alloc and compact into new mdirs
err = lfsr_mdir_alloc__(lfs, &mdir_[i^left], err = lfsr_mdir_alloc__(lfs, &mdir_[i^l],
lfs_smax(mdir->mid, 0), relocated); lfs_smax(mdir->mid, 0), relocated);
if (err) { if (err) {
goto failed; goto failed;
} }
relocated = true; relocated = true;
err = lfsr_mdir_compact__(lfs, &mdir_[i^left], err = lfsr_mdir_compact__(lfs, &mdir_[i^l],
mdir, mdir,
((i^left) == 0) ? 0 : split_rid, ((i^l) == 0) ? 0 : split_rid,
((i^left) == 0) ? split_rid : -1); ((i^l) == 0) ? split_rid : -1);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
// bad prog? try another block // bad prog? try another block
@@ -8283,9 +8283,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
goto failed; goto failed;
} }
err = lfsr_mdir_commit__(lfs, &mdir_[i^left], err = lfsr_mdir_commit__(lfs, &mdir_[i^l],
((i^left) == 0) ? 0 : split_rid, ((i^l) == 0) ? 0 : split_rid,
((i^left) == 0) ? split_rid : -1, ((i^l) == 0) ? split_rid : -1,
mdir->mid, rattrs, rattr_count); mdir->mid, rattrs, rattr_count);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -8297,7 +8297,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir,
} }
// empty? set weight to zero // empty? set weight to zero
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
mdir_[i^left].rbyd.weight = 0; mdir_[i^l].rbyd.weight = 0;
} }
} }
@@ -11386,8 +11386,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
lfsr_bid_t bid = file->b.shrub.weight; lfsr_bid_t bid = file->b.shrub.weight;
lfsr_rattr_t rattrs[5]; lfsr_rattr_t rattrs[5];
lfs_size_t rattr_count = 0; lfs_size_t rattr_count = 0;
lfsr_bptr_t left; lfsr_bptr_t l;
lfsr_bptr_t right; lfsr_bptr_t r;
// need a hole? // need a hole?
if (pos > file->b.shrub.weight) { if (pos > file->b.shrub.weight) {
@@ -11408,7 +11408,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
} }
// try to carve any existing data // try to carve any existing data
lfsr_rattr_t right_rattr_ = {.tag=0}; lfsr_rattr_t r_rattr_ = {.tag=0};
while (pos < file->b.shrub.weight) { while (pos < file->b.shrub.weight) {
lfsr_bid_t weight_; lfsr_bid_t weight_;
lfsr_bptr_t bptr_; lfsr_bptr_t bptr_;
@@ -11431,20 +11431,20 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
#endif #endif
// note, an entry can be both a left and right sibling // note, an entry can be both a left and right sibling
left = bptr_; l = bptr_;
left.data = LFSR_DATA_SLICE(bptr_.data, l.data = LFSR_DATA_SLICE(bptr_.data,
-1, -1,
pos - (bid-(weight_-1))); pos - (bid-(weight_-1)));
right = bptr_; r = bptr_;
right.data = LFSR_DATA_SLICE(bptr_.data, r.data = LFSR_DATA_SLICE(bptr_.data,
pos+weight - (bid-(weight_-1)), pos+weight - (bid-(weight_-1)),
-1); -1);
// left sibling needs carving but falls underneath our // left sibling needs carving but falls underneath our
// crystallization threshold? break into fragments // crystallization threshold? break into fragments
while (lfsr_bptr_isbptr(&bptr_) while (lfsr_bptr_isbptr(&bptr_)
&& lfsr_data_size(left.data) > lfs->cfg->fragment_size && lfsr_data_size(l.data) > lfs->cfg->fragment_size
&& lfsr_data_size(left.data) < lfs->cfg->crystal_thresh) { && lfsr_data_size(l.data) < lfs->cfg->crystal_thresh) {
bptr_.data = LFSR_DATA_SLICE(bptr_.data, bptr_.data = LFSR_DATA_SLICE(bptr_.data,
lfs->cfg->fragment_size, lfs->cfg->fragment_size,
-1); -1);
@@ -11453,7 +11453,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
LFSR_RATTR_DATA( LFSR_RATTR_DATA(
LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
-(weight_ - lfs->cfg->fragment_size), -(weight_ - lfs->cfg->fragment_size),
&LFSR_DATA_TRUNCATE(left.data, &LFSR_DATA_TRUNCATE(l.data,
lfs->cfg->fragment_size)), lfs->cfg->fragment_size)),
LFSR_RATTR( LFSR_RATTR(
LFSR_TAG_BLOCK, LFSR_TAG_BLOCK,
@@ -11464,7 +11464,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
} }
weight_ -= lfs->cfg->fragment_size; weight_ -= lfs->cfg->fragment_size;
left.data = LFSR_DATA_SLICE(bptr_.data, l.data = LFSR_DATA_SLICE(bptr_.data,
-1, -1,
pos - (bid-(weight_-1))); pos - (bid-(weight_-1)));
} }
@@ -11472,8 +11472,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
// right sibling needs carving but falls underneath our // right sibling needs carving but falls underneath our
// crystallization threshold? break into fragments // crystallization threshold? break into fragments
while (lfsr_bptr_isbptr(&bptr_) while (lfsr_bptr_isbptr(&bptr_)
&& lfsr_data_size(right.data) > lfs->cfg->fragment_size && lfsr_data_size(r.data) > lfs->cfg->fragment_size
&& lfsr_data_size(right.data) < lfs->cfg->crystal_thresh) { && lfsr_data_size(r.data) < lfs->cfg->crystal_thresh) {
bptr_.data = LFSR_DATA_SLICE(bptr_.data, bptr_.data = LFSR_DATA_SLICE(bptr_.data,
-1, -1,
lfsr_data_size(bptr_.data) - lfs->cfg->fragment_size); lfsr_data_size(bptr_.data) - lfs->cfg->fragment_size);
@@ -11486,7 +11486,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
LFSR_RATTR_DATA( LFSR_RATTR_DATA(
LFSR_TAG_DATA, LFSR_TAG_DATA,
+(weight_ - lfsr_data_size(bptr_.data)), +(weight_ - lfsr_data_size(bptr_.data)),
&LFSR_DATA_FRUNCATE(right.data, &LFSR_DATA_FRUNCATE(r.data,
lfs->cfg->fragment_size)))); lfs->cfg->fragment_size))));
if (err) { if (err) {
return err; return err;
@@ -11494,7 +11494,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
bid -= (weight_-lfsr_data_size(bptr_.data)); bid -= (weight_-lfsr_data_size(bptr_.data));
weight_ -= (weight_-lfsr_data_size(bptr_.data)); weight_ -= (weight_-lfsr_data_size(bptr_.data));
right.data = LFSR_DATA_SLICE(bptr_.data, r.data = LFSR_DATA_SLICE(bptr_.data,
pos+weight - (bid-(weight_-1)), pos+weight - (bid-(weight_-1)),
-1); -1);
} }
@@ -11502,7 +11502,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
// found left sibling? // found left sibling?
if (bid-(weight_-1) < pos) { if (bid-(weight_-1) < pos) {
// can we get away with a grow attribute? // can we get away with a grow attribute?
if (lfsr_data_size(bptr_.data) == lfsr_data_size(left.data)) { if (lfsr_data_size(bptr_.data) == lfsr_data_size(l.data)) {
rattrs[rattr_count++] = LFSR_RATTR( rattrs[rattr_count++] = LFSR_RATTR(
LFSR_TAG_GROW, -(bid+1 - pos), NULL, 0); LFSR_TAG_GROW, -(bid+1 - pos), NULL, 0);
@@ -11511,14 +11511,14 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
rattrs[rattr_count++] = LFSR_RATTR_DATA( rattrs[rattr_count++] = LFSR_RATTR_DATA(
LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA,
-(bid+1 - pos), -(bid+1 - pos),
&left.data); &l.data);
// carve bptr? // carve bptr?
} else { } else {
rattrs[rattr_count++] = LFSR_RATTR( rattrs[rattr_count++] = LFSR_RATTR(
LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK, LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK,
-(bid+1 - pos), -(bid+1 - pos),
&left, LFSR_BPTR_DSIZE); &l, LFSR_BPTR_DSIZE);
} }
// completely overwriting this entry? // completely overwriting this entry?
@@ -11530,7 +11530,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
// spans more than one entry? we can't do everything in one commit, // spans more than one entry? we can't do everything in one commit,
// so commit what we have and move on to next entry // so commit what we have and move on to next entry
if (pos+weight > bid+1) { if (pos+weight > bid+1) {
LFS_ASSERT(lfsr_data_size(right.data) == 0); LFS_ASSERT(lfsr_data_size(r.data) == 0);
LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t));
err = lfsr_file_commit(lfs, file, bid, err = lfsr_file_commit(lfs, file, bid,
@@ -11548,20 +11548,20 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
// found right sibling? // found right sibling?
if (pos+weight < bid+1) { if (pos+weight < bid+1) {
// can we coalesce a hole? // can we coalesce a hole?
if (lfsr_data_size(right.data) == 0) { if (lfsr_data_size(r.data) == 0) {
rattr.weight += bid+1 - (pos+weight); rattr.weight += bid+1 - (pos+weight);
// carve fragment? // carve fragment?
} else if (!lfsr_bptr_isbptr(&bptr_)) { } else if (!lfsr_bptr_isbptr(&bptr_)) {
right_rattr_ = LFSR_RATTR_DATA( r_rattr_ = LFSR_RATTR_DATA(
LFSR_TAG_DATA, bid+1 - (pos+weight), LFSR_TAG_DATA, bid+1 - (pos+weight),
&right.data); &r.data);
// carve bptr? // carve bptr?
} else { } else {
right_rattr_ = LFSR_RATTR( r_rattr_ = LFSR_RATTR(
LFSR_TAG_BLOCK, bid+1 - (pos+weight), LFSR_TAG_BLOCK, bid+1 - (pos+weight),
&right, LFSR_BPTR_DSIZE); &r, LFSR_BPTR_DSIZE);
} }
} }
@@ -11596,8 +11596,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file,
} }
// and don't forget the right sibling // and don't forget the right sibling
if (right_rattr_.tag) { if (r_rattr_.tag) {
rattrs[rattr_count++] = right_rattr_; rattrs[rattr_count++] = r_rattr_;
} }
// commit pending rattrs // commit pending rattrs