Github/littlefs
1
Fork 0
Code Actions Activity

Added lfsr_obshrub_t for generalized tracked bshrubs

Browse Source 
So now files and traversals contain several nested structs:

  file     <-- lfsr_file_t
  file.o   <-- lfsr_obshrub_t
  file.o.o <-- lfsr_omdir_t

This gets a bit ugly, but it's really the only way to make the compiler
happy when also with C's annoying strict aliasing rules.

This also makes lfsr_traversal_t a simple alias of lfsr_mtraversal_t,
with lfsr_mtraversal_t now including all of the obshrub/omdir state.
This simplifies things internally, and allows lfsr_mtree_gc to assert on
opened-list enrollment, but risks increased stack cost for all of the
unused fields.

Fortunately this stack cost turned out to not be that significant:

           code          stack
  before: 35264           2680 (+0.0%)
  after:  35256 (-0.0%)   2688 (+0.3%)
This commit is contained in:
Christopher Haster
2024-07-03 15:57:59 -05:00
parent 8d7e71d961
commit c316270ebb
5 changed files with 487 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+407 -391
View File
File diff suppressed because it is too large Load Diff
lfs.h
+17 -16
View File
@@ -485,6 +485,7 @@ typedef struct lfsr_mdir {
typedef struct lfsr_omdir { typedef struct lfsr_omdir {
struct lfsr_omdir *next; struct lfsr_omdir *next;
uint8_t type; uint8_t type;
uint8_t state;
uint16_t flags; uint16_t flags;
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
} lfsr_omdir_t; } lfsr_omdir_t;
@@ -565,14 +566,19 @@ typedef struct lfsr_bshrub {
} u; } u;
} lfsr_bshrub_t; } lfsr_bshrub_t;
typedef struct lfsr_file { typedef struct lfsr_obshrub {
// bshrubs need to be tracked for commits to work
lfsr_omdir_t o; lfsr_omdir_t o;
const struct lfs_file_config *cfg;
// files contain both an active bshrub and staging bshrub, to allow // files contain both an active bshrub and staging bshrub, to allow
// staging during mdir compacts // staging during mdir compacts
lfsr_bshrub_t bshrub; lfsr_bshrub_t bshrub;
lfsr_bshrub_t bshrub_; lfsr_bshrub_t bshrub_;
} lfsr_obshrub_t;
typedef struct lfsr_file {
lfsr_obshrub_t o;
const struct lfs_file_config *cfg;
lfs_off_t pos; lfs_off_t pos;
// note this lines up with lfsr_data_t's buffer representation // note this lines up with lfsr_data_t's buffer representation
@@ -614,15 +620,10 @@ typedef struct lfsr_btraversal {
} lfsr_btraversal_t; } lfsr_btraversal_t;
typedef struct lfsr_mtraversal { typedef struct lfsr_mtraversal {
// mdir/btree state, this also includes our traversal state machine
lfsr_obshrub_t o;
// opened file state // opened file state
lfsr_omdir_t *o; lfsr_omdir_t *ot;
// bshrub/btree state
// this lines up with bshrub/btree in lfsr_file_t
lfsr_bshrub_t bshrub;
lfsr_bshrub_t bshrub_;
// core state machine
uint8_t state;
uint16_t flags;
union { union {
// cycle detection state, only valid when traversing the mroot chain // cycle detection state, only valid when traversing the mroot chain
struct { struct {
@@ -633,13 +634,13 @@ typedef struct lfsr_mtraversal {
// btree traversal state // btree traversal state
lfsr_btraversal_t bt; lfsr_btraversal_t bt;
} u; } u;
// pending blocks, only used in lfsr_traversal_read
lfs_sblock_t blocks[2];
} lfsr_mtraversal_t; } lfsr_mtraversal_t;
typedef struct lfsr_traversal { typedef lfsr_mtraversal_t lfsr_traversal_t;
lfsr_omdir_t o;
lfsr_mtraversal_t mt;
lfs_sblock_t blocks[2];
} lfsr_traversal_t;
//typedef struct lfs_superblock { //typedef struct lfs_superblock {
// uint32_t version; // uint32_t version;
tests/test_alloc.toml
+3 -6
View File
@@ -163,7 +163,6 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8); uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL( lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
(CKMETA) ? LFS_T_CKMETA : 0); (CKMETA) ? LFS_T_CKMETA : 0);
for (lfs_block_t i = 0;; i++) { for (lfs_block_t i = 0;; i++) {
@@ -171,7 +170,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -332,7 +331,6 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8); uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL( lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
((CKMETA) ? LFS_T_CKMETA : 0)); ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) { for (lfs_block_t i = 0;; i++) {
@@ -340,7 +338,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -487,7 +485,6 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8); uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL( lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
((CKMETA) ? LFS_T_CKMETA : 0)); ((CKMETA) ? LFS_T_CKMETA : 0));
for (lfs_block_t i = 0;; i++) { for (lfs_block_t i = 0;; i++) {
@@ -495,7 +492,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
tests/test_mtree.toml
+10 -11
View File
@@ -3370,7 +3370,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -3485,7 +3485,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -3622,7 +3622,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -3780,7 +3780,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -3922,7 +3922,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -4031,7 +4031,6 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8); uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL( lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
LFS_T_MTREEONLY LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0)); | ((CKMETA) ? LFS_T_CKMETA : 0));
@@ -4040,7 +4039,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -4088,6 +4087,7 @@ code = '''
// and the tree should still work // and the tree should still work
// try looking up each entry // try looking up each entry
lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_data_t data; lfsr_data_t data;
uint8_t buffer[256]; uint8_t buffer[256];
@@ -4190,7 +4190,6 @@ code = '''
uint8_t *seen = malloc((BLOCK_COUNT+7)/8); uint8_t *seen = malloc((BLOCK_COUNT+7)/8);
memset(seen, 0, (BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8);
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL( lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
LFS_T_MTREEONLY LFS_T_MTREEONLY
| ((CKMETA) ? LFS_T_CKMETA : 0)); | ((CKMETA) ? LFS_T_CKMETA : 0));
@@ -4199,7 +4198,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -4247,6 +4246,7 @@ code = '''
// and the tree should still work // and the tree should still work
// try looking up each entry // try looking up each entry
lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_data_t data; lfsr_data_t data;
uint8_t buffer[256]; uint8_t buffer[256];
@@ -4313,7 +4313,6 @@ code = '''
LFSR_DATA_MPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0; LFSR_DATA_MPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0;
// technically, cycle detection only needs to work when we're validating // technically, cycle detection only needs to work when we're validating
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL( lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(
LFS_T_MTREEONLY | LFS_T_CKMETA); LFS_T_MTREEONLY | LFS_T_CKMETA);
for (lfs_block_t i = 0;; i++) { for (lfs_block_t i = 0;; i++) {
@@ -4321,7 +4320,7 @@ code = '''
assert(i < 2*BLOCK_COUNT); assert(i < 2*BLOCK_COUNT);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_CORRUPT); assert(!err || err == LFS_ERR_CORRUPT);
if (err == LFS_ERR_CORRUPT) { if (err == LFS_ERR_CORRUPT) {
break; break;
tests/test_traversal.toml
+50 -60
View File
@@ -5224,7 +5224,7 @@ code = '''
// hack, don't use the internals like this // hack, don't use the internals like this
uint8_t wbuf[SIZE]; uint8_t wbuf[SIZE];
while ((file.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_rewind(&lfs, &file) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5252,7 +5252,7 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mdir should have been compacted // mdir should have been compacted
assert((file.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the file // check we can still read the file
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -5296,7 +5296,7 @@ code = '''
// hack, don't use the internals like this // hack, don't use the internals like this
uint8_t wbuf[SIZE]; uint8_t wbuf[SIZE];
while ((file.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_rewind(&lfs, &file) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5320,7 +5320,7 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mdir should have been compacted // mdir should have been compacted
assert((file.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the file // check we can still read the file
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -5466,7 +5466,7 @@ code = '''
// hack, don't use the internals like this // hack, don't use the internals like this
uint8_t wbuf[SIZE]; uint8_t wbuf[SIZE];
while ((file.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_rewind(&lfs, &file) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5496,7 +5496,7 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mdir should have been compacted // mdir should have been compacted
assert((file.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the file // check we can still read the file
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -5559,10 +5559,10 @@ code = '''
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs, lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs,
&file1.o.mdir, -1, -1, &file1.o.o.mdir, -1, -1,
NULL); NULL);
assert(estimate >= 0); assert(estimate >= 0);
if ((file1.o.mdir.rbyd.eoff & 0x7fffffff) > GC_COMPACT_THRESH if ((file1.o.o.mdir.rbyd.eoff & 0x7fffffff) > GC_COMPACT_THRESH
&& estimate > BLOCK_SIZE/2) { && estimate > BLOCK_SIZE/2) {
break; break;
} }
@@ -5608,8 +5608,8 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mdirs should have been compacted // mdirs should have been compacted
assert((file1.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file1.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
assert((file2.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file2.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the files // check we can still read the files
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -5711,7 +5711,7 @@ code = '''
// write to each file until mdir >gc_compact_thresh full // write to each file until mdir >gc_compact_thresh full
if (COMPACTSET & 0x1) { if (COMPACTSET & 0x1) {
// hack, don't use the internals like this // hack, don't use the internals like this
while ((file1.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file1.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file1) => 0; lfsr_file_rewind(&lfs, &file1) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5723,7 +5723,7 @@ code = '''
if (COMPACTSET & 0x2) { if (COMPACTSET & 0x2) {
// hack, don't use the internals like this // hack, don't use the internals like this
while ((file2.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file2.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file2) => 0; lfsr_file_rewind(&lfs, &file2) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5735,7 +5735,7 @@ code = '''
if (COMPACTSET & 0x4) { if (COMPACTSET & 0x4) {
// hack, don't use the internals like this // hack, don't use the internals like this
while ((file3.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file3.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file3) => 0; lfsr_file_rewind(&lfs, &file3) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -5782,9 +5782,9 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mdirs should have been compacted // mdirs should have been compacted
assert((file1.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file1.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
assert((file2.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file2.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
assert((file3.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file3.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the files // check we can still read the files
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -5905,10 +5905,10 @@ code = '''
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs, lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs,
&file2.o.mdir, -1, -1, &file2.o.o.mdir, -1, -1,
NULL); NULL);
assert(estimate >= 0); assert(estimate >= 0);
if ((file2.o.mdir.rbyd.eoff & 0x7fffffff) > GC_COMPACT_THRESH if ((file2.o.o.mdir.rbyd.eoff & 0x7fffffff) > GC_COMPACT_THRESH
&& estimate > BLOCK_SIZE/2) { && estimate > BLOCK_SIZE/2) {
break; break;
} }
@@ -5964,10 +5964,10 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mdirs should have been compacted // mdirs should have been compacted
assert((file1.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file1.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
assert((file2.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file2.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
assert((file3.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file3.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
assert((file4.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file4.o.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the files // check we can still read the files
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -6075,13 +6075,12 @@ code = '''
// rewrite a file until btree is >gc_compact_thresh full // rewrite a file until btree is >gc_compact_thresh full
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfsr_mdir_t mdir;
// ckmeta needed for eoff // ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_BRANCH); assert(mtinfo.tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) { if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) {
break; break;
@@ -6135,12 +6134,11 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// mtree should have been compacted // mtree should have been compacted
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_BRANCH); assert(mtinfo.tag == LFSR_TAG_BRANCH);
assert(lfsr_rbyd_eoff(&mtinfo.u.rbyd) <= GC_COMPACT_THRESH); assert(lfsr_rbyd_eoff(&mtinfo.u.rbyd) <= GC_COMPACT_THRESH);
@@ -6196,7 +6194,7 @@ code = '''
// rewrite our file until btree is >gc_compact_thresh full // rewrite our file until btree is >gc_compact_thresh full
uint8_t wbuf[SIZE]; uint8_t wbuf[SIZE];
while ((file.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_rewind(&lfs, &file) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6229,7 +6227,7 @@ code = '''
// btree should have been compacted // btree should have been compacted
lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0;
assert((file.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the file // check we can still read the file
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -6276,7 +6274,7 @@ code = '''
// rewrite our file until btree is >gc_compact_thresh full // rewrite our file until btree is >gc_compact_thresh full
uint8_t wbuf[SIZE]; uint8_t wbuf[SIZE];
while ((file.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_rewind(&lfs, &file) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6308,7 +6306,7 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// btree should have been compacted // btree should have been compacted
assert((file.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the file // check we can still read the file
for (int remount = 0; remount < 2; remount++) { for (int remount = 0; remount < 2; remount++) {
@@ -6355,7 +6353,7 @@ code = '''
// rewrite our file until btree is >gc_compact_thresh full // rewrite our file until btree is >gc_compact_thresh full
uint8_t wbuf[SIZE]; uint8_t wbuf[SIZE];
while ((file.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file) => 0; lfsr_file_rewind(&lfs, &file) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6385,7 +6383,7 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// btree should have been compacted // btree should have been compacted
assert((file.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// file should not have accidentally been created or anything // file should not have accidentally been created or anything
struct lfs_info info; struct lfs_info info;
@@ -6436,7 +6434,7 @@ code = '''
// rewrite our file until btree is >gc_compact_thresh full // rewrite our file until btree is >gc_compact_thresh full
uint8_t wbuf1[SIZE]; uint8_t wbuf1[SIZE];
while ((file1.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { while ((file1.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) {
lfsr_file_rewind(&lfs, &file1) => 0; lfsr_file_rewind(&lfs, &file1) => 0;
for (lfs_size_t j = 0; j < SIZE; j++) { for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26);
@@ -6493,7 +6491,7 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// btree should have been compacted // btree should have been compacted
assert((file1.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file1.o.bshrub.u.btree.eoff & 0x7fffffff) <= GC_COMPACT_THRESH);
// check we can still read the files // check we can still read the files
lfsr_file_rewind(&lfs, &file1) => 0; lfsr_file_rewind(&lfs, &file1) => 0;
@@ -6555,13 +6553,12 @@ code = '''
// rewrite part of our file until bshrub is >gc_compact_thresh full // rewrite part of our file until bshrub is >gc_compact_thresh full
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfsr_mdir_t mdir;
// ckmeta needed for eoff // ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_BRANCH); assert(mtinfo.tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) { if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) {
break; break;
@@ -6602,13 +6599,12 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted // bshrub should have been compacted
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
while (true) { while (true) {
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -6670,13 +6666,12 @@ code = '''
// rewrite part of our file until bshrub is >gc_compact_thresh full // rewrite part of our file until bshrub is >gc_compact_thresh full
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfsr_mdir_t mdir;
// ckmeta needed for eoff // ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_BRANCH); assert(mtinfo.tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) { if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) {
break; break;
@@ -6717,13 +6712,12 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted // bshrub should have been compacted
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
while (true) { while (true) {
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -6786,13 +6780,12 @@ code = '''
// rewrite part of our file until bshrub is >gc_compact_thresh full // rewrite part of our file until bshrub is >gc_compact_thresh full
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfsr_mdir_t mdir;
// ckmeta needed for eoff // ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_BRANCH); assert(mtinfo.tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) { if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) {
break; break;
@@ -6831,13 +6824,12 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted // bshrub should have been compacted
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
while (true) { while (true) {
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;
@@ -6900,13 +6892,12 @@ code = '''
// rewrite part of our file until bshrub is >gc_compact_thresh full // rewrite part of our file until bshrub is >gc_compact_thresh full
while (true) { while (true) {
// we need internals to check this // we need internals to check this
lfsr_mdir_t mdir;
// ckmeta needed for eoff // ckmeta needed for eoff
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_BRANCH); assert(mtinfo.tag == LFSR_TAG_BRANCH);
if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) { if (lfsr_rbyd_eoff(&mtinfo.u.rbyd) > GC_COMPACT_THRESH) {
break; break;
@@ -6966,13 +6957,12 @@ code = '''
lfsr_traversal_close(&lfs, &t) => 0; lfsr_traversal_close(&lfs, &t) => 0;
// bshrub should have been compacted // bshrub should have been compacted
lfsr_mdir_t mdir;
lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA); lfsr_mtraversal_t mt = LFSR_MTRAVERSAL(LFS_T_CKMETA);
lfsr_mtinfo_t mtinfo; lfsr_mtinfo_t mtinfo;
lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo) => 0; lfsr_mtree_traverse(&lfs, &mt, &mtinfo) => 0;
assert(mtinfo.tag == LFSR_TAG_MDIR); assert(mtinfo.tag == LFSR_TAG_MDIR);
while (true) { while (true) {
int err = lfsr_mtree_traverse(&lfs, &mdir, &mt, &mtinfo); int err = lfsr_mtree_traverse(&lfs, &mt, &mtinfo);
assert(!err || err == LFS_ERR_NOENT); assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
break; break;