From 6eba1180c848f73d3ca3537f589c8d5ff183a974 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Wed, 28 May 2025 15:00:04 -0500 Subject: [PATCH] Big rename! Renamed lfs -> lfs3 and lfsr -> lfs3 --- .gitignore | 22 +- Makefile | 138 +- bd/{lfs_emubd.c => lfs3_emubd.c} | 677 +- bd/lfs3_emubd.h | 265 + bd/{lfs_filebd.c => lfs3_filebd.c} | 84 +- bd/lfs3_filebd.h | 56 + bd/lfs3_rambd.c | 131 + bd/lfs3_rambd.h | 65 + bd/lfs_emubd.h | 262 - bd/lfs_filebd.h | 56 - bd/lfs_rambd.c | 131 - bd/lfs_rambd.h | 65 - lfs.c => lfs3.c | 10422 +++++++++--------- lfs.h => lfs3.h | 845 +- lfs_util.c => lfs3_util.c | 86 +- lfs_util.h => lfs3_util.h | 422 +- runners/bench_runner.c | 50 +- runners/bench_runner.h | 26 +- runners/test_runner.c | 152 +- runners/test_runner.h | 26 +- scripts/bench.py | 4 +- scripts/dbgbmap.py | 10 +- scripts/dbgbmapsvg.py | 10 +- scripts/dbgerr.py | 8 +- scripts/dbgflags.py | 44 +- scripts/{dbglfs.py => dbglfs3.py} | 16 +- scripts/test.py | 4 +- tests/test_alloc.toml | 480 +- tests/test_attrs.toml | 2626 ++--- tests/test_badblocks.toml | 3184 +++--- tests/test_bd.toml | 118 +- tests/test_btree.toml | 3674 +++---- tests/test_ck.toml | 3114 +++--- tests/test_compat.toml | 728 +- tests/test_dirs.toml | 5974 +++++------ tests/test_dread.toml | 1278 +-- tests/test_exhaustion.toml | 854 +- tests/test_files.toml | 2373 ++--- tests/test_fsync.toml | 5274 +++++----- tests/test_fwrite.toml | 3490 +++--- tests/test_gc.toml | 2488 ++--- tests/test_grow.toml | 1874 ++-- tests/test_mount.toml | 1985 ++-- tests/test_mtree.toml | 4295 ++++---- tests/test_paths.toml | 12160 ++++++++++----------- tests/test_powerloss.toml | 572 +- tests/test_rbyd.toml | 15221 ++++++++++++++------------- tests/test_relocations.toml | 1072 +- tests/test_stickynotes.toml | 8920 ++++++++-------- tests/test_traversal.toml | 8558 +++++++-------- 50 files changed, 52278 insertions(+), 52111 deletions(-) rename bd/{lfs_emubd.c => lfs3_emubd.c} (59%) create mode 100644 bd/lfs3_emubd.h rename bd/{lfs_filebd.c => lfs3_filebd.c} (53%) create mode 100644 bd/lfs3_filebd.h create mode 100644 bd/lfs3_rambd.c create mode 100644 bd/lfs3_rambd.h delete mode 100644 bd/lfs_emubd.h delete mode 100644 bd/lfs_filebd.h delete mode 100644 bd/lfs_rambd.c delete mode 100644 bd/lfs_rambd.h rename lfs.c => lfs3.c (50%) rename lfs.h => lfs3.h (55%) rename lfs_util.c => lfs3_util.c (80%) rename lfs_util.h => lfs3_util.h (52%) rename scripts/{dbglfs.py => dbglfs3.py} (99%) diff --git a/.gitignore b/.gitignore index e43d5fef..e9938232 100644 --- a/.gitignore +++ b/.gitignore @@ -9,21 +9,21 @@ *.gcno *.gcda *.perf -lfs -liblfs.a +lfs3 +liblfs3.a # Testing things runners/test_runner runners/bench_runner -lfs.code.csv -lfs.data.csv -lfs.stack.csv -lfs.structs.csv -lfs.cov.csv -lfs.perf.csv -lfs.perfbd.csv -lfs.test.csv -lfs.bench.csv +lfs3.code.csv +lfs3.data.csv +lfs3.stack.csv +lfs3.structs.csv +lfs3.cov.csv +lfs3.perf.csv +lfs3.perfbd.csv +lfs3.test.csv +lfs3.bench.csv # Misc tags diff --git a/Makefile b/Makefile index 96194687..40ed3726 100644 --- a/Makefile +++ b/Makefile @@ -2,9 +2,9 @@ BUILDDIR ?= . # overrideable target, default to building a library ifneq ($(wildcard test.c main.c),) -TARGET ?= $(BUILDDIR)/lfs +TARGET ?= $(BUILDDIR)/lfs3 else -TARGET ?= $(BUILDDIR)/liblfs.a +TARGET ?= $(BUILDDIR)/liblfs3.a endif @@ -82,7 +82,7 @@ else CFLAGS += -Os endif ifdef TRACE -CFLAGS += -DLFS_YES_TRACE +CFLAGS += -DLFS3_YES_TRACE endif ifdef COVGEN CFLAGS += --coverage @@ -94,8 +94,8 @@ ifdef PERFBDGEN CFLAGS += -fno-omit-frame-pointer endif -# also forward all LFS_* environment variables -CFLAGS += $(foreach D,$(filter LFS_%,$(.VARIABLES)),-D$D=$($D)) +# also forward all LFS3_* environment variables +CFLAGS += $(foreach D,$(filter LFS3_%,$(.VARIABLES)),-D$D=$($D)) TEST_CFLAGS += -Wno-unused-function TEST_CFLAGS += -Wno-format-overflow @@ -231,12 +231,12 @@ code: $(OBJ) ## Save the per-function code size .PHONY: code-csv -code-csv: $(BUILDDIR)/lfs.code.csv +code-csv: $(BUILDDIR)/lfs3.code.csv ## Compare per-function code size .PHONY: code-diff code-diff: $(OBJ) - ./scripts/code.py $^ $(CODEFLAGS) -d $(BUILDDIR)/lfs.code.csv + ./scripts/code.py $^ $(CODEFLAGS) -d $(BUILDDIR)/lfs3.code.csv ## Find the per-function data size .PHONY: data @@ -246,12 +246,12 @@ data: $(OBJ) ## Save the per-function data size .PHONY: data-csv -data-csv: $(BUILDDIR)/lfs.data.csv +data-csv: $(BUILDDIR)/lfs3.data.csv ## Compare per-function data size .PHONY: data-diff data-diff: $(OBJ) - ./scripts/data.py $^ $(DATAFLAGS) -d $(BUILDDIR)/lfs.data.csv + ./scripts/data.py $^ $(DATAFLAGS) -d $(BUILDDIR)/lfs3.data.csv ## Find the per-function stack usage .PHONY: stack @@ -261,12 +261,12 @@ stack: $(CI) ## Save the per-function stack usage .PHONY: stack-csv -stack-csv: $(BUILDDIR)/lfs.stack.csv +stack-csv: $(BUILDDIR)/lfs3.stack.csv ## Compare per-function stack usage .PHONY: stack-diff stack-diff: $(CI) - ./scripts/stack.py $^ $(STACKFLAGS) -d $(BUILDDIR)/lfs.stack.csv + ./scripts/stack.py $^ $(STACKFLAGS) -d $(BUILDDIR)/lfs3.stack.csv ## Find the per-function context .PHONY: ctx @@ -276,12 +276,12 @@ ctx: $(OBJ) ## Save the per-function context .PHONY: ctx-csv -ctx-csv: $(BUILDDIR)/lfs.ctx.csv +ctx-csv: $(BUILDDIR)/lfs3.ctx.csv ## Compare per-function context .PHONY: ctx-diff ctx-diff: $(CI) - ./scripts/ctx.py $^ $(CTXFLAGS) -d $(BUILDDIR)/lfs.ctx.csv + ./scripts/ctx.py $^ $(CTXFLAGS) -d $(BUILDDIR)/lfs3.ctx.csv ## Find function sizes .PHONY: funcs @@ -302,9 +302,9 @@ funcs: $(OBJ) $(CI) .PHONY: funcs-csv funcs-csv: SHELL=/bin/bash funcs-csv: \ - $(BUILDDIR)/lfs.code.csv \ - $(BUILDDIR)/lfs.stack.csv \ - $(BUILDDIR)/lfs.ctx.csv + $(BUILDDIR)/lfs3.code.csv \ + $(BUILDDIR)/lfs3.stack.csv \ + $(BUILDDIR)/lfs3.ctx.csv ## Compare function sizes .PHONY: funcs-diff @@ -319,9 +319,9 @@ funcs-diff: $(OBJ) $(CI) -fstack='max(stack_limit)' \ -fctx='max(ctx_size)' \ -d <(./scripts/csv.py \ - $(BUILDDIR)/lfs.code.csv \ - $(BUILDDIR)/lfs.stack.csv \ - $(BUILDDIR)/lfs.ctx.csv \ + $(BUILDDIR)/lfs3.code.csv \ + $(BUILDDIR)/lfs3.stack.csv \ + $(BUILDDIR)/lfs3.ctx.csv \ -fcode_size=code_size \ -fstack_limit='max(stack_limit)' \ -fctx_size='max(ctx_size)' \ @@ -336,12 +336,12 @@ structs: $(OBJ) ## Save struct sizes .PHONY: structs-csv -structs-csv: $(BUILDDIR)/lfs.structs.csv +structs-csv: $(BUILDDIR)/lfs3.structs.csv ## Compare struct sizes .PHONY: structs-diff structs-diff: $(OBJ) - ./scripts/structs.py $^ $(STRUCTSFLAGS) -d $(BUILDDIR)/lfs.structs.csv + ./scripts/structs.py $^ $(STRUCTSFLAGS) -d $(BUILDDIR)/lfs3.structs.csv ## Find the line/branch coverage after a test run .PHONY: cov @@ -353,14 +353,14 @@ cov: $(GCDA) ## Save line/branch coverage .PHONY: cov-csv -cov-csv: $(BUILDDIR)/lfs.cov.csv +cov-csv: $(BUILDDIR)/lfs3.cov.csv ## Compare line/branch coverage .PHONY: cov-diff cov-diff: $(GCDA) $(strip ./scripts/cov.py $^ \ $(patsubst %,-F%,$(SRC)) \ - $(COVFLAGS) -d $(BUILDDIR)/lfs.cov.csv) + $(COVFLAGS) -d $(BUILDDIR)/lfs3.cov.csv) ## Find the perf results after bench run with PERFGEN .PHONY: perf @@ -372,14 +372,14 @@ perf: $(BENCH_PERF) ## Save perf results .PHONY: perf-csv -perf-csv: $(BUILDDIR)/lfs.perf.csv +perf-csv: $(BUILDDIR)/lfs3.perf.csv ## Compare perf results .PHONY: perf-diff perf-diff: $(BENCH_PERF) $(strip ./scripts/perf.py $^ \ $(patsubst %,-F%,$(SRC)) \ - $(PERFFLAGS) -d $(BUILDDIR)/lfs.perf.csv) + $(PERFFLAGS) -d $(BUILDDIR)/lfs3.perf.csv) ## Find the perfbd results after a bench run .PHONY: perfbd @@ -391,14 +391,14 @@ perfbd: $(BENCH_TRACE) ## Save perfbd results .PHONY: perfbd-csv -perfbd-csv: $(BUILDDIR)/lfs.perfbd.csv +perfbd-csv: $(BUILDDIR)/lfs3.perfbd.csv ## Compare perfbd results .PHONY: perfbd-diff perfbd-diff: $(BENCH_TRACE) $(strip ./scripts/perfbd.py $(BENCH_RUNNER) $^ \ $(patsubst %,-F%,$(SRC)) \ - $(PERFBDFLAGS) -d $(BUILDDIR)/lfs.perfbd.csv) + $(PERFBDFLAGS) -d $(BUILDDIR)/lfs3.perfbd.csv) ## Find a summary of compile-time sizes .PHONY: summary sizes @@ -420,10 +420,10 @@ summary sizes: $(OBJ) $(CI) .PHONY: summary-csv sizes-csv summary-csv sizes-csv: SHELL=/bin/bash summary-csv sizes-csv: \ - $(BUILDDIR)/lfs.code.csv \ - $(BUILDDIR)/lfs.data.csv \ - $(BUILDDIR)/lfs.stack.csv \ - $(BUILDDIR)/lfs.ctx.csv + $(BUILDDIR)/lfs3.code.csv \ + $(BUILDDIR)/lfs3.data.csv \ + $(BUILDDIR)/lfs3.stack.csv \ + $(BUILDDIR)/lfs3.ctx.csv ## Compare compile-time sizes .PHONY: summary-diff sizes-diff @@ -442,10 +442,10 @@ summary-diff sizes-diff: $(OBJ) $(CI) -fctx='max(ctx_size)' \ -o-) \ <(./scripts/csv.py \ - $(BUILDDIR)/lfs.code.csv \ - $(BUILDDIR)/lfs.data.csv \ - $(BUILDDIR)/lfs.stack.csv \ - $(BUILDDIR)/lfs.ctx.csv \ + $(BUILDDIR)/lfs3.code.csv \ + $(BUILDDIR)/lfs3.data.csv \ + $(BUILDDIR)/lfs3.stack.csv \ + $(BUILDDIR)/lfs3.ctx.csv \ -bbuild=BEFORE \ -fcode=code_size \ -fdata=data_size \ @@ -458,12 +458,12 @@ summary-diff sizes-diff: $(OBJ) $(CI) ## Generate a codemap svg .PHONY: codemap codemap: CODEMAPFLAGS+=-W1400 -H750 --dark -codemap: $(BUILDDIR)/lfs.codemap.svg +codemap: $(BUILDDIR)/lfs3.codemap.svg ## Generate a tiny codemap, where 1 pixel ~= 1 byte .PHONY: codemap-tiny codemap-tiny: CODEMAPFLAGS+=--dark -codemap-tiny: $(BUILDDIR)/lfs.codemap_tiny.svg +codemap-tiny: $(BUILDDIR)/lfs3.codemap_tiny.svg ## Build the test-runner @@ -504,7 +504,7 @@ testmarks: $(TEST_CSV) ## Save the test results .PHONY: testmarks-csv -testmarks-csv: $(BUILDDIR)/lfs.test.csv +testmarks-csv: $(BUILDDIR)/lfs3.test.csv ## Compare test results against a previous run .PHONY: testmarks-diff @@ -513,7 +513,7 @@ testmarks-diff: $(TEST_CSV) -bsuite \ -fpassed=test_passed \ -ftime=test_time \ - $(SUMMARYFLAGS) -d $(BUILDDIR)/lfs.test.csv) + $(SUMMARYFLAGS) -d $(BUILDDIR)/lfs3.test.csv) ## Build the bench-runner .PHONY: bench-runner build-benches @@ -554,7 +554,7 @@ benchmarks: $(BENCH_CSV) ## Save the bench results .PHONY: benchmarks-csv -benchmarks-csv: $(BUILDDIR)/lfs.bench.csv +benchmarks-csv: $(BUILDDIR)/lfs3.bench.csv ## Compare bench results against a previous run .PHONY: benchmarks-diff @@ -564,7 +564,7 @@ benchmarks-diff: $(BENCH_CSV) -freaded=bench_readed \ -fproged=bench_proged \ -ferased=bench_erased \ - $(SUMMARYFLAGS) -d $(BUILDDIR)/lfs.bench.csv) + $(SUMMARYFLAGS) -d $(BUILDDIR)/lfs3.bench.csv) @@ -575,54 +575,54 @@ benchmarks-diff: $(BENCH_CSV) .SUFFIXES: .SECONDARY: -$(BUILDDIR)/lfs: $(OBJ) +$(BUILDDIR)/lfs3: $(OBJ) $(CC) $(CFLAGS) $^ $(LFLAGS) -o$@ -$(BUILDDIR)/liblfs.a: $(OBJ) +$(BUILDDIR)/liblfs3.a: $(OBJ) $(AR) rcs $@ $^ -$(BUILDDIR)/lfs.code.csv: $(OBJ) +$(BUILDDIR)/lfs3.code.csv: $(OBJ) ./scripts/code.py $^ $(CODEFLAGS) -o$@ -$(BUILDDIR)/lfs.data.csv: $(OBJ) +$(BUILDDIR)/lfs3.data.csv: $(OBJ) ./scripts/data.py $^ $(DATAFLAGS) -o$@ -$(BUILDDIR)/lfs.stack.csv: $(CI) +$(BUILDDIR)/lfs3.stack.csv: $(CI) ./scripts/stack.py $^ $(STACKFLAGS) -o$@ -$(BUILDDIR)/lfs.ctx.csv: $(OBJ) +$(BUILDDIR)/lfs3.ctx.csv: $(OBJ) ./scripts/ctx.py $^ $(CTXFLAGS) -o$@ -$(BUILDDIR)/lfs.structs.csv: $(OBJ) +$(BUILDDIR)/lfs3.structs.csv: $(OBJ) ./scripts/structs.py $^ $(STRUCTSFLAGS) -o$@ -$(BUILDDIR)/lfs.cov.csv: $(GCDA) +$(BUILDDIR)/lfs3.cov.csv: $(GCDA) $(strip ./scripts/cov.py $^ \ $(patsubst %,-F%,$(SRC)) \ $(COVFLAGS) -o$@) -$(BUILDDIR)/lfs.perf.csv: $(BENCH_PERF) +$(BUILDDIR)/lfs3.perf.csv: $(BENCH_PERF) $(strip ./scripts/perf.py $^ \ $(patsubst %,-F%,$(SRC)) \ $(PERFFLAGS) -o$@) -$(BUILDDIR)/lfs.perfbd.csv: $(BENCH_TRACE) +$(BUILDDIR)/lfs3.perfbd.csv: $(BENCH_TRACE) $(strip ./scripts/perfbd.py $(BENCH_RUNNER) $^ \ $(patsubst %,-F%,$(SRC)) \ $(PERFBDFLAGS) -o$@) -$(BUILDDIR)/lfs.codemap.svg: $(OBJ) $(CI) +$(BUILDDIR)/lfs3.codemap.svg: $(OBJ) $(CI) $(strip ./scripts/codemapsvg.py $^ $(CODEMAPFLAGS) -o$@ \ && ./scripts/codemap.py $^ --no-header) -$(BUILDDIR)/lfs.codemap_tiny.svg: $(OBJ) $(CI) +$(BUILDDIR)/lfs3.codemap_tiny.svg: $(OBJ) $(CI) $(strip ./scripts/codemapsvg.py $^ --tiny $(CODEMAPFLAGS) -o$@ \ && ./scripts/codemap.py $^ --no-header) -$(BUILDDIR)/lfs.test.csv: $(TEST_CSV) +$(BUILDDIR)/lfs3.test.csv: $(TEST_CSV) cp $^ $@ -$(BUILDDIR)/lfs.bench.csv: $(BENCH_CSV) +$(BUILDDIR)/lfs3.bench.csv: $(BENCH_CSV) cp $^ $@ $(BUILDDIR)/runners/test_runner: $(TEST_OBJ) @@ -666,20 +666,20 @@ $(BUILDDIR)/%.b.c: %.c $(BENCHES) ## Clean everything .PHONY: clean clean: - rm -f $(BUILDDIR)/lfs - rm -f $(BUILDDIR)/liblfs.a - rm -f $(BUILDDIR)/lfs.code.csv - rm -f $(BUILDDIR)/lfs.data.csv - rm -f $(BUILDDIR)/lfs.stack.csv - rm -f $(BUILDDIR)/lfs.ctx.csv - rm -f $(BUILDDIR)/lfs.structs.csv - rm -f $(BUILDDIR)/lfs.cov.csv - rm -f $(BUILDDIR)/lfs.perf.csv - rm -f $(BUILDDIR)/lfs.perfbd.csv - rm -f $(BUILDDIR)/lfs.codemap.svg - rm -f $(BUILDDIR)/lfs.codemap_tiny.svg - rm -f $(BUILDDIR)/lfs.test.csv - rm -f $(BUILDDIR)/lfs.bench.csv + rm -f $(BUILDDIR)/lfs3 + rm -f $(BUILDDIR)/liblfs3.a + rm -f $(BUILDDIR)/lfs3.code.csv + rm -f $(BUILDDIR)/lfs3.data.csv + rm -f $(BUILDDIR)/lfs3.stack.csv + rm -f $(BUILDDIR)/lfs3.ctx.csv + rm -f $(BUILDDIR)/lfs3.structs.csv + rm -f $(BUILDDIR)/lfs3.cov.csv + rm -f $(BUILDDIR)/lfs3.perf.csv + rm -f $(BUILDDIR)/lfs3.perfbd.csv + rm -f $(BUILDDIR)/lfs3.codemap.svg + rm -f $(BUILDDIR)/lfs3.codemap_tiny.svg + rm -f $(BUILDDIR)/lfs3.test.csv + rm -f $(BUILDDIR)/lfs3.bench.csv rm -f $(OBJ) rm -f $(DEP) rm -f $(ASM) diff --git a/bd/lfs_emubd.c b/bd/lfs3_emubd.c similarity index 59% rename from bd/lfs_emubd.c rename to bd/lfs3_emubd.c index ae29d4db..aa068d87 100644 --- a/bd/lfs_emubd.c +++ b/bd/lfs3_emubd.c @@ -11,7 +11,7 @@ #define _POSIX_C_SOURCE 199309L #endif -#include "bd/lfs_emubd.h" +#include "bd/lfs3_emubd.h" #include #include @@ -29,14 +29,14 @@ // Note we can only modify a block if we have exclusive access to it (rc == 1) // -static lfs_emubd_block_t *lfs_emubd_incblock(lfs_emubd_block_t *block) { +static lfs3_emubd_block_t *lfs3_emubd_incblock(lfs3_emubd_block_t *block) { if (block) { block->rc += 1; } return block; } -static void lfs_emubd_decblock(lfs_emubd_block_t *block) { +static void lfs3_emubd_decblock(lfs3_emubd_block_t *block) { if (block) { block->rc -= 1; if (block->rc == 0) { @@ -45,32 +45,32 @@ static void lfs_emubd_decblock(lfs_emubd_block_t *block) { } } -static lfs_emubd_block_t *lfs_emubd_mutblock( - const struct lfs_config *cfg, - lfs_emubd_block_t *block) { +static lfs3_emubd_block_t *lfs3_emubd_mutblock( + const struct lfs3_config *cfg, + lfs3_emubd_block_t *block) { if (block && block->rc == 1) { // rc == 1? can modify return block; } else if (block) { // rc > 1? need to create a copy - lfs_emubd_block_t *block_ = malloc( - sizeof(lfs_emubd_block_t) + cfg->block_size); + lfs3_emubd_block_t *block_ = malloc( + sizeof(lfs3_emubd_block_t) + cfg->block_size); if (!block_) { return NULL; } memcpy(block_, block, - sizeof(lfs_emubd_block_t) + cfg->block_size); + sizeof(lfs3_emubd_block_t) + cfg->block_size); block_->rc = 1; - lfs_emubd_decblock(block); + lfs3_emubd_decblock(block); return block_; } else { // no block? need to allocate - lfs_emubd_block_t *block_ = malloc( - sizeof(lfs_emubd_block_t) + cfg->block_size); + lfs3_emubd_block_t *block_ = malloc( + sizeof(lfs3_emubd_block_t) + cfg->block_size); if (!block_) { return NULL; } @@ -81,7 +81,7 @@ static lfs_emubd_block_t *lfs_emubd_mutblock( block_->bad_bit = 0; // zero for consistency - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; memset(block_->data, (bd->cfg->erase_value != -1) ? bd->cfg->erase_value : 0, cfg->block_size); @@ -92,7 +92,7 @@ static lfs_emubd_block_t *lfs_emubd_mutblock( // prng used for some emulation things -static uint32_t lfs_emubd_prng_(uint32_t *state) { +static uint32_t lfs3_emubd_prng_(uint32_t *state) { // A simple xorshift32 generator, easily reproducible. Keep in mind // determinism is much more important than actual randomness here. uint32_t x = *state; @@ -111,9 +111,9 @@ static uint32_t lfs_emubd_prng_(uint32_t *state) { // emubd create/destroy -int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path, - const struct lfs_emubd_config *bdcfg) { - LFS_EMUBD_TRACE("lfs_emubd_createcfg(%p {.context=%p, " +int lfs3_emubd_createcfg(const struct lfs3_config *cfg, const char *path, + const struct lfs3_emubd_config *bdcfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_createcfg(%p {.context=%p, " ".read=%p, .prog=%p, .erase=%p, .sync=%p, " ".read_size=%"PRIu32", .prog_size=%"PRIu32", " ".block_size=%"PRIu32", .block_count=%"PRIu32"}, " @@ -130,7 +130,7 @@ int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path, bdcfg->badblock_behavior, bdcfg->power_cycles, bdcfg->powerloss_behavior, (void*)(uintptr_t)bdcfg->powerloss_cb, bdcfg->powerloss_data, bdcfg->seed); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; bd->cfg = bdcfg; // setup testing things @@ -146,40 +146,40 @@ int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path, // allocate our block array, all blocks start as uninitialized bd->blocks = malloc( - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); int err; if (!bd->blocks) { - err = LFS_ERR_NOMEM; + err = LFS3_ERR_NOMEM; goto failed; } memset(bd->blocks, 0, - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); // allocate extra block arrays to hold our ooo snapshots - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { bd->ooo_before = malloc( - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); if (!bd->ooo_before) { - err = LFS_ERR_NOMEM; + err = LFS3_ERR_NOMEM; goto failed; } memset(bd->ooo_before, 0, - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); bd->ooo_after = malloc( - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); if (!bd->ooo_after) { - err = LFS_ERR_NOMEM; + err = LFS3_ERR_NOMEM; goto failed; } memset(bd->ooo_after, 0, - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); } if (bd->cfg->disk_path) { - bd->disk = malloc(sizeof(lfs_emubd_disk_t)); + bd->disk = malloc(sizeof(lfs3_emubd_disk_t)); if (!bd->disk) { - err = LFS_ERR_NOMEM; + err = LFS3_ERR_NOMEM; goto failed; } bd->disk->rc = 1; @@ -200,7 +200,7 @@ int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path, bd->disk->scratch = malloc(cfg->block_size); if (!bd->disk->scratch) { - err = LFS_ERR_NOMEM; + err = LFS3_ERR_NOMEM; goto failed; } memset(bd->disk->scratch, @@ -220,14 +220,14 @@ int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path, } } - LFS_EMUBD_TRACE("lfs_emubd_createcfg -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_createcfg -> %d", 0); return 0; failed:; - LFS_EMUBD_TRACE("lfs_emubd_createcfg -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_createcfg -> %d", err); // clean up memory free(bd->blocks); - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { free(bd->ooo_before); free(bd->ooo_after); } @@ -241,8 +241,8 @@ failed:; return err; } -int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { - LFS_EMUBD_TRACE("lfs_emubd_create(%p {.context=%p, " +int lfs3_emubd_create(const struct lfs3_config *cfg, const char *path) { + LFS3_EMUBD_TRACE("lfs3_emubd_create(%p {.context=%p, " ".read=%p, .prog=%p, .erase=%p, .sync=%p, " ".read_size=%"PRIu32", .prog_size=%"PRIu32", " ".block_size=%"PRIu32", .block_count=%"PRIu32"}, " @@ -252,30 +252,30 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, path); - static const struct lfs_emubd_config defaults = {.erase_value=-1}; - int err = lfs_emubd_createcfg(cfg, path, &defaults); - LFS_EMUBD_TRACE("lfs_emubd_create -> %d", err); + static const struct lfs3_emubd_config defaults = {.erase_value=-1}; + int err = lfs3_emubd_createcfg(cfg, path, &defaults); + LFS3_EMUBD_TRACE("lfs3_emubd_create -> %d", err); return err; } -int lfs_emubd_destroy(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_destroy(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_destroy(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_destroy(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; // decrement reference counts - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - lfs_emubd_decblock(bd->blocks[i]); + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + lfs3_emubd_decblock(bd->blocks[i]); } free(bd->blocks); - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - lfs_emubd_decblock(bd->ooo_before[i]); + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + lfs3_emubd_decblock(bd->ooo_before[i]); } free(bd->ooo_before); - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - lfs_emubd_decblock(bd->ooo_after[i]); + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + lfs3_emubd_decblock(bd->ooo_after[i]); } free(bd->ooo_after); } @@ -290,36 +290,36 @@ int lfs_emubd_destroy(const struct lfs_config *cfg) { } } - LFS_EMUBD_TRACE("lfs_emubd_destroy -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_destroy -> %d", 0); return 0; } // block device API -int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size) { - LFS_EMUBD_TRACE("lfs_emubd_read(%p, " +int lfs3_emubd_read(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size) { + LFS3_EMUBD_TRACE("lfs3_emubd_read(%p, " "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", (void*)cfg, block, off, buffer, size); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if read is valid - LFS_ASSERT(block < cfg->block_count); - LFS_ASSERT(off % cfg->read_size == 0); - LFS_ASSERT(size % cfg->read_size == 0); - LFS_ASSERT(off+size <= cfg->block_size); + LFS3_ASSERT(block < cfg->block_count); + LFS3_ASSERT(off % cfg->read_size == 0); + LFS3_ASSERT(size % cfg->read_size == 0); + LFS3_ASSERT(off+size <= cfg->block_size); // get the block - const lfs_emubd_block_t *b = bd->blocks[block]; + const lfs3_emubd_block_t *b = bd->blocks[block]; if (b) { // block bad? if (b->wear > bd->cfg->erase_cycles) { // erroring reads? error if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_READERROR) { - LFS_EMUBD_TRACE("lfs_emubd_read -> %d", LFS_ERR_CORRUPT); - return LFS_ERR_CORRUPT; + == LFS3_EMUBD_BADBLOCK_READERROR) { + LFS3_EMUBD_TRACE("lfs3_emubd_read -> %d", LFS3_ERR_CORRUPT); + return LFS3_ERR_CORRUPT; } } @@ -328,10 +328,10 @@ int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block, // metastable? randomly decide if our bad bit flips if (b->metastable) { - lfs_size_t bit = b->bad_bit & 0x7fffffff; + lfs3_size_t bit = b->bad_bit & 0x7fffffff; if (bit/8 >= off && bit/8 < off+size - && (lfs_emubd_prng_(&bd->prng) & 1)) { + && (lfs3_emubd_prng_(&bd->prng) & 1)) { ((uint8_t*)buffer)[(bit/8) - off] ^= 1 << (bit%8); } } @@ -353,34 +353,34 @@ int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block, NULL); if (err) { err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_read -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_read -> %d", err); return err; } } - LFS_EMUBD_TRACE("lfs_emubd_read -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_read -> %d", 0); return 0; } -int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size) { - LFS_EMUBD_TRACE("lfs_emubd_prog(%p, " +int lfs3_emubd_prog(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size) { + LFS3_EMUBD_TRACE("lfs3_emubd_prog(%p, " "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", (void*)cfg, block, off, buffer, size); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if write is valid - LFS_ASSERT(block < cfg->block_count); - LFS_ASSERT(off % cfg->prog_size == 0); - LFS_ASSERT(size % cfg->prog_size == 0); - LFS_ASSERT(off+size <= cfg->block_size); + LFS3_ASSERT(block < cfg->block_count); + LFS3_ASSERT(off % cfg->prog_size == 0); + LFS3_ASSERT(size % cfg->prog_size == 0); + LFS3_ASSERT(off+size <= cfg->block_size); // were we erased properly? - LFS_ASSERT(bd->blocks[block]); + LFS3_ASSERT(bd->blocks[block]); if (bd->cfg->erase_value != -1 && bd->blocks[block]->wear <= bd->cfg->erase_cycles) { - for (lfs_off_t i = 0; i < size; i++) { - LFS_ASSERT(bd->blocks[block]->data[off+i] == bd->cfg->erase_value); + for (lfs3_off_t i = 0; i < size; i++) { + LFS3_ASSERT(bd->blocks[block]->data[off+i] == bd->cfg->erase_value); } } @@ -390,18 +390,18 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, if (bd->power_cycles == 0) { // emulating some bits? choose a random bit to flip if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_SOMEBITS) { + == LFS3_EMUBD_POWERLOSS_SOMEBITS) { // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; // flip bit - lfs_size_t bit = lfs_emubd_prng_(&bd->prng) + lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng) % (cfg->prog_size*8); b->data[off + (bit/8)] ^= 1 << (bit%8); @@ -412,14 +412,14 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } ssize_t res2 = write(bd->disk->fd, &b->data[off], size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } @@ -427,13 +427,13 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, // emulating most bits? prog data and choose a random bit // to flip } else if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_MOSTBITS) { + == LFS3_EMUBD_POWERLOSS_MOSTBITS) { // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -441,7 +441,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, memcpy(&b->data[off], buffer, size); // flip bit - lfs_size_t bit = lfs_emubd_prng_(&bd->prng) + lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng) % (cfg->prog_size*8); b->data[off + (bit/8)] ^= 1 << (bit%8); @@ -452,14 +452,14 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } ssize_t res2 = write(bd->disk->fd, &b->data[off], size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } @@ -467,14 +467,14 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, // emulating out-of-order writes? revert everything unsynced // except for our current block } else if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_OOO) { - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - lfs_emubd_decblock(bd->ooo_after[i]); - bd->ooo_after[i] = lfs_emubd_incblock(bd->blocks[i]); + == LFS3_EMUBD_POWERLOSS_OOO) { + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + lfs3_emubd_decblock(bd->ooo_after[i]); + bd->ooo_after[i] = lfs3_emubd_incblock(bd->blocks[i]); if (i != block && bd->blocks[i] != bd->ooo_before[i]) { - lfs_emubd_decblock(bd->blocks[i]); - bd->blocks[i] = lfs_emubd_incblock(bd->ooo_before[i]); + lfs3_emubd_decblock(bd->blocks[i]); + bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_before[i]); // mirror to disk file? if (bd->disk) { @@ -483,7 +483,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } @@ -494,7 +494,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } @@ -504,13 +504,13 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, // emulating metastability? prog data, choose a random bad bit, // and mark as metastable } else if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_METASTABLE) { + == LFS3_EMUBD_POWERLOSS_METASTABLE) { // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -519,7 +519,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, // choose a new bad bit unless overridden if (!(0x80000000 & b->bad_bit)) { - b->bad_bit = lfs_emubd_prng_(&bd->prng) + b->bad_bit = lfs3_emubd_prng_(&bd->prng) % (cfg->block_size*8); } @@ -533,14 +533,14 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } ssize_t res2 = write(bd->disk->fd, &b->data[off], size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } @@ -550,11 +550,11 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, bd->cfg->powerloss_cb(bd->cfg->powerloss_data); // oh, continuing? undo out-of-order write emulation - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { - for (lfs_block_t i = 0; i < cfg->block_count; i++) { + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { if (bd->blocks[i] != bd->ooo_after[i]) { - lfs_emubd_decblock(bd->blocks[i]); - bd->blocks[i] = lfs_emubd_incblock(bd->ooo_after[i]); + lfs3_emubd_decblock(bd->blocks[i]); + bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_after[i]); // mirror to disk file? if (bd->disk) { @@ -563,7 +563,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } @@ -574,7 +574,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } @@ -585,10 +585,10 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, } // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -596,22 +596,22 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, if (b->wear > bd->cfg->erase_cycles) { // erroring progs? error if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_PROGERROR) { - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", LFS_ERR_CORRUPT); - return LFS_ERR_CORRUPT; + == LFS3_EMUBD_BADBLOCK_PROGERROR) { + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_CORRUPT); + return LFS3_ERR_CORRUPT; // noop progs? skip } else if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_PROGNOOP + == LFS3_EMUBD_BADBLOCK_PROGNOOP || bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_ERASENOOP) { + == LFS3_EMUBD_BADBLOCK_ERASENOOP) { goto progged; // progs flipping bits? flip our bad bit, exactly which bit // is chosen during erase } else if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_PROGFLIP) { - lfs_size_t bit = b->bad_bit & 0x7fffffff; + == LFS3_EMUBD_BADBLOCK_PROGFLIP) { + lfs3_size_t bit = b->bad_bit & 0x7fffffff; if (bit/8 >= off && bit/8 < off+size) { memcpy(&b->data[off], buffer, size); b->data[bit/8] ^= 1 << (bit%8); @@ -620,7 +620,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, // reads flipping bits? prog as normal but mark as metastable } else if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_READFLIP) { + == LFS3_EMUBD_BADBLOCK_READFLIP) { memcpy(&b->data[off], buffer, size); b->metastable = true; goto progged; @@ -641,14 +641,14 @@ progged:; SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } ssize_t res2 = write(bd->disk->fd, &b->data[off], size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } @@ -662,22 +662,22 @@ progged:; NULL); if (err) { err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err); return err; } } - LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", 0); return 0; } -int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { - LFS_EMUBD_TRACE("lfs_emubd_erase(%p, 0x%"PRIx32" (%"PRIu32"))", +int lfs3_emubd_erase(const struct lfs3_config *cfg, lfs3_block_t block) { + LFS3_EMUBD_TRACE("lfs3_emubd_erase(%p, 0x%"PRIx32" (%"PRIu32"))", (void*)cfg, block, cfg->block_size); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if erase is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // losing power? if (bd->power_cycles > 0) { @@ -685,18 +685,18 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { if (bd->power_cycles == 0) { // emulating some bits? choose a random bit to flip if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_SOMEBITS) { + == LFS3_EMUBD_POWERLOSS_SOMEBITS) { // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; // flip bit - lfs_size_t bit = lfs_emubd_prng_(&bd->prng) + lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng) % (cfg->block_size*8); b->data[(bit/8)] ^= 1 << (bit%8); @@ -707,7 +707,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } @@ -715,7 +715,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { b->data, cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } @@ -723,13 +723,13 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { // emulating most bits? erase data and choose a random bit // to flip } else if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_MOSTBITS) { + == LFS3_EMUBD_POWERLOSS_MOSTBITS) { // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -739,7 +739,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { } // flip bit - lfs_size_t bit = lfs_emubd_prng_(&bd->prng) + lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng) % (cfg->block_size*8); b->data[(bit/8)] ^= 1 << (bit%8); @@ -750,7 +750,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } @@ -758,7 +758,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { b->data, cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } @@ -766,11 +766,11 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { // emulating out-of-order writes? revert everything unsynced // except for our current block } else if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_OOO) { - for (lfs_block_t i = 0; i < cfg->block_count; i++) { + == LFS3_EMUBD_POWERLOSS_OOO) { + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { if (i != block && bd->blocks[i] != bd->ooo_before[i]) { - lfs_emubd_decblock(bd->blocks[i]); - bd->blocks[i] = lfs_emubd_incblock(bd->ooo_before[i]); + lfs3_emubd_decblock(bd->blocks[i]); + bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_before[i]); // mirror to disk file? if (bd->disk) { @@ -779,7 +779,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } @@ -790,7 +790,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } @@ -800,13 +800,13 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { // emulating metastability? erase data, choose a random bad bit, // and mark as metastable } else if (bd->cfg->powerloss_behavior - == LFS_EMUBD_POWERLOSS_METASTABLE) { + == LFS3_EMUBD_POWERLOSS_METASTABLE) { // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -817,7 +817,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { // choose a new bad bit unless overridden if (!(0x80000000 & b->bad_bit)) { - b->bad_bit = lfs_emubd_prng_(&bd->prng) + b->bad_bit = lfs3_emubd_prng_(&bd->prng) % (cfg->block_size*8); } @@ -831,7 +831,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } @@ -839,7 +839,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { b->data, cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } @@ -849,11 +849,11 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { bd->cfg->powerloss_cb(bd->cfg->powerloss_data); // oh, continuing? undo out-of-order write emulation - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { - for (lfs_block_t i = 0; i < cfg->block_count; i++) { + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { if (bd->blocks[i] != bd->ooo_after[i]) { - lfs_emubd_decblock(bd->blocks[i]); - bd->blocks[i] = lfs_emubd_incblock(bd->ooo_after[i]); + lfs3_emubd_decblock(bd->blocks[i]); + bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_after[i]); // mirror to disk file? if (bd->disk) { @@ -862,7 +862,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } @@ -873,7 +873,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } @@ -884,10 +884,10 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { } // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -900,13 +900,13 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { if (b->wear > bd->cfg->erase_cycles) { // erroring erases? error if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_ERASEERROR) { - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", LFS_ERR_CORRUPT); - return LFS_ERR_CORRUPT; + == LFS3_EMUBD_BADBLOCK_ERASEERROR) { + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_CORRUPT); + return LFS3_ERR_CORRUPT; // noop erases? skip } else if (bd->cfg->badblock_behavior - == LFS_EMUBD_BADBLOCK_ERASENOOP) { + == LFS3_EMUBD_BADBLOCK_ERASENOOP) { goto erased; // flipping bits? if we're not manually overridden, choose a @@ -914,7 +914,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { // eventually cause problems } else { if (!(0x80000000 & b->bad_bit)) { - b->bad_bit = lfs_emubd_prng_(&bd->prng) + b->bad_bit = lfs3_emubd_prng_(&bd->prng) % (cfg->block_size*8); } } @@ -931,14 +931,14 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } ssize_t res2 = write(bd->disk->fd, b->data, cfg->block_size); if (res2 < 0) { int err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } @@ -957,158 +957,161 @@ erased:; NULL); if (err) { err = -errno; - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err); return err; } } - LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", 0); return 0; } -int lfs_emubd_sync(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_sync(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_sync(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_sync(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; // emulate out-of-order writes? save a snapshot on sync - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { for (size_t i = 0; i < cfg->block_count; i++) { - lfs_emubd_decblock(bd->ooo_before[i]); - bd->ooo_before[i] = lfs_emubd_incblock(bd->blocks[i]); + lfs3_emubd_decblock(bd->ooo_before[i]); + bd->ooo_before[i] = lfs3_emubd_incblock(bd->blocks[i]); } } - LFS_EMUBD_TRACE("lfs_emubd_sync -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_sync -> %d", 0); return 0; } /// Additional extended API for driving test features /// -void lfs_emubd_seed(const struct lfs_config *cfg, uint32_t seed) { - LFS_EMUBD_TRACE("lfs_emubd_seed(%p, 0x%08"PRIx32")", +void lfs3_emubd_seed(const struct lfs3_config *cfg, uint32_t seed) { + LFS3_EMUBD_TRACE("lfs3_emubd_seed(%p, 0x%08"PRIx32")", (void*)cfg, seed); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; bd->prng = seed; - LFS_EMUBD_TRACE("lfs_emubd_seed -> _"); + LFS3_EMUBD_TRACE("lfs3_emubd_seed -> _"); } -uint32_t lfs_emubd_prng(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_prng(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; +uint32_t lfs3_emubd_prng(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_prng(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; - uint32_t x = lfs_emubd_prng_(&bd->prng); + uint32_t x = lfs3_emubd_prng_(&bd->prng); - LFS_EMUBD_TRACE("lfs_emubd_prng -> 0x%08"PRIx32, x); + LFS3_EMUBD_TRACE("lfs3_emubd_prng -> 0x%08"PRIx32, x); return x; } -lfs_emubd_sio_t lfs_emubd_readed(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_readed(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; - LFS_EMUBD_TRACE("lfs_emubd_readed -> %"PRIu64, bd->readed); +lfs3_emubd_sio_t lfs3_emubd_readed(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_readed(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; + LFS3_EMUBD_TRACE("lfs3_emubd_readed -> %"PRIu64, bd->readed); return bd->readed; } -lfs_emubd_sio_t lfs_emubd_proged(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_proged(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; - LFS_EMUBD_TRACE("lfs_emubd_proged -> %"PRIu64, bd->proged); +lfs3_emubd_sio_t lfs3_emubd_proged(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_proged(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; + LFS3_EMUBD_TRACE("lfs3_emubd_proged -> %"PRIu64, bd->proged); return bd->proged; } -lfs_emubd_sio_t lfs_emubd_erased(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_erased(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; - LFS_EMUBD_TRACE("lfs_emubd_erased -> %"PRIu64, bd->erased); +lfs3_emubd_sio_t lfs3_emubd_erased(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_erased(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; + LFS3_EMUBD_TRACE("lfs3_emubd_erased -> %"PRIu64, bd->erased); return bd->erased; } -int lfs_emubd_setreaded(const struct lfs_config *cfg, lfs_emubd_io_t readed) { - LFS_EMUBD_TRACE("lfs_emubd_setreaded(%p, %"PRIu64")", (void*)cfg, readed); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_setreaded(const struct lfs3_config *cfg, + lfs3_emubd_io_t readed) { + LFS3_EMUBD_TRACE("lfs3_emubd_setreaded(%p, %"PRIu64")", (void*)cfg, readed); + lfs3_emubd_t *bd = cfg->context; bd->readed = readed; - LFS_EMUBD_TRACE("lfs_emubd_setreaded -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_setreaded -> %d", 0); return 0; } -int lfs_emubd_setproged(const struct lfs_config *cfg, lfs_emubd_io_t proged) { - LFS_EMUBD_TRACE("lfs_emubd_setproged(%p, %"PRIu64")", (void*)cfg, proged); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_setproged(const struct lfs3_config *cfg, + lfs3_emubd_io_t proged) { + LFS3_EMUBD_TRACE("lfs3_emubd_setproged(%p, %"PRIu64")", (void*)cfg, proged); + lfs3_emubd_t *bd = cfg->context; bd->proged = proged; - LFS_EMUBD_TRACE("lfs_emubd_setproged -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_setproged -> %d", 0); return 0; } -int lfs_emubd_seterased(const struct lfs_config *cfg, lfs_emubd_io_t erased) { - LFS_EMUBD_TRACE("lfs_emubd_seterased(%p, %"PRIu64")", (void*)cfg, erased); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_seterased(const struct lfs3_config *cfg, + lfs3_emubd_io_t erased) { + LFS3_EMUBD_TRACE("lfs3_emubd_seterased(%p, %"PRIu64")", (void*)cfg, erased); + lfs3_emubd_t *bd = cfg->context; bd->erased = erased; - LFS_EMUBD_TRACE("lfs_emubd_seterased -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_seterased -> %d", 0); return 0; } -lfs_emubd_swear_t lfs_emubd_wear(const struct lfs_config *cfg, - lfs_block_t block) { - LFS_EMUBD_TRACE("lfs_emubd_wear(%p, %"PRIu32")", (void*)cfg, block); - lfs_emubd_t *bd = cfg->context; +lfs3_emubd_swear_t lfs3_emubd_wear(const struct lfs3_config *cfg, + lfs3_block_t block) { + LFS3_EMUBD_TRACE("lfs3_emubd_wear(%p, %"PRIu32")", (void*)cfg, block); + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // get the wear - lfs_emubd_wear_t wear; - const lfs_emubd_block_t *b = bd->blocks[block]; + lfs3_emubd_wear_t wear; + const lfs3_emubd_block_t *b = bd->blocks[block]; if (b) { wear = b->wear; } else { wear = 0; } - LFS_EMUBD_TRACE("lfs_emubd_wear -> %"PRIi32, wear); + LFS3_EMUBD_TRACE("lfs3_emubd_wear -> %"PRIi32, wear); return wear; } -int lfs_emubd_setwear(const struct lfs_config *cfg, - lfs_block_t block, lfs_emubd_wear_t wear) { - LFS_EMUBD_TRACE("lfs_emubd_setwear(%p, %"PRIu32", %"PRIi32")", +int lfs3_emubd_setwear(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_emubd_wear_t wear) { + LFS3_EMUBD_TRACE("lfs3_emubd_setwear(%p, %"PRIu32", %"PRIi32")", (void*)cfg, block, wear); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_setwear -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_setwear -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; // set the wear b->wear = wear; - LFS_EMUBD_TRACE("lfs_emubd_setwear -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_setwear -> %d", 0); return 0; } -int lfs_emubd_markbad(const struct lfs_config *cfg, - lfs_block_t block) { - LFS_EMUBD_TRACE("lfs_emubd_markbad(%p, %"PRIu32")", +int lfs3_emubd_markbad(const struct lfs3_config *cfg, + lfs3_block_t block) { + LFS3_EMUBD_TRACE("lfs3_emubd_markbad(%p, %"PRIu32")", (void*)cfg, block); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_markbad -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_markbad -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -1117,121 +1120,121 @@ int lfs_emubd_markbad(const struct lfs_config *cfg, // choose a bad bit now in case this block is never erased if (!(0x80000000 & b->bad_bit)) { - b->bad_bit = lfs_emubd_prng_(&bd->prng) + b->bad_bit = lfs3_emubd_prng_(&bd->prng) % (cfg->block_size*8); } - LFS_EMUBD_TRACE("lfs_emubd_markbad -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_markbad -> %d", 0); return 0; } -int lfs_emubd_markgood(const struct lfs_config *cfg, - lfs_block_t block) { - LFS_EMUBD_TRACE("lfs_emubd_markgood(%p, %"PRIu32")", +int lfs3_emubd_markgood(const struct lfs3_config *cfg, + lfs3_block_t block) { + LFS3_EMUBD_TRACE("lfs3_emubd_markgood(%p, %"PRIu32")", (void*)cfg, block); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_markgood -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_markgood -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; // set the wear b->wear = 0; - LFS_EMUBD_TRACE("lfs_emubd_markgood -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_markgood -> %d", 0); return 0; } -lfs_ssize_t lfs_emubd_badbit(const struct lfs_config *cfg, - lfs_block_t block) { - LFS_EMUBD_TRACE("lfs_emubd_badbit(%p, %"PRIu32")", (void*)cfg, block); - lfs_emubd_t *bd = cfg->context; +lfs3_ssize_t lfs3_emubd_badbit(const struct lfs3_config *cfg, + lfs3_block_t block) { + LFS3_EMUBD_TRACE("lfs3_emubd_badbit(%p, %"PRIu32")", (void*)cfg, block); + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // get the bad bit - lfs_size_t bad_bit; - const lfs_emubd_block_t *b = bd->blocks[block]; + lfs3_size_t bad_bit; + const lfs3_emubd_block_t *b = bd->blocks[block]; if (b) { bad_bit = 0x7fffffff & b->bad_bit; } else { bad_bit = 0; } - LFS_EMUBD_TRACE("lfs_emubd_badbit -> %"PRIi32, bad_bit); + LFS3_EMUBD_TRACE("lfs3_emubd_badbit -> %"PRIi32, bad_bit); return bad_bit; } -int lfs_emubd_setbadbit(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit) { - LFS_EMUBD_TRACE("lfs_emubd_setbadbit(%p, %"PRIu32", %"PRIu32")", +int lfs3_emubd_setbadbit(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit) { + LFS3_EMUBD_TRACE("lfs3_emubd_setbadbit(%p, %"PRIu32", %"PRIu32")", (void*)cfg, block, bit); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_setbadbit -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_setbadbit -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; // set the bad bit and mark as fixed b->bad_bit = 0x80000000 | bit; - LFS_EMUBD_TRACE("lfs_emubd_setbadbit -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_setbadbit -> %d", 0); return 0; } -int lfs_emubd_randomizebadbit(const struct lfs_config *cfg, - lfs_block_t block) { - LFS_EMUBD_TRACE("lfs_emubd_randomizebadbit(%p, %"PRIu32")", +int lfs3_emubd_randomizebadbit(const struct lfs3_config *cfg, + lfs3_block_t block) { + LFS3_EMUBD_TRACE("lfs3_emubd_randomizebadbit(%p, %"PRIu32")", (void*)cfg, block); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_randomizebadbit -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_randomizebadbit -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; // mark the bad bit as randomized b->bad_bit &= ~0x80000000; - LFS_EMUBD_TRACE("lfs_emubd_randomizebadbit -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_randomizebadbit -> %d", 0); return 0; } -int lfs_emubd_markbadbit(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit) { - LFS_EMUBD_TRACE("lfs_emubd_markbadbit(%p, %"PRIu32", %"PRIu32")", +int lfs3_emubd_markbadbit(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit) { + LFS3_EMUBD_TRACE("lfs3_emubd_markbadbit(%p, %"PRIu32", %"PRIu32")", (void*)cfg, block, bit); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - LFS_EMUBD_TRACE("lfs_emubd_markbadbit -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_markbadbit -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -1240,21 +1243,21 @@ int lfs_emubd_markbadbit(const struct lfs_config *cfg, // set the bad bit and mark as fixed b->bad_bit = 0x80000000 | bit; - LFS_EMUBD_TRACE("lfs_emubd_markbadbit -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_markbadbit -> %d", 0); return 0; } -int lfs_emubd_flipbit_(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit) { - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_flipbit_(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit) { + lfs3_emubd_t *bd = cfg->context; // check if block is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // mutate the block - lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, bd->blocks[block]); + lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]); if (!b) { - return LFS_ERR_NOMEM; + return LFS3_ERR_NOMEM; } bd->blocks[block] = b; @@ -1282,98 +1285,98 @@ int lfs_emubd_flipbit_(const struct lfs_config *cfg, } -int lfs_emubd_flipbit(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit) { - LFS_EMUBD_TRACE("lfs_emubd_flipbit(%p, %"PRIu32", %"PRIu32")", +int lfs3_emubd_flipbit(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit) { + LFS3_EMUBD_TRACE("lfs3_emubd_flipbit(%p, %"PRIu32", %"PRIu32")", (void*)cfg, block, bit); // flip the bit - int err = lfs_emubd_flipbit_(cfg, block, bit); + int err = lfs3_emubd_flipbit_(cfg, block, bit); if (err) { - LFS_EMUBD_TRACE("lfs_emubd_flipbit -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_flipbit -> %d", err); return err; } - LFS_EMUBD_TRACE("lfs_emubd_flipbit -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_flipbit -> %d", 0); return 0; } -int lfs_emubd_flip(const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_flip(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_flip(const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_flip(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; // flip all bits in bad blocks, make sure not to allocate blocks we // don't need - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - const lfs_emubd_block_t *b = bd->blocks[i]; + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + const lfs3_emubd_block_t *b = bd->blocks[i]; if (b && b->wear > bd->cfg->erase_cycles) { - int err = lfs_emubd_flipbit_(cfg, i, b->bad_bit & 0x7fffffff); + int err = lfs3_emubd_flipbit_(cfg, i, b->bad_bit & 0x7fffffff); if (err) { - LFS_EMUBD_TRACE("lfs_emubd_flip -> %d", err); + LFS3_EMUBD_TRACE("lfs3_emubd_flip -> %d", err); return err; } } } - LFS_EMUBD_TRACE("lfs_emubd_flip -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_flip -> %d", 0); return 0; } -lfs_emubd_spowercycles_t lfs_emubd_powercycles( - const struct lfs_config *cfg) { - LFS_EMUBD_TRACE("lfs_emubd_powercycles(%p)", (void*)cfg); - lfs_emubd_t *bd = cfg->context; +lfs3_emubd_spowercycles_t lfs3_emubd_powercycles( + const struct lfs3_config *cfg) { + LFS3_EMUBD_TRACE("lfs3_emubd_powercycles(%p)", (void*)cfg); + lfs3_emubd_t *bd = cfg->context; - LFS_EMUBD_TRACE("lfs_emubd_powercycles -> %"PRIi32, bd->power_cycles); + LFS3_EMUBD_TRACE("lfs3_emubd_powercycles -> %"PRIi32, bd->power_cycles); return bd->power_cycles; } -int lfs_emubd_setpowercycles(const struct lfs_config *cfg, - lfs_emubd_powercycles_t power_cycles) { - LFS_EMUBD_TRACE("lfs_emubd_setpowercycles(%p, %"PRIi32")", +int lfs3_emubd_setpowercycles(const struct lfs3_config *cfg, + lfs3_emubd_powercycles_t power_cycles) { + LFS3_EMUBD_TRACE("lfs3_emubd_setpowercycles(%p, %"PRIi32")", (void*)cfg, power_cycles); - lfs_emubd_t *bd = cfg->context; + lfs3_emubd_t *bd = cfg->context; bd->power_cycles = power_cycles; - LFS_EMUBD_TRACE("lfs_emubd_powercycles -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_powercycles -> %d", 0); return 0; } -int lfs_emubd_cpy(const struct lfs_config *cfg, lfs_emubd_t *copy) { - LFS_EMUBD_TRACE("lfs_emubd_cpy(%p, %p)", (void*)cfg, (void*)copy); - lfs_emubd_t *bd = cfg->context; +int lfs3_emubd_cpy(const struct lfs3_config *cfg, lfs3_emubd_t *copy) { + LFS3_EMUBD_TRACE("lfs3_emubd_cpy(%p, %p)", (void*)cfg, (void*)copy); + lfs3_emubd_t *bd = cfg->context; // lazily copy over our block array copy->blocks = malloc( - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); if (!copy->blocks) { - LFS_EMUBD_TRACE("lfs_emubd_cpy -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - copy->blocks[i] = lfs_emubd_incblock(bd->blocks[i]); + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + copy->blocks[i] = lfs3_emubd_incblock(bd->blocks[i]); } - if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) { + if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) { copy->ooo_before = malloc( - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); if (!copy->ooo_before) { - LFS_EMUBD_TRACE("lfs_emubd_cpy -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - copy->ooo_before[i] = lfs_emubd_incblock(bd->ooo_before[i]); + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + copy->ooo_before[i] = lfs3_emubd_incblock(bd->ooo_before[i]); } copy->ooo_after = malloc( - cfg->block_count * sizeof(lfs_emubd_block_t*)); + cfg->block_count * sizeof(lfs3_emubd_block_t*)); if (!copy->ooo_after) { - LFS_EMUBD_TRACE("lfs_emubd_cpy -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; + LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; } - for (lfs_block_t i = 0; i < cfg->block_count; i++) { - copy->ooo_after[i] = lfs_emubd_incblock(bd->ooo_after[i]); + for (lfs3_block_t i = 0; i < cfg->block_count; i++) { + copy->ooo_after[i] = lfs3_emubd_incblock(bd->ooo_after[i]); } } @@ -1389,7 +1392,7 @@ int lfs_emubd_cpy(const struct lfs_config *cfg, lfs_emubd_t *copy) { } copy->cfg = bd->cfg; - LFS_EMUBD_TRACE("lfs_emubd_cpy -> %d", 0); + LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", 0); return 0; } diff --git a/bd/lfs3_emubd.h b/bd/lfs3_emubd.h new file mode 100644 index 00000000..cdd04db9 --- /dev/null +++ b/bd/lfs3_emubd.h @@ -0,0 +1,265 @@ +/* + * Emulating block device, wraps filebd and rambd while providing a bunch + * of hooks for testing littlefs in various conditions. + * + * Copyright (c) 2022, The littlefs authors. + * Copyright (c) 2017, Arm Limited. All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef LFS3_EMUBD_H +#define LFS3_EMUBD_H + +#include "lfs3.h" +#include "lfs3_util.h" +#include "bd/lfs3_rambd.h" +#include "bd/lfs3_filebd.h" + + +// Block device specific tracing +#ifndef LFS3_EMUBD_TRACE +#ifdef LFS3_EMUBD_YES_TRACE +#define LFS3_EMUBD_TRACE(...) LFS3_TRACE(__VA_ARGS__) +#else +#define LFS3_EMUBD_TRACE(...) +#endif +#endif + +// Mode determining how "bad-blocks" behave during testing. This simulates +// some real-world circumstances such as progs not sticking (prog-noop), +// a readonly disk (erase-noop), ECC failures (read-error), and of course, +// random bit failures (prog-flip, read-flip) +typedef enum lfs3_emubd_badblock_behavior { + LFS3_EMUBD_BADBLOCK_PROGERROR = 0, // Error on prog + LFS3_EMUBD_BADBLOCK_ERASEERROR = 1, // Error on erase + LFS3_EMUBD_BADBLOCK_READERROR = 2, // Error on read + LFS3_EMUBD_BADBLOCK_PROGNOOP = 3, // Prog does nothing silently + LFS3_EMUBD_BADBLOCK_ERASENOOP = 4, // Erase does nothing silently + LFS3_EMUBD_BADBLOCK_PROGFLIP = 5, // Prog flips a bit + LFS3_EMUBD_BADBLOCK_READFLIP = 6, // Read flips a bit sometimes + LFS3_EMUBD_BADBLOCK_MANUAL = 7, // Bits require manual flipping +} lfs3_emubd_badblock_behavior_t; + +// Mode determining how power-loss behaves during testing. +typedef enum lfs3_emubd_powerloss_behavior { + LFS3_EMUBD_POWERLOSS_ATOMIC = 0, // Progs are atomic + LFS3_EMUBD_POWERLOSS_SOMEBITS = 1, // One bit is progged + LFS3_EMUBD_POWERLOSS_MOSTBITS = 2, // All-but-one bit is progged + LFS3_EMUBD_POWERLOSS_OOO = 3, // Blocks are written out-of-order + LFS3_EMUBD_POWERLOSS_METASTABLE = 4, // Reads may flip a bit +} lfs3_emubd_powerloss_behavior_t; + +// Type for measuring read/program/erase operations +typedef uint64_t lfs3_emubd_io_t; +typedef int64_t lfs3_emubd_sio_t; + +// Type for measuring wear +typedef uint32_t lfs3_emubd_wear_t; +typedef int32_t lfs3_emubd_swear_t; + +// Type for tracking power-cycles +typedef uint32_t lfs3_emubd_powercycles_t; +typedef int32_t lfs3_emubd_spowercycles_t; + +// Type for delays in nanoseconds +typedef uint64_t lfs3_emubd_sleep_t; +typedef int64_t lfs3_emubd_ssleep_t; + +// emubd config, this is required for testing +struct lfs3_emubd_config { + // 8-bit erase value to use for simulating erases. -1 simulates a noop + // erase, which is faster than simulating a fixed erase value. + int32_t erase_value; + + // Number of erase cycles before a block becomes "bad". The exact behavior + // of bad blocks is controlled by badblock_behavior. + uint32_t erase_cycles; + + // The mode determining how bad-blocks fail + lfs3_emubd_badblock_behavior_t badblock_behavior; + + // Number of write operations (erase/prog) before triggering a power-loss. + // power_cycles=0 disables this. The exact behavior of power-loss is + // controlled by a combination of powerloss_behavior and powerloss_cb. + lfs3_emubd_powercycles_t power_cycles; + + // The mode determining how power-loss affects disk + lfs3_emubd_powerloss_behavior_t powerloss_behavior; + + // Function to call to emulate power-loss. The exact behavior of power-loss + // is up to the runner to provide. + void (*powerloss_cb)(void*); + + // Data for power-loss callback + void *powerloss_data; + + // Seed for prng, which may be used for emulating failed progs. This does + // not affect normal operation. + uint32_t seed; + + // Path to file to use as a mirror of the disk. This provides a way to view + // the current state of the block device. + const char *disk_path; + + // Artificial delay in nanoseconds, there is no purpose for this other + // than slowing down the simulation. + lfs3_emubd_sleep_t read_sleep; + + // Artificial delay in nanoseconds, there is no purpose for this other + // than slowing down the simulation. + lfs3_emubd_sleep_t prog_sleep; + + // Artificial delay in nanoseconds, there is no purpose for this other + // than slowing down the simulation. + lfs3_emubd_sleep_t erase_sleep; +}; + +// A reference counted block +typedef struct lfs3_emubd_block { + uint32_t rc; + lfs3_emubd_wear_t wear; + bool metastable; + // sign(bad_bit)=0 => randomized on erase + // sign(bad_bit)=1 => fixed + lfs3_size_t bad_bit; + + uint8_t data[]; +} lfs3_emubd_block_t; + +// Disk mirror +typedef struct lfs3_emubd_disk { + uint32_t rc; + int fd; + uint8_t *scratch; +} lfs3_emubd_disk_t; + +// emubd state +typedef struct lfs3_emubd { + // array of copy-on-write blocks + lfs3_emubd_block_t **blocks; + + // some other test state + lfs3_emubd_io_t readed; + lfs3_emubd_io_t proged; + lfs3_emubd_io_t erased; + uint32_t prng; + lfs3_emubd_powercycles_t power_cycles; + lfs3_emubd_block_t **ooo_before; + lfs3_emubd_block_t **ooo_after; + lfs3_emubd_disk_t *disk; + + const struct lfs3_emubd_config *cfg; +} lfs3_emubd_t; + + +/// Block device API /// + +// Create an emulating block device using the geometry in lfs3_config +// +// Note that filebd is used if a path is provided, if path is NULL +// emubd will use rambd which can be much faster. +int lfs3_emubd_create(const struct lfs3_config *cfg, const char *path); +int lfs3_emubd_createcfg(const struct lfs3_config *cfg, const char *path, + const struct lfs3_emubd_config *bdcfg); + +// Clean up memory associated with block device +int lfs3_emubd_destroy(const struct lfs3_config *cfg); + +// Read a block +int lfs3_emubd_read(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size); + +// Program a block +// +// The block must have previously been erased. +int lfs3_emubd_prog(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size); + +// Erase a block +// +// A block must be erased before being programmed. The +// state of an erased block is undefined. +int lfs3_emubd_erase(const struct lfs3_config *cfg, lfs3_block_t block); + +// Sync the block device +int lfs3_emubd_sync(const struct lfs3_config *cfg); + + +/// Additional extended API for driving test features /// + +// Set the current prng state +void lfs3_emubd_seed(const struct lfs3_config *cfg, uint32_t seed); + +// Get a pseudo-random number from emubd's internal prng +uint32_t lfs3_emubd_prng(const struct lfs3_config *cfg); + +// Get total amount of bytes read +lfs3_emubd_sio_t lfs3_emubd_readed(const struct lfs3_config *cfg); + +// Get total amount of bytes programmed +lfs3_emubd_sio_t lfs3_emubd_proged(const struct lfs3_config *cfg); + +// Get total amount of bytes erased +lfs3_emubd_sio_t lfs3_emubd_erased(const struct lfs3_config *cfg); + +// Manually set amount of bytes read +int lfs3_emubd_setreaded(const struct lfs3_config *cfg, + lfs3_emubd_io_t readed); + +// Manually set amount of bytes programmed +int lfs3_emubd_setproged(const struct lfs3_config *cfg, + lfs3_emubd_io_t proged); + +// Manually set amount of bytes erased +int lfs3_emubd_seterased(const struct lfs3_config *cfg, + lfs3_emubd_io_t erased); + +// Get simulated wear on a given block +lfs3_emubd_swear_t lfs3_emubd_wear(const struct lfs3_config *cfg, + lfs3_block_t block); + +// Manually set simulated wear on a given block +int lfs3_emubd_setwear(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_emubd_wear_t wear); + +// Mark a block as bad, this is equivalent to setting wear to maximum +int lfs3_emubd_markbad(const struct lfs3_config *cfg, lfs3_block_t block); + +// Clear any simulated wear on a given block +int lfs3_emubd_markgood(const struct lfs3_config *cfg, lfs3_block_t block); + +// Get which bit failed, this changes on erase/power-loss unless manually set +lfs3_ssize_t lfs3_emubd_badbit(const struct lfs3_config *cfg, + lfs3_block_t block); + +// Set which bit should fail in a given block +int lfs3_emubd_setbadbit(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit); + +// Randomize the bad bit on erase (the default) +int lfs3_emubd_randomizebadbit(const struct lfs3_config *cfg, + lfs3_block_t block); + +// Mark a block as bad and which bit should fail +int lfs3_emubd_markbadbit(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit); + +// Flip a bit in a given block, intended for emulating bit errors +int lfs3_emubd_flipbit(const struct lfs3_config *cfg, + lfs3_block_t block, lfs3_size_t bit); + +// Flip all bits marked as bad +int lfs3_emubd_flip(const struct lfs3_config *cfg); + +// Get the remaining power-cycles +lfs3_emubd_spowercycles_t lfs3_emubd_powercycles( + const struct lfs3_config *cfg); + +// Manually set the remaining power-cycles +int lfs3_emubd_setpowercycles(const struct lfs3_config *cfg, + lfs3_emubd_powercycles_t power_cycles); + +// Create a copy-on-write copy of the state of this block device +int lfs3_emubd_cpy(const struct lfs3_config *cfg, lfs3_emubd_t *copy); + + +#endif diff --git a/bd/lfs_filebd.c b/bd/lfs3_filebd.c similarity index 53% rename from bd/lfs_filebd.c rename to bd/lfs3_filebd.c index 780c8f90..7fc4c514 100644 --- a/bd/lfs_filebd.c +++ b/bd/lfs3_filebd.c @@ -5,7 +5,7 @@ * Copyright (c) 2017, Arm Limited. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause */ -#include "bd/lfs_filebd.h" +#include "bd/lfs3_filebd.h" #include #include @@ -15,8 +15,8 @@ #include #endif -int lfs_filebd_create(const struct lfs_config *cfg, const char *path) { - LFS_FILEBD_TRACE("lfs_filebd_create(%p {.context=%p, " +int lfs3_filebd_create(const struct lfs3_config *cfg, const char *path) { + LFS3_FILEBD_TRACE("lfs3_filebd_create(%p {.context=%p, " ".read=%p, .prog=%p, .erase=%p, .sync=%p, " ".read_size=%"PRIu32", .prog_size=%"PRIu32", " ".block_size=%"PRIu32", .block_count=%"PRIu32"}, " @@ -26,7 +26,7 @@ int lfs_filebd_create(const struct lfs_config *cfg, const char *path) { (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, path, (void*)bdcfg, bdcfg->erase_value); - lfs_filebd_t *bd = cfg->context; + lfs3_filebd_t *bd = cfg->context; // open file #ifdef _WIN32 @@ -37,39 +37,39 @@ int lfs_filebd_create(const struct lfs_config *cfg, const char *path) { if (bd->fd < 0) { int err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_create -> %d", err); + LFS3_FILEBD_TRACE("lfs3_filebd_create -> %d", err); return err; } - LFS_FILEBD_TRACE("lfs_filebd_create -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_create -> %d", 0); return 0; } -int lfs_filebd_destroy(const struct lfs_config *cfg) { - LFS_FILEBD_TRACE("lfs_filebd_destroy(%p)", (void*)cfg); - lfs_filebd_t *bd = cfg->context; +int lfs3_filebd_destroy(const struct lfs3_config *cfg) { + LFS3_FILEBD_TRACE("lfs3_filebd_destroy(%p)", (void*)cfg); + lfs3_filebd_t *bd = cfg->context; int err = close(bd->fd); if (err < 0) { err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_destroy -> %d", err); + LFS3_FILEBD_TRACE("lfs3_filebd_destroy -> %d", err); return err; } - LFS_FILEBD_TRACE("lfs_filebd_destroy -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_destroy -> %d", 0); return 0; } -int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size) { - LFS_FILEBD_TRACE("lfs_filebd_read(%p, " +int lfs3_filebd_read(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size) { + LFS3_FILEBD_TRACE("lfs3_filebd_read(%p, " "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", (void*)cfg, block, off, buffer, size); - lfs_filebd_t *bd = cfg->context; + lfs3_filebd_t *bd = cfg->context; // check if read is valid - LFS_ASSERT(block < cfg->block_count); - LFS_ASSERT(off % cfg->read_size == 0); - LFS_ASSERT(size % cfg->read_size == 0); - LFS_ASSERT(off+size <= cfg->block_size); + LFS3_ASSERT(block < cfg->block_count); + LFS3_ASSERT(off % cfg->read_size == 0); + LFS3_ASSERT(size % cfg->read_size == 0); + LFS3_ASSERT(off+size <= cfg->block_size); // zero for reproducibility (in case file is truncated) memset(buffer, 0, size); @@ -79,73 +79,73 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block, (off_t)block*cfg->block_size + (off_t)off, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_read -> %d", err); + LFS3_FILEBD_TRACE("lfs3_filebd_read -> %d", err); return err; } ssize_t res2 = read(bd->fd, buffer, size); if (res2 < 0) { int err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_read -> %d", err); + LFS3_FILEBD_TRACE("lfs3_filebd_read -> %d", err); return err; } - LFS_FILEBD_TRACE("lfs_filebd_read -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_read -> %d", 0); return 0; } -int lfs_filebd_prog(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size) { - LFS_FILEBD_TRACE("lfs_filebd_prog(%p, " +int lfs3_filebd_prog(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size) { + LFS3_FILEBD_TRACE("lfs3_filebd_prog(%p, " "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", (void*)cfg, block, off, buffer, size); - lfs_filebd_t *bd = cfg->context; + lfs3_filebd_t *bd = cfg->context; // check if write is valid - LFS_ASSERT(block < cfg->block_count); - LFS_ASSERT(off % cfg->prog_size == 0); - LFS_ASSERT(size % cfg->prog_size == 0); - LFS_ASSERT(off+size <= cfg->block_size); + LFS3_ASSERT(block < cfg->block_count); + LFS3_ASSERT(off % cfg->prog_size == 0); + LFS3_ASSERT(size % cfg->prog_size == 0); + LFS3_ASSERT(off+size <= cfg->block_size); // program data off_t res1 = lseek(bd->fd, (off_t)block*cfg->block_size + (off_t)off, SEEK_SET); if (res1 < 0) { int err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_prog -> %d", err); + LFS3_FILEBD_TRACE("lfs3_filebd_prog -> %d", err); return err; } ssize_t res2 = write(bd->fd, buffer, size); if (res2 < 0) { int err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_prog -> %d", err); + LFS3_FILEBD_TRACE("lfs3_filebd_prog -> %d", err); return err; } - LFS_FILEBD_TRACE("lfs_filebd_prog -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_prog -> %d", 0); return 0; } -int lfs_filebd_erase(const struct lfs_config *cfg, lfs_block_t block) { - LFS_FILEBD_TRACE("lfs_filebd_erase(%p, 0x%"PRIx32" (%"PRIu32"))", +int lfs3_filebd_erase(const struct lfs3_config *cfg, lfs3_block_t block) { + LFS3_FILEBD_TRACE("lfs3_filebd_erase(%p, 0x%"PRIx32" (%"PRIu32"))", (void*)cfg, block, cfg->block_size); // check if erase is valid - LFS_ASSERT(block < cfg->block_count); + LFS3_ASSERT(block < cfg->block_count); // erase is a noop (void)block; - LFS_FILEBD_TRACE("lfs_filebd_erase -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_erase -> %d", 0); return 0; } -int lfs_filebd_sync(const struct lfs_config *cfg) { - LFS_FILEBD_TRACE("lfs_filebd_sync(%p)", (void*)cfg); +int lfs3_filebd_sync(const struct lfs3_config *cfg) { + LFS3_FILEBD_TRACE("lfs3_filebd_sync(%p)", (void*)cfg); // file sync - lfs_filebd_t *bd = cfg->context; + lfs3_filebd_t *bd = cfg->context; #ifdef _WIN32 int err = FlushFileBuffers((HANDLE) _get_osfhandle(bd->fd)) ? 0 : -1; #else @@ -153,10 +153,10 @@ int lfs_filebd_sync(const struct lfs_config *cfg) { #endif if (err) { err = -errno; - LFS_FILEBD_TRACE("lfs_filebd_sync -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_sync -> %d", 0); return err; } - LFS_FILEBD_TRACE("lfs_filebd_sync -> %d", 0); + LFS3_FILEBD_TRACE("lfs3_filebd_sync -> %d", 0); return 0; } diff --git a/bd/lfs3_filebd.h b/bd/lfs3_filebd.h new file mode 100644 index 00000000..846d110a --- /dev/null +++ b/bd/lfs3_filebd.h @@ -0,0 +1,56 @@ +/* + * Block device emulated in a file + * + * Copyright (c) 2022, The littlefs authors. + * Copyright (c) 2017, Arm Limited. All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef LFS3_FILEBD_H +#define LFS3_FILEBD_H + +#include "lfs3.h" +#include "lfs3_util.h" + + +// Block device specific tracing +#ifndef LFS3_FILEBD_TRACE +#ifdef LFS3_FILEBD_YES_TRACE +#define LFS3_FILEBD_TRACE(...) LFS3_TRACE(__VA_ARGS__) +#else +#define LFS3_FILEBD_TRACE(...) +#endif +#endif + +// filebd state +typedef struct lfs3_filebd { + int fd; +} lfs3_filebd_t; + + +// Create a file block device using the geometry in lfs3_config +int lfs3_filebd_create(const struct lfs3_config *cfg, const char *path); + +// Clean up memory associated with block device +int lfs3_filebd_destroy(const struct lfs3_config *cfg); + +// Read a block +int lfs3_filebd_read(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size); + +// Program a block +// +// The block must have previously been erased. +int lfs3_filebd_prog(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size); + +// Erase a block +// +// A block must be erased before being programmed. The +// state of an erased block is undefined. +int lfs3_filebd_erase(const struct lfs3_config *cfg, lfs3_block_t block); + +// Sync the block device +int lfs3_filebd_sync(const struct lfs3_config *cfg); + + +#endif diff --git a/bd/lfs3_rambd.c b/bd/lfs3_rambd.c new file mode 100644 index 00000000..2c0ff16e --- /dev/null +++ b/bd/lfs3_rambd.c @@ -0,0 +1,131 @@ +/* + * Block device emulated in RAM + * + * Copyright (c) 2022, The littlefs authors. + * Copyright (c) 2017, Arm Limited. All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + */ +#include "bd/lfs3_rambd.h" + +int lfs3_rambd_createcfg(const struct lfs3_config *cfg, + const struct lfs3_rambd_config *bdcfg) { + LFS3_RAMBD_TRACE("lfs3_rambd_createcfg(%p {.context=%p, " + ".read=%p, .prog=%p, .erase=%p, .sync=%p, " + ".read_size=%"PRIu32", .prog_size=%"PRIu32", " + ".block_size=%"PRIu32", .block_count=%"PRIu32"}, " + "%p {.buffer=%p})", + (void*)cfg, cfg->context, + (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, + (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, + cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, + (void*)bdcfg, bdcfg->buffer); + lfs3_rambd_t *bd = cfg->context; + bd->cfg = bdcfg; + + // allocate buffer? + if (bd->cfg->buffer) { + bd->buffer = bd->cfg->buffer; + } else { + bd->buffer = lfs3_malloc(cfg->block_size * cfg->block_count); + if (!bd->buffer) { + LFS3_RAMBD_TRACE("lfs3_rambd_createcfg -> %d", LFS3_ERR_NOMEM); + return LFS3_ERR_NOMEM; + } + } + + // zero for reproducibility + memset(bd->buffer, 0, cfg->block_size * cfg->block_count); + + LFS3_RAMBD_TRACE("lfs3_rambd_createcfg -> %d", 0); + return 0; +} + +int lfs3_rambd_create(const struct lfs3_config *cfg) { + LFS3_RAMBD_TRACE("lfs3_rambd_create(%p {.context=%p, " + ".read=%p, .prog=%p, .erase=%p, .sync=%p, " + ".read_size=%"PRIu32", .prog_size=%"PRIu32", " + ".block_size=%"PRIu32", .block_count=%"PRIu32"})", + (void*)cfg, cfg->context, + (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, + (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, + cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count); + static const struct lfs3_rambd_config defaults = {0}; + int err = lfs3_rambd_createcfg(cfg, &defaults); + LFS3_RAMBD_TRACE("lfs3_rambd_create -> %d", err); + return err; +} + +int lfs3_rambd_destroy(const struct lfs3_config *cfg) { + LFS3_RAMBD_TRACE("lfs3_rambd_destroy(%p)", (void*)cfg); + // clean up memory + lfs3_rambd_t *bd = cfg->context; + if (!bd->cfg->buffer) { + lfs3_free(bd->buffer); + } + LFS3_RAMBD_TRACE("lfs3_rambd_destroy -> %d", 0); + return 0; +} + +int lfs3_rambd_read(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size) { + LFS3_RAMBD_TRACE("lfs3_rambd_read(%p, " + "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", + (void*)cfg, block, off, buffer, size); + lfs3_rambd_t *bd = cfg->context; + + // check if read is valid + LFS3_ASSERT(block < cfg->block_count); + LFS3_ASSERT(off % cfg->read_size == 0); + LFS3_ASSERT(size % cfg->read_size == 0); + LFS3_ASSERT(off+size <= cfg->block_size); + + // read data + memcpy(buffer, &bd->buffer[block*cfg->block_size + off], size); + + LFS3_RAMBD_TRACE("lfs3_rambd_read -> %d", 0); + return 0; +} + +int lfs3_rambd_prog(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size) { + LFS3_RAMBD_TRACE("lfs3_rambd_prog(%p, " + "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", + (void*)cfg, block, off, buffer, size); + lfs3_rambd_t *bd = cfg->context; + + // check if write is valid + LFS3_ASSERT(block < cfg->block_count); + LFS3_ASSERT(off % cfg->prog_size == 0); + LFS3_ASSERT(size % cfg->prog_size == 0); + LFS3_ASSERT(off+size <= cfg->block_size); + + // program data + memcpy(&bd->buffer[block*cfg->block_size + off], buffer, size); + + LFS3_RAMBD_TRACE("lfs3_rambd_prog -> %d", 0); + return 0; +} + +int lfs3_rambd_erase(const struct lfs3_config *cfg, lfs3_block_t block) { + LFS3_RAMBD_TRACE("lfs3_rambd_erase(%p, 0x%"PRIx32" (%"PRIu32"))", + (void*)cfg, block, cfg->block_size); + + // check if erase is valid + LFS3_ASSERT(block < cfg->block_count); + + // erase is a noop + (void)block; + + LFS3_RAMBD_TRACE("lfs3_rambd_erase -> %d", 0); + return 0; +} + +int lfs3_rambd_sync(const struct lfs3_config *cfg) { + LFS3_RAMBD_TRACE("lfs3_rambd_sync(%p)", (void*)cfg); + + // sync is a noop + (void)cfg; + + LFS3_RAMBD_TRACE("lfs3_rambd_sync -> %d", 0); + return 0; +} diff --git a/bd/lfs3_rambd.h b/bd/lfs3_rambd.h new file mode 100644 index 00000000..3aa2ad7d --- /dev/null +++ b/bd/lfs3_rambd.h @@ -0,0 +1,65 @@ +/* + * Block device emulated in RAM + * + * Copyright (c) 2022, The littlefs authors. + * Copyright (c) 2017, Arm Limited. All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef LFS3_RAMBD_H +#define LFS3_RAMBD_H + +#include "lfs3.h" +#include "lfs3_util.h" + + +// Block device specific tracing +#ifndef LFS3_RAMBD_TRACE +#ifdef LFS3_RAMBD_YES_TRACE +#define LFS3_RAMBD_TRACE(...) LFS3_TRACE(__VA_ARGS__) +#else +#define LFS3_RAMBD_TRACE(...) +#endif +#endif + +// rambd config (optional) +struct lfs3_rambd_config { + // Optional statically allocated buffer for the block device. + void *buffer; +}; + +// rambd state +typedef struct lfs3_rambd { + uint8_t *buffer; + const struct lfs3_rambd_config *cfg; +} lfs3_rambd_t; + + +// Create a RAM block device using the geometry in lfs3_config +int lfs3_rambd_create(const struct lfs3_config *cfg); +int lfs3_rambd_createcfg(const struct lfs3_config *cfg, + const struct lfs3_rambd_config *bdcfg); + +// Clean up memory associated with block device +int lfs3_rambd_destroy(const struct lfs3_config *cfg); + +// Read a block +int lfs3_rambd_read(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size); + +// Program a block +// +// The block must have previously been erased. +int lfs3_rambd_prog(const struct lfs3_config *cfg, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size); + +// Erase a block +// +// A block must be erased before being programmed. The +// state of an erased block is undefined. +int lfs3_rambd_erase(const struct lfs3_config *cfg, lfs3_block_t block); + +// Sync the block device +int lfs3_rambd_sync(const struct lfs3_config *cfg); + + +#endif diff --git a/bd/lfs_emubd.h b/bd/lfs_emubd.h deleted file mode 100644 index f6e65d9f..00000000 --- a/bd/lfs_emubd.h +++ /dev/null @@ -1,262 +0,0 @@ -/* - * Emulating block device, wraps filebd and rambd while providing a bunch - * of hooks for testing littlefs in various conditions. - * - * Copyright (c) 2022, The littlefs authors. - * Copyright (c) 2017, Arm Limited. All rights reserved. - * SPDX-License-Identifier: BSD-3-Clause - */ -#ifndef LFS_EMUBD_H -#define LFS_EMUBD_H - -#include "lfs.h" -#include "lfs_util.h" -#include "bd/lfs_rambd.h" -#include "bd/lfs_filebd.h" - - -// Block device specific tracing -#ifndef LFS_EMUBD_TRACE -#ifdef LFS_EMUBD_YES_TRACE -#define LFS_EMUBD_TRACE(...) LFS_TRACE(__VA_ARGS__) -#else -#define LFS_EMUBD_TRACE(...) -#endif -#endif - -// Mode determining how "bad-blocks" behave during testing. This simulates -// some real-world circumstances such as progs not sticking (prog-noop), -// a readonly disk (erase-noop), ECC failures (read-error), and of course, -// random bit failures (prog-flip, read-flip) -typedef enum lfs_emubd_badblock_behavior { - LFS_EMUBD_BADBLOCK_PROGERROR = 0, // Error on prog - LFS_EMUBD_BADBLOCK_ERASEERROR = 1, // Error on erase - LFS_EMUBD_BADBLOCK_READERROR = 2, // Error on read - LFS_EMUBD_BADBLOCK_PROGNOOP = 3, // Prog does nothing silently - LFS_EMUBD_BADBLOCK_ERASENOOP = 4, // Erase does nothing silently - LFS_EMUBD_BADBLOCK_PROGFLIP = 5, // Prog flips a bit - LFS_EMUBD_BADBLOCK_READFLIP = 6, // Read flips a bit sometimes - LFS_EMUBD_BADBLOCK_MANUAL = 7, // Bits require manual flipping -} lfs_emubd_badblock_behavior_t; - -// Mode determining how power-loss behaves during testing. -typedef enum lfs_emubd_powerloss_behavior { - LFS_EMUBD_POWERLOSS_ATOMIC = 0, // Progs are atomic - LFS_EMUBD_POWERLOSS_SOMEBITS = 1, // One bit is progged - LFS_EMUBD_POWERLOSS_MOSTBITS = 2, // All-but-one bit is progged - LFS_EMUBD_POWERLOSS_OOO = 3, // Blocks are written out-of-order - LFS_EMUBD_POWERLOSS_METASTABLE = 4, // Reads may flip a bit -} lfs_emubd_powerloss_behavior_t; - -// Type for measuring read/program/erase operations -typedef uint64_t lfs_emubd_io_t; -typedef int64_t lfs_emubd_sio_t; - -// Type for measuring wear -typedef uint32_t lfs_emubd_wear_t; -typedef int32_t lfs_emubd_swear_t; - -// Type for tracking power-cycles -typedef uint32_t lfs_emubd_powercycles_t; -typedef int32_t lfs_emubd_spowercycles_t; - -// Type for delays in nanoseconds -typedef uint64_t lfs_emubd_sleep_t; -typedef int64_t lfs_emubd_ssleep_t; - -// emubd config, this is required for testing -struct lfs_emubd_config { - // 8-bit erase value to use for simulating erases. -1 simulates a noop - // erase, which is faster than simulating a fixed erase value. - int32_t erase_value; - - // Number of erase cycles before a block becomes "bad". The exact behavior - // of bad blocks is controlled by badblock_behavior. - uint32_t erase_cycles; - - // The mode determining how bad-blocks fail - lfs_emubd_badblock_behavior_t badblock_behavior; - - // Number of write operations (erase/prog) before triggering a power-loss. - // power_cycles=0 disables this. The exact behavior of power-loss is - // controlled by a combination of powerloss_behavior and powerloss_cb. - lfs_emubd_powercycles_t power_cycles; - - // The mode determining how power-loss affects disk - lfs_emubd_powerloss_behavior_t powerloss_behavior; - - // Function to call to emulate power-loss. The exact behavior of power-loss - // is up to the runner to provide. - void (*powerloss_cb)(void*); - - // Data for power-loss callback - void *powerloss_data; - - // Seed for prng, which may be used for emulating failed progs. This does - // not affect normal operation. - uint32_t seed; - - // Path to file to use as a mirror of the disk. This provides a way to view - // the current state of the block device. - const char *disk_path; - - // Artificial delay in nanoseconds, there is no purpose for this other - // than slowing down the simulation. - lfs_emubd_sleep_t read_sleep; - - // Artificial delay in nanoseconds, there is no purpose for this other - // than slowing down the simulation. - lfs_emubd_sleep_t prog_sleep; - - // Artificial delay in nanoseconds, there is no purpose for this other - // than slowing down the simulation. - lfs_emubd_sleep_t erase_sleep; -}; - -// A reference counted block -typedef struct lfs_emubd_block { - uint32_t rc; - lfs_emubd_wear_t wear; - bool metastable; - // sign(bad_bit)=0 => randomized on erase - // sign(bad_bit)=1 => fixed - lfs_size_t bad_bit; - - uint8_t data[]; -} lfs_emubd_block_t; - -// Disk mirror -typedef struct lfs_emubd_disk { - uint32_t rc; - int fd; - uint8_t *scratch; -} lfs_emubd_disk_t; - -// emubd state -typedef struct lfs_emubd { - // array of copy-on-write blocks - lfs_emubd_block_t **blocks; - - // some other test state - lfs_emubd_io_t readed; - lfs_emubd_io_t proged; - lfs_emubd_io_t erased; - uint32_t prng; - lfs_emubd_powercycles_t power_cycles; - lfs_emubd_block_t **ooo_before; - lfs_emubd_block_t **ooo_after; - lfs_emubd_disk_t *disk; - - const struct lfs_emubd_config *cfg; -} lfs_emubd_t; - - -/// Block device API /// - -// Create an emulating block device using the geometry in lfs_config -// -// Note that filebd is used if a path is provided, if path is NULL -// emubd will use rambd which can be much faster. -int lfs_emubd_create(const struct lfs_config *cfg, const char *path); -int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path, - const struct lfs_emubd_config *bdcfg); - -// Clean up memory associated with block device -int lfs_emubd_destroy(const struct lfs_config *cfg); - -// Read a block -int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size); - -// Program a block -// -// The block must have previously been erased. -int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size); - -// Erase a block -// -// A block must be erased before being programmed. The -// state of an erased block is undefined. -int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block); - -// Sync the block device -int lfs_emubd_sync(const struct lfs_config *cfg); - - -/// Additional extended API for driving test features /// - -// Set the current prng state -void lfs_emubd_seed(const struct lfs_config *cfg, uint32_t seed); - -// Get a pseudo-random number from emubd's internal prng -uint32_t lfs_emubd_prng(const struct lfs_config *cfg); - -// Get total amount of bytes read -lfs_emubd_sio_t lfs_emubd_readed(const struct lfs_config *cfg); - -// Get total amount of bytes programmed -lfs_emubd_sio_t lfs_emubd_proged(const struct lfs_config *cfg); - -// Get total amount of bytes erased -lfs_emubd_sio_t lfs_emubd_erased(const struct lfs_config *cfg); - -// Manually set amount of bytes read -int lfs_emubd_setreaded(const struct lfs_config *cfg, lfs_emubd_io_t readed); - -// Manually set amount of bytes programmed -int lfs_emubd_setproged(const struct lfs_config *cfg, lfs_emubd_io_t proged); - -// Manually set amount of bytes erased -int lfs_emubd_seterased(const struct lfs_config *cfg, lfs_emubd_io_t erased); - -// Get simulated wear on a given block -lfs_emubd_swear_t lfs_emubd_wear(const struct lfs_config *cfg, - lfs_block_t block); - -// Manually set simulated wear on a given block -int lfs_emubd_setwear(const struct lfs_config *cfg, - lfs_block_t block, lfs_emubd_wear_t wear); - -// Mark a block as bad, this is equivalent to setting wear to maximum -int lfs_emubd_markbad(const struct lfs_config *cfg, lfs_block_t block); - -// Clear any simulated wear on a given block -int lfs_emubd_markgood(const struct lfs_config *cfg, lfs_block_t block); - -// Get which bit failed, this changes on erase/power-loss unless manually set -lfs_ssize_t lfs_emubd_badbit(const struct lfs_config *cfg, - lfs_block_t block); - -// Set which bit should fail in a given block -int lfs_emubd_setbadbit(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit); - -// Randomize the bad bit on erase (the default) -int lfs_emubd_randomizebadbit(const struct lfs_config *cfg, - lfs_block_t block); - -// Mark a block as bad and which bit should fail -int lfs_emubd_markbadbit(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit); - -// Flip a bit in a given block, intended for emulating bit errors -int lfs_emubd_flipbit(const struct lfs_config *cfg, - lfs_block_t block, lfs_size_t bit); - -// Flip all bits marked as bad -int lfs_emubd_flip(const struct lfs_config *cfg); - -// Get the remaining power-cycles -lfs_emubd_spowercycles_t lfs_emubd_powercycles( - const struct lfs_config *cfg); - -// Manually set the remaining power-cycles -int lfs_emubd_setpowercycles(const struct lfs_config *cfg, - lfs_emubd_powercycles_t power_cycles); - -// Create a copy-on-write copy of the state of this block device -int lfs_emubd_cpy(const struct lfs_config *cfg, lfs_emubd_t *copy); - - -#endif diff --git a/bd/lfs_filebd.h b/bd/lfs_filebd.h deleted file mode 100644 index 45b7d9e3..00000000 --- a/bd/lfs_filebd.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Block device emulated in a file - * - * Copyright (c) 2022, The littlefs authors. - * Copyright (c) 2017, Arm Limited. All rights reserved. - * SPDX-License-Identifier: BSD-3-Clause - */ -#ifndef LFS_FILEBD_H -#define LFS_FILEBD_H - -#include "lfs.h" -#include "lfs_util.h" - - -// Block device specific tracing -#ifndef LFS_FILEBD_TRACE -#ifdef LFS_FILEBD_YES_TRACE -#define LFS_FILEBD_TRACE(...) LFS_TRACE(__VA_ARGS__) -#else -#define LFS_FILEBD_TRACE(...) -#endif -#endif - -// filebd state -typedef struct lfs_filebd { - int fd; -} lfs_filebd_t; - - -// Create a file block device using the geometry in lfs_config -int lfs_filebd_create(const struct lfs_config *cfg, const char *path); - -// Clean up memory associated with block device -int lfs_filebd_destroy(const struct lfs_config *cfg); - -// Read a block -int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size); - -// Program a block -// -// The block must have previously been erased. -int lfs_filebd_prog(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size); - -// Erase a block -// -// A block must be erased before being programmed. The -// state of an erased block is undefined. -int lfs_filebd_erase(const struct lfs_config *cfg, lfs_block_t block); - -// Sync the block device -int lfs_filebd_sync(const struct lfs_config *cfg); - - -#endif diff --git a/bd/lfs_rambd.c b/bd/lfs_rambd.c deleted file mode 100644 index ab180b93..00000000 --- a/bd/lfs_rambd.c +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Block device emulated in RAM - * - * Copyright (c) 2022, The littlefs authors. - * Copyright (c) 2017, Arm Limited. All rights reserved. - * SPDX-License-Identifier: BSD-3-Clause - */ -#include "bd/lfs_rambd.h" - -int lfs_rambd_createcfg(const struct lfs_config *cfg, - const struct lfs_rambd_config *bdcfg) { - LFS_RAMBD_TRACE("lfs_rambd_createcfg(%p {.context=%p, " - ".read=%p, .prog=%p, .erase=%p, .sync=%p, " - ".read_size=%"PRIu32", .prog_size=%"PRIu32", " - ".block_size=%"PRIu32", .block_count=%"PRIu32"}, " - "%p {.buffer=%p})", - (void*)cfg, cfg->context, - (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, - (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, - cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, - (void*)bdcfg, bdcfg->buffer); - lfs_rambd_t *bd = cfg->context; - bd->cfg = bdcfg; - - // allocate buffer? - if (bd->cfg->buffer) { - bd->buffer = bd->cfg->buffer; - } else { - bd->buffer = lfs_malloc(cfg->block_size * cfg->block_count); - if (!bd->buffer) { - LFS_RAMBD_TRACE("lfs_rambd_createcfg -> %d", LFS_ERR_NOMEM); - return LFS_ERR_NOMEM; - } - } - - // zero for reproducibility - memset(bd->buffer, 0, cfg->block_size * cfg->block_count); - - LFS_RAMBD_TRACE("lfs_rambd_createcfg -> %d", 0); - return 0; -} - -int lfs_rambd_create(const struct lfs_config *cfg) { - LFS_RAMBD_TRACE("lfs_rambd_create(%p {.context=%p, " - ".read=%p, .prog=%p, .erase=%p, .sync=%p, " - ".read_size=%"PRIu32", .prog_size=%"PRIu32", " - ".block_size=%"PRIu32", .block_count=%"PRIu32"})", - (void*)cfg, cfg->context, - (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, - (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, - cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count); - static const struct lfs_rambd_config defaults = {0}; - int err = lfs_rambd_createcfg(cfg, &defaults); - LFS_RAMBD_TRACE("lfs_rambd_create -> %d", err); - return err; -} - -int lfs_rambd_destroy(const struct lfs_config *cfg) { - LFS_RAMBD_TRACE("lfs_rambd_destroy(%p)", (void*)cfg); - // clean up memory - lfs_rambd_t *bd = cfg->context; - if (!bd->cfg->buffer) { - lfs_free(bd->buffer); - } - LFS_RAMBD_TRACE("lfs_rambd_destroy -> %d", 0); - return 0; -} - -int lfs_rambd_read(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size) { - LFS_RAMBD_TRACE("lfs_rambd_read(%p, " - "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", - (void*)cfg, block, off, buffer, size); - lfs_rambd_t *bd = cfg->context; - - // check if read is valid - LFS_ASSERT(block < cfg->block_count); - LFS_ASSERT(off % cfg->read_size == 0); - LFS_ASSERT(size % cfg->read_size == 0); - LFS_ASSERT(off+size <= cfg->block_size); - - // read data - memcpy(buffer, &bd->buffer[block*cfg->block_size + off], size); - - LFS_RAMBD_TRACE("lfs_rambd_read -> %d", 0); - return 0; -} - -int lfs_rambd_prog(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size) { - LFS_RAMBD_TRACE("lfs_rambd_prog(%p, " - "0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", - (void*)cfg, block, off, buffer, size); - lfs_rambd_t *bd = cfg->context; - - // check if write is valid - LFS_ASSERT(block < cfg->block_count); - LFS_ASSERT(off % cfg->prog_size == 0); - LFS_ASSERT(size % cfg->prog_size == 0); - LFS_ASSERT(off+size <= cfg->block_size); - - // program data - memcpy(&bd->buffer[block*cfg->block_size + off], buffer, size); - - LFS_RAMBD_TRACE("lfs_rambd_prog -> %d", 0); - return 0; -} - -int lfs_rambd_erase(const struct lfs_config *cfg, lfs_block_t block) { - LFS_RAMBD_TRACE("lfs_rambd_erase(%p, 0x%"PRIx32" (%"PRIu32"))", - (void*)cfg, block, cfg->block_size); - - // check if erase is valid - LFS_ASSERT(block < cfg->block_count); - - // erase is a noop - (void)block; - - LFS_RAMBD_TRACE("lfs_rambd_erase -> %d", 0); - return 0; -} - -int lfs_rambd_sync(const struct lfs_config *cfg) { - LFS_RAMBD_TRACE("lfs_rambd_sync(%p)", (void*)cfg); - - // sync is a noop - (void)cfg; - - LFS_RAMBD_TRACE("lfs_rambd_sync -> %d", 0); - return 0; -} diff --git a/bd/lfs_rambd.h b/bd/lfs_rambd.h deleted file mode 100644 index 00df64ff..00000000 --- a/bd/lfs_rambd.h +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Block device emulated in RAM - * - * Copyright (c) 2022, The littlefs authors. - * Copyright (c) 2017, Arm Limited. All rights reserved. - * SPDX-License-Identifier: BSD-3-Clause - */ -#ifndef LFS_RAMBD_H -#define LFS_RAMBD_H - -#include "lfs.h" -#include "lfs_util.h" - - -// Block device specific tracing -#ifndef LFS_RAMBD_TRACE -#ifdef LFS_RAMBD_YES_TRACE -#define LFS_RAMBD_TRACE(...) LFS_TRACE(__VA_ARGS__) -#else -#define LFS_RAMBD_TRACE(...) -#endif -#endif - -// rambd config (optional) -struct lfs_rambd_config { - // Optional statically allocated buffer for the block device. - void *buffer; -}; - -// rambd state -typedef struct lfs_rambd { - uint8_t *buffer; - const struct lfs_rambd_config *cfg; -} lfs_rambd_t; - - -// Create a RAM block device using the geometry in lfs_config -int lfs_rambd_create(const struct lfs_config *cfg); -int lfs_rambd_createcfg(const struct lfs_config *cfg, - const struct lfs_rambd_config *bdcfg); - -// Clean up memory associated with block device -int lfs_rambd_destroy(const struct lfs_config *cfg); - -// Read a block -int lfs_rambd_read(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size); - -// Program a block -// -// The block must have previously been erased. -int lfs_rambd_prog(const struct lfs_config *cfg, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size); - -// Erase a block -// -// A block must be erased before being programmed. The -// state of an erased block is undefined. -int lfs_rambd_erase(const struct lfs_config *cfg, lfs_block_t block); - -// Sync the block device -int lfs_rambd_sync(const struct lfs_config *cfg); - - -#endif diff --git a/lfs.c b/lfs3.c similarity index 50% rename from lfs.c rename to lfs3.c index 5e3d2a2c..60901b9e 100644 --- a/lfs.c +++ b/lfs3.c @@ -5,41 +5,41 @@ * Copyright (c) 2017, Arm Limited. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause */ -#include "lfs.h" -#include "lfs_util.h" +#include "lfs3.h" +#include "lfs3_util.h" // internally used disk-comparison enum // // note LT < EQ < GT -enum lfs_scmp { - LFS_CMP_LT = 0, // disk < query - LFS_CMP_EQ = 1, // disk = query - LFS_CMP_GT = 2, // disk > query +enum lfs3_scmp { + LFS3_CMP_LT = 0, // disk < query + LFS3_CMP_EQ = 1, // disk = query + LFS3_CMP_GT = 2, // disk > query }; -typedef int lfs_scmp_t; +typedef int lfs3_scmp_t; // this is just a hint that the function returns a bool + err union -typedef int lfs_sbool_t; +typedef int lfs3_sbool_t; /// Simple bd wrappers (asserts go here) /// -static int lfsr_bd_read__(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - void *buffer, lfs_size_t size) { +static int lfs3_bd_read__(lfs3_t *lfs3, lfs3_block_t block, lfs3_size_t off, + void *buffer, lfs3_size_t size) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); // must be aligned - LFS_ASSERT(off % lfs->cfg->read_size == 0); - LFS_ASSERT(size % lfs->cfg->read_size == 0); + LFS3_ASSERT(off % lfs3->cfg->read_size == 0); + LFS3_ASSERT(size % lfs3->cfg->read_size == 0); // bd read - int err = lfs->cfg->read(lfs->cfg, block, off, buffer, size); - LFS_ASSERT(err <= 0); + int err = lfs3->cfg->read(lfs3->cfg, block, off, buffer, size); + LFS3_ASSERT(err <= 0); if (err) { - LFS_INFO("Bad read 0x%"PRIx32".%"PRIx32" %"PRIu32" (%d)", + LFS3_INFO("Bad read 0x%"PRIx32".%"PRIx32" %"PRIu32" (%d)", block, off, size, err); return err; } @@ -47,20 +47,20 @@ static int lfsr_bd_read__(lfs_t *lfs, lfs_block_t block, lfs_size_t off, return 0; } -static int lfsr_bd_prog__(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size) { +static int lfs3_bd_prog__(lfs3_t *lfs3, lfs3_block_t block, lfs3_size_t off, + const void *buffer, lfs3_size_t size) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); // must be aligned - LFS_ASSERT(off % lfs->cfg->prog_size == 0); - LFS_ASSERT(size % lfs->cfg->prog_size == 0); + LFS3_ASSERT(off % lfs3->cfg->prog_size == 0); + LFS3_ASSERT(size % lfs3->cfg->prog_size == 0); // bd prog - int err = lfs->cfg->prog(lfs->cfg, block, off, buffer, size); - LFS_ASSERT(err <= 0); + int err = lfs3->cfg->prog(lfs3->cfg, block, off, buffer, size); + LFS3_ASSERT(err <= 0); if (err) { - LFS_INFO("Bad prog 0x%"PRIx32".%"PRIx32" %"PRIu32" (%d)", + LFS3_INFO("Bad prog 0x%"PRIx32".%"PRIx32" %"PRIu32" (%d)", block, off, size, err); return err; } @@ -68,15 +68,15 @@ static int lfsr_bd_prog__(lfs_t *lfs, lfs_block_t block, lfs_size_t off, return 0; } -static int lfsr_bd_erase__(lfs_t *lfs, lfs_block_t block) { +static int lfs3_bd_erase__(lfs3_t *lfs3, lfs3_block_t block) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); + LFS3_ASSERT(block < lfs3->block_count); // bd erase - int err = lfs->cfg->erase(lfs->cfg, block); - LFS_ASSERT(err <= 0); + int err = lfs3->cfg->erase(lfs3->cfg, block); + LFS3_ASSERT(err <= 0); if (err) { - LFS_INFO("Bad erase 0x%"PRIx32" (%d)", + LFS3_INFO("Bad erase 0x%"PRIx32" (%d)", block, err); return err; } @@ -84,12 +84,12 @@ static int lfsr_bd_erase__(lfs_t *lfs, lfs_block_t block) { return 0; } -static int lfsr_bd_sync__(lfs_t *lfs) { +static int lfs3_bd_sync__(lfs3_t *lfs3) { // bd sync - int err = lfs->cfg->sync(lfs->cfg); - LFS_ASSERT(err <= 0); + int err = lfs3->cfg->sync(lfs3->cfg); + LFS3_ASSERT(err <= 0); if (err) { - LFS_INFO("Bad sync (%d)", err); + LFS3_INFO("Bad sync (%d)", err); return err; } @@ -99,12 +99,12 @@ static int lfsr_bd_sync__(lfs_t *lfs) { /// Caching block device operations /// -static inline void lfsr_bd_droprcache(lfs_t *lfs) { - lfs->rcache.size = 0; +static inline void lfs3_bd_droprcache(lfs3_t *lfs3) { + lfs3->rcache.size = 0; } -static inline void lfsr_bd_droppcache(lfs_t *lfs) { - lfs->pcache.size = 0; +static inline void lfs3_bd_droppcache(lfs3_t *lfs3) { + lfs3->pcache.size = 0; } // caching read that lends you a buffer @@ -112,69 +112,69 @@ static inline void lfsr_bd_droppcache(lfs_t *lfs) { // note hint has two conveniences: // 0 => minimal caching // -1 => maximal caching -static int lfsr_bd_readnext(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - lfs_size_t size, - const uint8_t **buffer_, lfs_size_t *size_) { +static int lfs3_bd_readnext(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + lfs3_size_t size, + const uint8_t **buffer_, lfs3_size_t *size_) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); - lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size + lfs3_size_t hint_ = lfs3_max(hint, size); // make sure hint >= size while (true) { - lfs_size_t d = hint_; + lfs3_size_t d = hint_; // already in pcache? - if (block == lfs->pcache.block - && off < lfs->pcache.off + lfs->pcache.size) { - if (off >= lfs->pcache.off) { - *buffer_ = &lfs->pcache.buffer[off-lfs->pcache.off]; - *size_ = lfs_min( - lfs_min(d, size), - lfs->pcache.size - (off-lfs->pcache.off)); + if (block == lfs3->pcache.block + && off < lfs3->pcache.off + lfs3->pcache.size) { + if (off >= lfs3->pcache.off) { + *buffer_ = &lfs3->pcache.buffer[off-lfs3->pcache.off]; + *size_ = lfs3_min( + lfs3_min(d, size), + lfs3->pcache.size - (off-lfs3->pcache.off)); return 0; } // pcache takes priority - d = lfs_min(d, lfs->pcache.off - off); + d = lfs3_min(d, lfs3->pcache.off - off); } // already in rcache? - if (block == lfs->rcache.block - && off < lfs->rcache.off + lfs->rcache.size - && off >= lfs->rcache.off) { - *buffer_ = &lfs->rcache.buffer[off-lfs->rcache.off]; - *size_ = lfs_min( - lfs_min(d, size), - lfs->rcache.size - (off-lfs->rcache.off)); + if (block == lfs3->rcache.block + && off < lfs3->rcache.off + lfs3->rcache.size + && off >= lfs3->rcache.off) { + *buffer_ = &lfs3->rcache.buffer[off-lfs3->rcache.off]; + *size_ = lfs3_min( + lfs3_min(d, size), + lfs3->rcache.size - (off-lfs3->rcache.off)); return 0; } // drop rcache in case read fails - lfsr_bd_droprcache(lfs); + lfs3_bd_droprcache(lfs3); // load into rcache, above conditions can no longer fail // // note it's ok if we overlap the pcache a bit, pcache always // takes priority until flush, which updates the rcache - lfs_size_t off__ = lfs_aligndown(off, lfs->cfg->read_size); - lfs_size_t size__ = lfs_alignup( - lfs_min( + lfs3_size_t off__ = lfs3_aligndown(off, lfs3->cfg->read_size); + lfs3_size_t size__ = lfs3_alignup( + lfs3_min( // watch out for overflow when hint_=-1! - (off-off__) + lfs_min( + (off-off__) + lfs3_min( d, - lfs->cfg->block_size - off), - lfs->cfg->rcache_size), - lfs->cfg->read_size); - int err = lfsr_bd_read__(lfs, block, off__, - lfs->rcache.buffer, size__); + lfs3->cfg->block_size - off), + lfs3->cfg->rcache_size), + lfs3->cfg->read_size); + int err = lfs3_bd_read__(lfs3, block, off__, + lfs3->rcache.buffer, size__); if (err) { return err; } - lfs->rcache.block = block; - lfs->rcache.off = off__; - lfs->rcache.size = size__; + lfs3->rcache.block = block; + lfs3->rcache.off = off__; + lfs3->rcache.size = size__; } } @@ -183,29 +183,29 @@ static int lfsr_bd_readnext(lfs_t *lfs, // note hint has two conveniences: // 0 => minimal caching // -1 => maximal caching -static int lfsr_bd_read(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - void *buffer, lfs_size_t size) { +static int lfs3_bd_read(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + void *buffer, lfs3_size_t size) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); - lfs_size_t off_ = off; - lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size + lfs3_size_t off_ = off; + lfs3_size_t hint_ = lfs3_max(hint, size); // make sure hint >= size uint8_t *buffer_ = buffer; - lfs_size_t size_ = size; + lfs3_size_t size_ = size; while (size_ > 0) { - lfs_size_t d = hint_; + lfs3_size_t d = hint_; // already in pcache? - if (block == lfs->pcache.block - && off_ < lfs->pcache.off + lfs->pcache.size) { - if (off_ >= lfs->pcache.off) { - d = lfs_min( - lfs_min(d, size_), - lfs->pcache.size - (off_-lfs->pcache.off)); - lfs_memcpy(buffer_, - &lfs->pcache.buffer[off_-lfs->pcache.off], + if (block == lfs3->pcache.block + && off_ < lfs3->pcache.off + lfs3->pcache.size) { + if (off_ >= lfs3->pcache.off) { + d = lfs3_min( + lfs3_min(d, size_), + lfs3->pcache.size - (off_-lfs3->pcache.off)); + lfs3_memcpy(buffer_, + &lfs3->pcache.buffer[off_-lfs3->pcache.off], d); off_ += d; @@ -216,18 +216,18 @@ static int lfsr_bd_read(lfs_t *lfs, } // pcache takes priority - d = lfs_min(d, lfs->pcache.off - off_); + d = lfs3_min(d, lfs3->pcache.off - off_); } // already in rcache? - if (block == lfs->rcache.block - && off_ < lfs->rcache.off + lfs->rcache.size) { - if (off_ >= lfs->rcache.off) { - d = lfs_min( - lfs_min(d, size_), - lfs->rcache.size - (off_-lfs->rcache.off)); - lfs_memcpy(buffer_, - &lfs->rcache.buffer[off_-lfs->rcache.off], + if (block == lfs3->rcache.block + && off_ < lfs3->rcache.off + lfs3->rcache.size) { + if (off_ >= lfs3->rcache.off) { + d = lfs3_min( + lfs3_min(d, size_), + lfs3->rcache.size - (off_-lfs3->rcache.off)); + lfs3_memcpy(buffer_, + &lfs3->rcache.buffer[off_-lfs3->rcache.off], d); off_ += d; @@ -238,15 +238,15 @@ static int lfsr_bd_read(lfs_t *lfs, } // rcache takes priority - d = lfs_min(d, lfs->rcache.off - off_); + d = lfs3_min(d, lfs3->rcache.off - off_); } // bypass rcache? - if (off_ % lfs->cfg->read_size == 0 - && lfs_min(d, size_) >= lfs_min(hint_, lfs->cfg->rcache_size) - && lfs_min(d, size_) >= lfs->cfg->read_size) { - d = lfs_aligndown(size_, lfs->cfg->read_size); - int err = lfsr_bd_read__(lfs, block, off_, buffer_, d); + if (off_ % lfs3->cfg->read_size == 0 + && lfs3_min(d, size_) >= lfs3_min(hint_, lfs3->cfg->rcache_size) + && lfs3_min(d, size_) >= lfs3->cfg->read_size) { + d = lfs3_aligndown(size_, lfs3->cfg->read_size); + int err = lfs3_bd_read__(lfs3, block, off_, buffer_, d); if (err) { return err; } @@ -259,116 +259,118 @@ static int lfsr_bd_read(lfs_t *lfs, } // drop rcache in case read fails - lfsr_bd_droprcache(lfs); + lfs3_bd_droprcache(lfs3); // load into rcache, above conditions can no longer fail // // note it's ok if we overlap the pcache a bit, pcache always // takes priority until flush, which updates the rcache - lfs_size_t off__ = lfs_aligndown(off_, lfs->cfg->read_size); - lfs_size_t size__ = lfs_alignup( - lfs_min( + lfs3_size_t off__ = lfs3_aligndown(off_, lfs3->cfg->read_size); + lfs3_size_t size__ = lfs3_alignup( + lfs3_min( // watch out for overflow when hint_=-1! - (off_-off__) + lfs_min( - lfs_min(hint_, d), - lfs->cfg->block_size - off_), - lfs->cfg->rcache_size), - lfs->cfg->read_size); - int err = lfsr_bd_read__(lfs, block, off__, - lfs->rcache.buffer, size__); + (off_-off__) + lfs3_min( + lfs3_min(hint_, d), + lfs3->cfg->block_size - off_), + lfs3->cfg->rcache_size), + lfs3->cfg->read_size); + int err = lfs3_bd_read__(lfs3, block, off__, + lfs3->rcache.buffer, size__); if (err) { return err; } - lfs->rcache.block = block; - lfs->rcache.off = off__; - lfs->rcache.size = size__; + lfs3->rcache.block = block; + lfs3->rcache.off = off__; + lfs3->rcache.size = size__; } return 0; } -// needed in lfsr_bd_prog_ for prog validation -#ifdef LFS_CKPROGS -static inline bool lfsr_m_isckprogs(uint32_t flags); +// needed in lfs3_bd_prog_ for prog validation +#ifdef LFS3_CKPROGS +static inline bool lfs3_m_isckprogs(uint32_t flags); #endif -static lfs_scmp_t lfsr_bd_cmp(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - const void *buffer, lfs_size_t size); +static lfs3_scmp_t lfs3_bd_cmp(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + const void *buffer, lfs3_size_t size); // low-level prog stuff -static int lfsr_bd_prog_(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size, +static int lfs3_bd_prog_(lfs3_t *lfs3, lfs3_block_t block, lfs3_size_t off, + const void *buffer, lfs3_size_t size, uint32_t *cksum, bool align) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); // prog to disk - int err = lfsr_bd_prog__(lfs, block, off, buffer, size); + int err = lfs3_bd_prog__(lfs3, block, off, buffer, size); if (err) { return err; } - #ifdef LFS_CKPROGS + #ifdef LFS3_CKPROGS // checking progs? - if (lfsr_m_isckprogs(lfs->flags)) { + if (lfs3_m_isckprogs(lfs3->flags)) { // pcache should have been dropped at this point - LFS_ASSERT(lfs->pcache.size == 0); + LFS3_ASSERT(lfs3->pcache.size == 0); // invalidate rcache, we're going to clobber it anyways - lfsr_bd_droprcache(lfs); + lfs3_bd_droprcache(lfs3); - lfs_scmp_t cmp = lfsr_bd_cmp(lfs, block, off, 0, + lfs3_scmp_t cmp = lfs3_bd_cmp(lfs3, block, off, 0, buffer, size); if (cmp < 0) { return cmp; } - if (cmp != LFS_CMP_EQ) { - LFS_WARN("Found ckprog mismatch 0x%"PRIx32".%"PRIx32" %"PRId32, + if (cmp != LFS3_CMP_EQ) { + LFS3_WARN("Found ckprog mismatch 0x%"PRIx32".%"PRIx32" %"PRId32, block, off, size); - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } } #endif // update rcache if we can - if (block == lfs->rcache.block - && off <= lfs->rcache.off + lfs->rcache.size) { - lfs->rcache.off = lfs_min(off, lfs->rcache.off); - lfs->rcache.size = lfs_min( - (off-lfs->rcache.off) + size, - lfs->cfg->rcache_size); - lfs_memcpy(&lfs->rcache.buffer[off-lfs->rcache.off], + if (block == lfs3->rcache.block + && off <= lfs3->rcache.off + lfs3->rcache.size) { + lfs3->rcache.off = lfs3_min(off, lfs3->rcache.off); + lfs3->rcache.size = lfs3_min( + (off-lfs3->rcache.off) + size, + lfs3->cfg->rcache_size); + lfs3_memcpy(&lfs3->rcache.buffer[off-lfs3->rcache.off], buffer, - lfs->rcache.size - (off-lfs->rcache.off)); + lfs3->rcache.size - (off-lfs3->rcache.off)); } // optional aligned checksum if (cksum && align) { - *cksum = lfs_crc32c(*cksum, buffer, size); + *cksum = lfs3_crc32c(*cksum, buffer, size); } return 0; } // flush the pcache -static int lfsr_bd_flush(lfs_t *lfs, uint32_t *cksum, bool align) { - if (lfs->pcache.size != 0) { +static int lfs3_bd_flush(lfs3_t *lfs3, uint32_t *cksum, bool align) { + if (lfs3->pcache.size != 0) { // must be in-bounds - LFS_ASSERT(lfs->pcache.block < lfs->block_count); + LFS3_ASSERT(lfs3->pcache.block < lfs3->block_count); // must be aligned - LFS_ASSERT(lfs->pcache.off % lfs->cfg->prog_size == 0); - lfs_size_t size = lfs_alignup(lfs->pcache.size, lfs->cfg->prog_size); + LFS3_ASSERT(lfs3->pcache.off % lfs3->cfg->prog_size == 0); + lfs3_size_t size = lfs3_alignup( + lfs3->pcache.size, + lfs3->cfg->prog_size); // make this cache available, if we error anything in this cache // would be useless anyways - lfsr_bd_droppcache(lfs); + lfs3_bd_droppcache(lfs3); // flush - int err = lfsr_bd_prog_(lfs, lfs->pcache.block, - lfs->pcache.off, lfs->pcache.buffer, size, + int err = lfs3_bd_prog_(lfs3, lfs3->pcache.block, + lfs3->pcache.off, lfs3->pcache.buffer, size, cksum, align); if (err) { return err; @@ -381,85 +383,85 @@ static int lfsr_bd_flush(lfs_t *lfs, uint32_t *cksum, bool align) { // caching prog that lends you a buffer // // with optional checksum -static int lfsr_bd_prognext(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - lfs_size_t size, - uint8_t **buffer_, lfs_size_t *size_, +static int lfs3_bd_prognext(lfs3_t *lfs3, lfs3_block_t block, lfs3_size_t off, + lfs3_size_t size, + uint8_t **buffer_, lfs3_size_t *size_, uint32_t *cksum, bool align) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); while (true) { // active pcache? - if (lfs->pcache.block == block - && lfs->pcache.size != 0) { + if (lfs3->pcache.block == block + && lfs3->pcache.size != 0) { // fits in pcache? - if (off < lfs->pcache.off + lfs->cfg->pcache_size) { + if (off < lfs3->pcache.off + lfs3->cfg->pcache_size) { // you can't prog backwards silly - LFS_ASSERT(off >= lfs->pcache.off); + LFS3_ASSERT(off >= lfs3->pcache.off); // expand the pcache? - lfs->pcache.size = lfs_min( - (off-lfs->pcache.off) + size, - lfs->cfg->pcache_size); + lfs3->pcache.size = lfs3_min( + (off-lfs3->pcache.off) + size, + lfs3->cfg->pcache_size); - *buffer_ = &lfs->pcache.buffer[off-lfs->pcache.off]; - *size_ = lfs_min( + *buffer_ = &lfs3->pcache.buffer[off-lfs3->pcache.off]; + *size_ = lfs3_min( size, - lfs->pcache.size - (off-lfs->pcache.off)); + lfs3->pcache.size - (off-lfs3->pcache.off)); return 0; } // flush pcache? - int err = lfsr_bd_flush(lfs, cksum, align); + int err = lfs3_bd_flush(lfs3, cksum, align); if (err) { return err; } } // move the pcache, above conditions can no longer fail - lfs->pcache.block = block; - lfs->pcache.off = lfs_aligndown(off, lfs->cfg->prog_size); - lfs->pcache.size = lfs_min( - (off-lfs->pcache.off) + size, - lfs->cfg->pcache_size); + lfs3->pcache.block = block; + lfs3->pcache.off = lfs3_aligndown(off, lfs3->cfg->prog_size); + lfs3->pcache.size = lfs3_min( + (off-lfs3->pcache.off) + size, + lfs3->cfg->pcache_size); // zero to avoid any information leaks - lfs_memset(lfs->pcache.buffer, 0xff, lfs->cfg->pcache_size); + lfs3_memset(lfs3->pcache.buffer, 0xff, lfs3->cfg->pcache_size); } } // caching prog // // with optional checksum -static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size, +static int lfs3_bd_prog(lfs3_t *lfs3, lfs3_block_t block, lfs3_size_t off, + const void *buffer, lfs3_size_t size, uint32_t *cksum, bool align) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); - lfs_size_t off_ = off; + lfs3_size_t off_ = off; const uint8_t *buffer_ = buffer; - lfs_size_t size_ = size; + lfs3_size_t size_ = size; while (size_ > 0) { // active pcache? - if (lfs->pcache.block == block - && lfs->pcache.size != 0) { + if (lfs3->pcache.block == block + && lfs3->pcache.size != 0) { // fits in pcache? - if (off_ < lfs->pcache.off + lfs->cfg->pcache_size) { + if (off_ < lfs3->pcache.off + lfs3->cfg->pcache_size) { // you can't prog backwards silly - LFS_ASSERT(off_ >= lfs->pcache.off); + LFS3_ASSERT(off_ >= lfs3->pcache.off); // expand the pcache? - lfs->pcache.size = lfs_min( - (off_-lfs->pcache.off) + size_, - lfs->cfg->pcache_size); + lfs3->pcache.size = lfs3_min( + (off_-lfs3->pcache.off) + size_, + lfs3->cfg->pcache_size); - lfs_size_t d = lfs_min( + lfs3_size_t d = lfs3_min( size_, - lfs->pcache.size - (off_-lfs->pcache.off)); - lfs_memcpy(&lfs->pcache.buffer[off_-lfs->pcache.off], + lfs3->pcache.size - (off_-lfs3->pcache.off)); + lfs3_memcpy(&lfs3->pcache.buffer[off_-lfs3->pcache.off], buffer_, d); @@ -473,17 +475,17 @@ static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off, // // flush even if we're bypassing pcache, some devices don't // support out-of-order progs in a block - int err = lfsr_bd_flush(lfs, cksum, align); + int err = lfs3_bd_flush(lfs3, cksum, align); if (err) { return err; } } // bypass pcache? - if (off_ % lfs->cfg->prog_size == 0 - && size_ >= lfs->cfg->pcache_size) { - lfs_size_t d = lfs_aligndown(size_, lfs->cfg->prog_size); - int err = lfsr_bd_prog_(lfs, block, off_, buffer_, d, + if (off_ % lfs3->cfg->prog_size == 0 + && size_ >= lfs3->cfg->pcache_size) { + lfs3_size_t d = lfs3_aligndown(size_, lfs3->cfg->prog_size); + int err = lfs3_bd_prog_(lfs3, block, off_, buffer_, d, cksum, align); if (err) { return err; @@ -496,73 +498,73 @@ static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off, } // move the pcache, above conditions can no longer fail - lfs->pcache.block = block; - lfs->pcache.off = lfs_aligndown(off_, lfs->cfg->prog_size); - lfs->pcache.size = lfs_min( - (off_-lfs->pcache.off) + size_, - lfs->cfg->pcache_size); + lfs3->pcache.block = block; + lfs3->pcache.off = lfs3_aligndown(off_, lfs3->cfg->prog_size); + lfs3->pcache.size = lfs3_min( + (off_-lfs3->pcache.off) + size_, + lfs3->cfg->pcache_size); // zero to avoid any information leaks - lfs_memset(lfs->pcache.buffer, 0xff, lfs->cfg->pcache_size); + lfs3_memset(lfs3->pcache.buffer, 0xff, lfs3->cfg->pcache_size); } // optional checksum if (cksum && !align) { - *cksum = lfs_crc32c(*cksum, buffer, size); + *cksum = lfs3_crc32c(*cksum, buffer, size); } return 0; } -static int lfsr_bd_sync(lfs_t *lfs) { +static int lfs3_bd_sync(lfs3_t *lfs3) { // make sure we flush any caches - int err = lfsr_bd_flush(lfs, NULL, false); + int err = lfs3_bd_flush(lfs3, NULL, false); if (err) { return err; } - return lfsr_bd_sync__(lfs); + return lfs3_bd_sync__(lfs3); } -static int lfsr_bd_erase(lfs_t *lfs, lfs_block_t block) { +static int lfs3_bd_erase(lfs3_t *lfs3, lfs3_block_t block) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); + LFS3_ASSERT(block < lfs3->block_count); // invalidate any relevant caches - if (lfs->pcache.block == block) { - lfsr_bd_droppcache(lfs); + if (lfs3->pcache.block == block) { + lfs3_bd_droppcache(lfs3); } - if (lfs->rcache.block == block) { - lfsr_bd_droprcache(lfs); + if (lfs3->rcache.block == block) { + lfs3_bd_droprcache(lfs3); } - return lfsr_bd_erase__(lfs, block); + return lfs3_bd_erase__(lfs3, block); } // other block device utils -static int lfsr_bd_cksum(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - lfs_size_t size, +static int lfs3_bd_cksum(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + lfs3_size_t size, uint32_t *cksum) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); - lfs_size_t off_ = off; - lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size - lfs_size_t size_ = size; + lfs3_size_t off_ = off; + lfs3_size_t hint_ = lfs3_max(hint, size); // make sure hint >= size + lfs3_size_t size_ = size; while (size_ > 0) { const uint8_t *buffer__; - lfs_size_t size__; - int err = lfsr_bd_readnext(lfs, block, off_, hint_, size_, + lfs3_size_t size__; + int err = lfs3_bd_readnext(lfs3, block, off_, hint_, size_, &buffer__, &size__); if (err) { return err; } - *cksum = lfs_crc32c(*cksum, buffer__, size__); + *cksum = lfs3_crc32c(*cksum, buffer__, size__); off_ += size__; hint_ -= size__; @@ -572,29 +574,29 @@ static int lfsr_bd_cksum(lfs_t *lfs, return 0; } -static lfs_scmp_t lfsr_bd_cmp(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - const void *buffer, lfs_size_t size) { +static lfs3_scmp_t lfs3_bd_cmp(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + const void *buffer, lfs3_size_t size) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); - lfs_size_t off_ = off; - lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size + lfs3_size_t off_ = off; + lfs3_size_t hint_ = lfs3_max(hint, size); // make sure hint >= size const uint8_t *buffer_ = buffer; - lfs_size_t size_ = size; + lfs3_size_t size_ = size; while (size_ > 0) { const uint8_t *buffer__; - lfs_size_t size__; - int err = lfsr_bd_readnext(lfs, block, off_, hint_, size_, + lfs3_size_t size__; + int err = lfs3_bd_readnext(lfs3, block, off_, hint_, size_, &buffer__, &size__); if (err) { return err; } - int cmp = lfs_memcmp(buffer__, buffer_, size__); + int cmp = lfs3_memcmp(buffer__, buffer_, size__); if (cmp != 0) { - return (cmp < 0) ? LFS_CMP_LT : LFS_CMP_GT; + return (cmp < 0) ? LFS3_CMP_LT : LFS3_CMP_GT; } off_ += size__; @@ -603,38 +605,38 @@ static lfs_scmp_t lfsr_bd_cmp(lfs_t *lfs, size_ -= size__; } - return LFS_CMP_EQ; + return LFS3_CMP_EQ; } -static int lfsr_bd_cpy(lfs_t *lfs, - lfs_block_t dst_block, lfs_size_t dst_off, - lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint, - lfs_size_t size, +static int lfs3_bd_cpy(lfs3_t *lfs3, + lfs3_block_t dst_block, lfs3_size_t dst_off, + lfs3_block_t src_block, lfs3_size_t src_off, lfs3_size_t hint, + lfs3_size_t size, uint32_t *cksum, bool align) { // must be in-bounds - LFS_ASSERT(dst_block < lfs->block_count); - LFS_ASSERT(dst_off+size <= lfs->cfg->block_size); - LFS_ASSERT(src_block < lfs->block_count); - LFS_ASSERT(src_off+size <= lfs->cfg->block_size); + LFS3_ASSERT(dst_block < lfs3->block_count); + LFS3_ASSERT(dst_off+size <= lfs3->cfg->block_size); + LFS3_ASSERT(src_block < lfs3->block_count); + LFS3_ASSERT(src_off+size <= lfs3->cfg->block_size); - lfs_size_t dst_off_ = dst_off; - lfs_size_t src_off_ = src_off; - lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size - lfs_size_t size_ = size; + lfs3_size_t dst_off_ = dst_off; + lfs3_size_t src_off_ = src_off; + lfs3_size_t hint_ = lfs3_max(hint, size); // make sure hint >= size + lfs3_size_t size_ = size; while (size_ > 0) { // prefer the pcache here to avoid rcache conflicts with prog // validation, if we're lucky we might even be able to avoid // clobbering the rcache at all uint8_t *buffer__; - lfs_size_t size__; - int err = lfsr_bd_prognext(lfs, dst_block, dst_off_, size_, + lfs3_size_t size__; + int err = lfs3_bd_prognext(lfs3, dst_block, dst_off_, size_, &buffer__, &size__, cksum, align); if (err) { return err; } - err = lfsr_bd_read(lfs, src_block, src_off_, hint_, + err = lfs3_bd_read(lfs3, src_block, src_off_, hint_, buffer__, size__); if (err) { return err; @@ -642,7 +644,7 @@ static int lfsr_bd_cpy(lfs_t *lfs, // optional checksum if (cksum && !align) { - *cksum = lfs_crc32c(*cksum, buffer__, size__); + *cksum = lfs3_crc32c(*cksum, buffer__, size__); } dst_off_ += size__; @@ -654,30 +656,30 @@ static int lfsr_bd_cpy(lfs_t *lfs, return 0; } -static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - uint8_t c, lfs_size_t size, +static int lfs3_bd_set(lfs3_t *lfs3, lfs3_block_t block, lfs3_size_t off, + uint8_t c, lfs3_size_t size, uint32_t *cksum, bool align) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(off+size <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(off+size <= lfs3->cfg->block_size); - lfs_size_t off_ = off; - lfs_size_t size_ = size; + lfs3_size_t off_ = off; + lfs3_size_t size_ = size; while (size_ > 0) { uint8_t *buffer__; - lfs_size_t size__; - int err = lfsr_bd_prognext(lfs, block, off_, size_, + lfs3_size_t size__; + int err = lfs3_bd_prognext(lfs3, block, off_, size_, &buffer__, &size__, cksum, align); if (err) { return err; } - lfs_memset(buffer__, c, size__); + lfs3_memset(buffer__, c, size__); // optional checksum if (cksum && !align) { - *cksum = lfs_crc32c(*cksum, buffer__, size__); + *cksum = lfs3_crc32c(*cksum, buffer__, size__); } off_ += size__; @@ -688,51 +690,51 @@ static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off, } -// lfsr_ptail_t stuff +// lfs3_ptail_t stuff // // ptail tracks the most recent trunk's parity so we can parity-check // if it hasn't been written to disk yet -#ifdef LFS_CKMETAPARITY -#define LFSR_PTAIL_PARITY 0x80000000 +#ifdef LFS3_CKMETAPARITY +#define LFS3_PTAIL_PARITY 0x80000000 #endif -#ifdef LFS_CKMETAPARITY -static inline bool lfsr_ptail_parity(const lfs_t *lfs) { - return lfs->ptail.off & LFSR_PTAIL_PARITY; +#ifdef LFS3_CKMETAPARITY +static inline bool lfs3_ptail_parity(const lfs3_t *lfs3) { + return lfs3->ptail.off & LFS3_PTAIL_PARITY; } #endif -#ifdef LFS_CKMETAPARITY -static inline lfs_size_t lfsr_ptail_off(const lfs_t *lfs) { - return lfs->ptail.off & ~LFSR_PTAIL_PARITY; +#ifdef LFS3_CKMETAPARITY +static inline lfs3_size_t lfs3_ptail_off(const lfs3_t *lfs3) { + return lfs3->ptail.off & ~LFS3_PTAIL_PARITY; } #endif // checked read helpers -#ifdef LFS_CKDATACKSUMREADS -static int lfsr_bd_ckprefix(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - lfs_size_t cksize, uint32_t cksum, - lfs_size_t *hint_, +#ifdef LFS3_CKDATACKSUMREADS +static int lfs3_bd_ckprefix(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + lfs3_size_t cksize, uint32_t cksum, + lfs3_size_t *hint_, uint32_t *cksum__) { (void)cksum; // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(cksize <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(cksize <= lfs3->cfg->block_size); // make sure hint includes our prefix/suffix - lfs_size_t hint__ = lfs_max( + lfs3_size_t hint__ = lfs3_max( // watch out for overflow when hint=-1! - off + lfs_min( + off + lfs3_min( hint, - lfs->cfg->block_size - off), + lfs3->cfg->block_size - off), cksize); // checksum any prefixed data - int err = lfsr_bd_cksum(lfs, + int err = lfs3_bd_cksum(lfs3, block, 0, hint__, off, cksum__); @@ -747,17 +749,17 @@ static int lfsr_bd_ckprefix(lfs_t *lfs, } #endif -#ifdef LFS_CKDATACKSUMREADS -static int lfsr_bd_cksuffix(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - lfs_size_t cksize, uint32_t cksum, +#ifdef LFS3_CKDATACKSUMREADS +static int lfs3_bd_cksuffix(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + lfs3_size_t cksize, uint32_t cksum, uint32_t cksum__) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(cksize <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(cksize <= lfs3->cfg->block_size); // checksum any suffixed data - int err = lfsr_bd_cksum(lfs, + int err = lfs3_bd_cksum(lfs3, block, off, hint, cksize - off, &cksum__); @@ -767,12 +769,12 @@ static int lfsr_bd_cksuffix(lfs_t *lfs, // do checksums match? if (cksum__ != cksum) { - LFS_ERROR("Found ckdatacksums mismatch " + LFS3_ERROR("Found ckdatacksums mismatch " "0x%"PRIx32".%"PRIx32" %"PRId32", " "cksum %08"PRIx32" (!= %08"PRIx32")", block, 0, cksize, cksum__, cksum); - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } return 0; @@ -782,27 +784,27 @@ static int lfsr_bd_cksuffix(lfs_t *lfs, // checked read functions -#ifdef LFS_CKDATACKSUMREADS +#ifdef LFS3_CKDATACKSUMREADS // caching read with parity/checksum checks // // the main downside of checking reads is we need to read all data that // contributes to the relevant parity/checksum, this may be // significantly more than the data we actually end up using // -static int lfsr_bd_readck(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - void *buffer, lfs_size_t size, - lfs_size_t cksize, uint32_t cksum) { +static int lfs3_bd_readck(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + void *buffer, lfs3_size_t size, + lfs3_size_t cksize, uint32_t cksum) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(cksize <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(cksize <= lfs3->cfg->block_size); // read should fit in ck info - LFS_ASSERT(off+size <= cksize); + LFS3_ASSERT(off+size <= cksize); // checksum any prefixed data uint32_t cksum__ = 0; - lfs_size_t hint_; - int err = lfsr_bd_ckprefix(lfs, block, off, hint, + lfs3_size_t hint_; + int err = lfs3_bd_ckprefix(lfs3, block, off, hint, cksize, cksum, &hint_, &cksum__); @@ -811,17 +813,17 @@ static int lfsr_bd_readck(lfs_t *lfs, } // read and checksum the data we're interested in - err = lfsr_bd_read(lfs, + err = lfs3_bd_read(lfs3, block, off, hint_, buffer, size); if (err) { return err; } - cksum__ = lfs_crc32c(cksum__, buffer, size); + cksum__ = lfs3_crc32c(cksum__, buffer, size); // checksum any suffixed data and validate - err = lfsr_bd_cksuffix(lfs, block, off+size, hint_-size, + err = lfs3_bd_cksuffix(lfs3, block, off+size, hint_-size, cksize, cksum, cksum__); if (err) { @@ -836,23 +838,23 @@ static int lfsr_bd_readck(lfs_t *lfs, // unchecked counterparts, but we don't generally use both at the same // time // -// we'd also need to worry about early termination in lfsr_bd_cmp/cmpck +// we'd also need to worry about early termination in lfs3_bd_cmp/cmpck -#ifdef LFS_CKDATACKSUMREADS -static lfs_scmp_t lfsr_bd_cmpck(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - const void *buffer, lfs_size_t size, - lfs_size_t cksize, uint32_t cksum) { +#ifdef LFS3_CKDATACKSUMREADS +static lfs3_scmp_t lfs3_bd_cmpck(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + const void *buffer, lfs3_size_t size, + lfs3_size_t cksize, uint32_t cksum) { // must be in-bounds - LFS_ASSERT(block < lfs->block_count); - LFS_ASSERT(cksize <= lfs->cfg->block_size); + LFS3_ASSERT(block < lfs3->block_count); + LFS3_ASSERT(cksize <= lfs3->cfg->block_size); // read should fit in ck info - LFS_ASSERT(off+size <= cksize); + LFS3_ASSERT(off+size <= cksize); // checksum any prefixed data uint32_t cksum__ = 0; - lfs_size_t hint_; - int err = lfsr_bd_ckprefix(lfs, block, off, hint, + lfs3_size_t hint_; + int err = lfs3_bd_ckprefix(lfs3, block, off, hint, cksize, cksum, &hint_, &cksum__); @@ -861,26 +863,26 @@ static lfs_scmp_t lfsr_bd_cmpck(lfs_t *lfs, } // compare the data while simultaneously updating the checksum - lfs_size_t off_ = off; - lfs_size_t hint__ = hint_ - off; + lfs3_size_t off_ = off; + lfs3_size_t hint__ = hint_ - off; const uint8_t *buffer_ = buffer; - lfs_size_t size_ = size; - int cmp = LFS_CMP_EQ; + lfs3_size_t size_ = size; + int cmp = LFS3_CMP_EQ; while (size_ > 0) { const uint8_t *buffer__; - lfs_size_t size__; - err = lfsr_bd_readnext(lfs, block, off_, hint__, size_, + lfs3_size_t size__; + err = lfs3_bd_readnext(lfs3, block, off_, hint__, size_, &buffer__, &size__); if (err) { return err; } - cksum__ = lfs_crc32c(cksum__, buffer__, size__); + cksum__ = lfs3_crc32c(cksum__, buffer__, size__); - if (cmp == LFS_CMP_EQ) { - int cmp_ = lfs_memcmp(buffer__, buffer_, size__); + if (cmp == LFS3_CMP_EQ) { + int cmp_ = lfs3_memcmp(buffer__, buffer_, size__); if (cmp_ != 0) { - cmp = (cmp_ < 0) ? LFS_CMP_LT : LFS_CMP_GT; + cmp = (cmp_ < 0) ? LFS3_CMP_LT : LFS3_CMP_GT; } } @@ -891,7 +893,7 @@ static lfs_scmp_t lfsr_bd_cmpck(lfs_t *lfs, } // checksum any suffixed data and validate - err = lfsr_bd_cksuffix(lfs, block, off+size, hint_-size, + err = lfs3_bd_cksuffix(lfs3, block, off+size, hint_-size, cksize, cksum, cksum__); if (err) { @@ -902,25 +904,25 @@ static lfs_scmp_t lfsr_bd_cmpck(lfs_t *lfs, } #endif -#ifdef LFS_CKDATACKSUMREADS -static int lfsr_bd_cpyck(lfs_t *lfs, - lfs_block_t dst_block, lfs_size_t dst_off, - lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint, - lfs_size_t size, - lfs_size_t src_cksize, uint32_t src_cksum, +#ifdef LFS3_CKDATACKSUMREADS +static int lfs3_bd_cpyck(lfs3_t *lfs3, + lfs3_block_t dst_block, lfs3_size_t dst_off, + lfs3_block_t src_block, lfs3_size_t src_off, lfs3_size_t hint, + lfs3_size_t size, + lfs3_size_t src_cksize, uint32_t src_cksum, uint32_t *cksum, bool align) { // must be in-bounds - LFS_ASSERT(dst_block < lfs->block_count); - LFS_ASSERT(dst_off+size <= lfs->cfg->block_size); - LFS_ASSERT(src_block < lfs->block_count); - LFS_ASSERT(src_cksize <= lfs->cfg->block_size); + LFS3_ASSERT(dst_block < lfs3->block_count); + LFS3_ASSERT(dst_off+size <= lfs3->cfg->block_size); + LFS3_ASSERT(src_block < lfs3->block_count); + LFS3_ASSERT(src_cksize <= lfs3->cfg->block_size); // read should fit in ck info - LFS_ASSERT(src_off+size <= src_cksize); + LFS3_ASSERT(src_off+size <= src_cksize); // checksum any prefixed data uint32_t cksum__ = 0; - lfs_size_t hint_; - int err = lfsr_bd_ckprefix(lfs, src_block, src_off, hint, + lfs3_size_t hint_; + int err = lfs3_bd_ckprefix(lfs3, src_block, src_off, hint, src_cksize, src_cksum, &hint_, &cksum__); @@ -929,35 +931,35 @@ static int lfsr_bd_cpyck(lfs_t *lfs, } // copy the data while simultaneously updating our checksum - lfs_size_t dst_off_ = dst_off; - lfs_size_t src_off_ = src_off; - lfs_size_t hint__ = hint_; - lfs_size_t size_ = size; + lfs3_size_t dst_off_ = dst_off; + lfs3_size_t src_off_ = src_off; + lfs3_size_t hint__ = hint_; + lfs3_size_t size_ = size; while (size_ > 0) { // prefer the pcache here to avoid rcache conflicts with prog // validation, if we're lucky we might even be able to avoid // clobbering the rcache at all uint8_t *buffer__; - lfs_size_t size__; - err = lfsr_bd_prognext(lfs, dst_block, dst_off_, size_, + lfs3_size_t size__; + err = lfs3_bd_prognext(lfs3, dst_block, dst_off_, size_, &buffer__, &size__, cksum, align); if (err) { return err; } - err = lfsr_bd_read(lfs, src_block, src_off_, hint__, + err = lfs3_bd_read(lfs3, src_block, src_off_, hint__, buffer__, size__); if (err) { return err; } // validating checksum - cksum__ = lfs_crc32c(cksum__, buffer__, size__); + cksum__ = lfs3_crc32c(cksum__, buffer__, size__); // optional prog checksum if (cksum && !align) { - *cksum = lfs_crc32c(*cksum, buffer__, size__); + *cksum = lfs3_crc32c(*cksum, buffer__, size__); } dst_off_ += size__; @@ -967,7 +969,7 @@ static int lfsr_bd_cpyck(lfs_t *lfs, } // checksum any suffixed data and validate - err = lfsr_bd_cksuffix(lfs, src_block, src_off+size, hint_-size, + err = lfs3_bd_cksuffix(lfs3, src_block, src_off+size, hint_-size, src_cksize, src_cksum, cksum__); if (err) { @@ -981,264 +983,264 @@ static int lfsr_bd_cpyck(lfs_t *lfs, -/// lfsr_tag_t stuff /// +/// lfs3_tag_t stuff /// // 16-bit metadata tags -enum lfsr_tag { +enum lfs3_tag { // the null tag is reserved - LFSR_TAG_NULL = 0x0000, + LFS3_TAG_NULL = 0x0000, // config tags - LFSR_TAG_CONFIG = 0x0000, - LFSR_TAG_MAGIC = 0x0031, - LFSR_TAG_VERSION = 0x0034, - LFSR_TAG_RCOMPAT = 0x0035, - LFSR_TAG_WCOMPAT = 0x0036, - LFSR_TAG_OCOMPAT = 0x0037, - LFSR_TAG_GEOMETRY = 0x0038, - LFSR_TAG_NAMELIMIT = 0x0039, - LFSR_TAG_FILELIMIT = 0x003a, + LFS3_TAG_CONFIG = 0x0000, + LFS3_TAG_MAGIC = 0x0031, + LFS3_TAG_VERSION = 0x0034, + LFS3_TAG_RCOMPAT = 0x0035, + LFS3_TAG_WCOMPAT = 0x0036, + LFS3_TAG_OCOMPAT = 0x0037, + LFS3_TAG_GEOMETRY = 0x0038, + LFS3_TAG_NAMELIMIT = 0x0039, + LFS3_TAG_FILELIMIT = 0x003a, // in-device only, to help find unknown config tags - LFSR_TAG_UNKNOWNCONFIG = 0x003b, + LFS3_TAG_UNKNOWNCONFIG = 0x003b, // global-state tags - LFSR_TAG_GDELTA = 0x0100, - LFSR_TAG_GRMDELTA = 0x0100, + LFS3_TAG_GDELTA = 0x0100, + LFS3_TAG_GRMDELTA = 0x0100, // name tags - LFSR_TAG_NAME = 0x0200, - LFSR_TAG_BNAME = 0x0200, - LFSR_TAG_REG = 0x0201, - LFSR_TAG_DIR = 0x0202, - LFSR_TAG_STICKYNOTE = 0x0203, - LFSR_TAG_BOOKMARK = 0x0204, + LFS3_TAG_NAME = 0x0200, + LFS3_TAG_BNAME = 0x0200, + LFS3_TAG_REG = 0x0201, + LFS3_TAG_DIR = 0x0202, + LFS3_TAG_STICKYNOTE = 0x0203, + LFS3_TAG_BOOKMARK = 0x0204, // in-device only name tags, these should never get written to disk - LFSR_TAG_ORPHAN = 0x0205, - LFSR_TAG_TRAVERSAL = 0x0206, - LFSR_TAG_UNKNOWN = 0x0207, + LFS3_TAG_ORPHAN = 0x0205, + LFS3_TAG_TRAVERSAL = 0x0206, + LFS3_TAG_UNKNOWN = 0x0207, // non-file name tags - LFSR_TAG_MNAME = 0x0220, + LFS3_TAG_MNAME = 0x0220, // struct tags - LFSR_TAG_STRUCT = 0x0300, - LFSR_TAG_BRANCH = 0x0300, - LFSR_TAG_DATA = 0x0304, - LFSR_TAG_BLOCK = 0x0308, - LFSR_TAG_DID = 0x0314, - LFSR_TAG_BSHRUB = 0x0318, - LFSR_TAG_BTREE = 0x031c, - LFSR_TAG_MROOT = 0x0321, - LFSR_TAG_MDIR = 0x0325, - LFSR_TAG_MTREE = 0x032c, + LFS3_TAG_STRUCT = 0x0300, + LFS3_TAG_BRANCH = 0x0300, + LFS3_TAG_DATA = 0x0304, + LFS3_TAG_BLOCK = 0x0308, + LFS3_TAG_DID = 0x0314, + LFS3_TAG_BSHRUB = 0x0318, + LFS3_TAG_BTREE = 0x031c, + LFS3_TAG_MROOT = 0x0321, + LFS3_TAG_MDIR = 0x0325, + LFS3_TAG_MTREE = 0x032c, // user/sys attributes - LFSR_TAG_ATTR = 0x0400, - LFSR_TAG_UATTR = 0x0400, - LFSR_TAG_SATTR = 0x0500, + LFS3_TAG_ATTR = 0x0400, + LFS3_TAG_UATTR = 0x0400, + LFS3_TAG_SATTR = 0x0500, // shrub tags belong to secondary trees - LFSR_TAG_SHRUB = 0x1000, + LFS3_TAG_SHRUB = 0x1000, // alt pointers form the inner nodes of our rbyd trees - LFSR_TAG_ALT = 0x4000, - LFSR_TAG_B = 0x0000, - LFSR_TAG_R = 0x2000, - LFSR_TAG_LE = 0x0000, - LFSR_TAG_GT = 0x1000, + LFS3_TAG_ALT = 0x4000, + LFS3_TAG_B = 0x0000, + LFS3_TAG_R = 0x2000, + LFS3_TAG_LE = 0x0000, + LFS3_TAG_GT = 0x1000, // checksum tags - LFSR_TAG_CKSUM = 0x3000, - LFSR_TAG_PHASE = 0x0003, - LFSR_TAG_PERTURB = 0x0004, - LFSR_TAG_NOTE = 0x3100, - LFSR_TAG_ECKSUM = 0x3200, - LFSR_TAG_GCKSUMDELTA = 0x3300, + LFS3_TAG_CKSUM = 0x3000, + LFS3_TAG_PHASE = 0x0003, + LFS3_TAG_PERTURB = 0x0004, + LFS3_TAG_NOTE = 0x3100, + LFS3_TAG_ECKSUM = 0x3200, + LFS3_TAG_GCKSUMDELTA = 0x3300, // in-device only tags, these should never get written to disk - LFSR_TAG_INTERNAL = 0x0800, - LFSR_TAG_RATTRS = 0x0800, - LFSR_TAG_SHRUBCOMMIT = 0x0801, - LFSR_TAG_GRMPUSH = 0x0802, - LFSR_TAG_MOVE = 0x0803, - LFSR_TAG_ATTRS = 0x0804, + LFS3_TAG_INTERNAL = 0x0800, + LFS3_TAG_RATTRS = 0x0800, + LFS3_TAG_SHRUBCOMMIT = 0x0801, + LFS3_TAG_GRMPUSH = 0x0802, + LFS3_TAG_MOVE = 0x0803, + LFS3_TAG_ATTRS = 0x0804, // some in-device only tag modifiers - LFSR_TAG_RM = 0x8000, - LFSR_TAG_GROW = 0x4000, - LFSR_TAG_MASK0 = 0x0000, - LFSR_TAG_MASK2 = 0x1000, - LFSR_TAG_MASK8 = 0x2000, - LFSR_TAG_MASK12 = 0x3000, + LFS3_TAG_RM = 0x8000, + LFS3_TAG_GROW = 0x4000, + LFS3_TAG_MASK0 = 0x0000, + LFS3_TAG_MASK2 = 0x1000, + LFS3_TAG_MASK8 = 0x2000, + LFS3_TAG_MASK12 = 0x3000, }; // some other tag encodings with their own subfields -#define LFSR_TAG_ALT(c, d, key) \ - (LFSR_TAG_ALT \ +#define LFS3_TAG_ALT(c, d, key) \ + (LFS3_TAG_ALT \ | (0x2000 & (c)) \ | (0x1000 & (d)) \ - | (0x0fff & (lfsr_tag_t)(key))) + | (0x0fff & (lfs3_tag_t)(key))) -#define LFSR_TAG_ATTR(attr) \ - (LFSR_TAG_ATTR \ - | ((0x80 & (lfsr_tag_t)(attr)) << 1) \ - | (0x7f & (lfsr_tag_t)(attr))) +#define LFS3_TAG_ATTR(attr) \ + (LFS3_TAG_ATTR \ + | ((0x80 & (lfs3_tag_t)(attr)) << 1) \ + | (0x7f & (lfs3_tag_t)(attr))) // tag type operations -static inline lfsr_tag_t lfsr_tag_mode(lfsr_tag_t tag) { +static inline lfs3_tag_t lfs3_tag_mode(lfs3_tag_t tag) { return tag & 0xf000; } -static inline lfsr_tag_t lfsr_tag_suptype(lfsr_tag_t tag) { +static inline lfs3_tag_t lfs3_tag_suptype(lfs3_tag_t tag) { return tag & 0xff00; } -static inline uint8_t lfsr_tag_subtype(lfsr_tag_t tag) { +static inline uint8_t lfs3_tag_subtype(lfs3_tag_t tag) { return tag & 0x00ff; } -static inline lfsr_tag_t lfsr_tag_key(lfsr_tag_t tag) { +static inline lfs3_tag_t lfs3_tag_key(lfs3_tag_t tag) { return tag & 0x0fff; } -static inline lfsr_tag_t lfsr_tag_supkey(lfsr_tag_t tag) { +static inline lfs3_tag_t lfs3_tag_supkey(lfs3_tag_t tag) { return tag & 0x0f00; } -static inline lfsr_tag_t lfsr_tag_subkey(lfsr_tag_t tag) { +static inline lfs3_tag_t lfs3_tag_subkey(lfs3_tag_t tag) { return tag & 0x00ff; } -static inline uint8_t lfsr_tag_redund(lfsr_tag_t tag) { +static inline uint8_t lfs3_tag_redund(lfs3_tag_t tag) { return tag & 0x0003; } -static inline bool lfsr_tag_isalt(lfsr_tag_t tag) { - return tag & LFSR_TAG_ALT; +static inline bool lfs3_tag_isalt(lfs3_tag_t tag) { + return tag & LFS3_TAG_ALT; } -static inline bool lfsr_tag_isshrub(lfsr_tag_t tag) { - return tag & LFSR_TAG_SHRUB; +static inline bool lfs3_tag_isshrub(lfs3_tag_t tag) { + return tag & LFS3_TAG_SHRUB; } -static inline bool lfsr_tag_istrunk(lfsr_tag_t tag) { - return lfsr_tag_mode(tag) != LFSR_TAG_CKSUM; +static inline bool lfs3_tag_istrunk(lfs3_tag_t tag) { + return lfs3_tag_mode(tag) != LFS3_TAG_CKSUM; } -static inline uint8_t lfsr_tag_phase(lfsr_tag_t tag) { - return tag & LFSR_TAG_PHASE; +static inline uint8_t lfs3_tag_phase(lfs3_tag_t tag) { + return tag & LFS3_TAG_PHASE; } -static inline bool lfsr_tag_perturb(lfsr_tag_t tag) { - return tag & LFSR_TAG_PERTURB; +static inline bool lfs3_tag_perturb(lfs3_tag_t tag) { + return tag & LFS3_TAG_PERTURB; } -static inline bool lfsr_tag_isinternal(lfsr_tag_t tag) { - return tag & LFSR_TAG_INTERNAL; +static inline bool lfs3_tag_isinternal(lfs3_tag_t tag) { + return tag & LFS3_TAG_INTERNAL; } -static inline bool lfsr_tag_isrm(lfsr_tag_t tag) { - return tag & LFSR_TAG_RM; +static inline bool lfs3_tag_isrm(lfs3_tag_t tag) { + return tag & LFS3_TAG_RM; } -static inline bool lfsr_tag_isgrow(lfsr_tag_t tag) { - return tag & LFSR_TAG_GROW; +static inline bool lfs3_tag_isgrow(lfs3_tag_t tag) { + return tag & LFS3_TAG_GROW; } -static inline bool lfsr_tag_ismask0(lfsr_tag_t tag) { +static inline bool lfs3_tag_ismask0(lfs3_tag_t tag) { return ((tag >> 12) & 0x3) == 0; } -static inline bool lfsr_tag_ismask2(lfsr_tag_t tag) { +static inline bool lfs3_tag_ismask2(lfs3_tag_t tag) { return ((tag >> 12) & 0x3) == 1; } -static inline bool lfsr_tag_ismask8(lfsr_tag_t tag) { +static inline bool lfs3_tag_ismask8(lfs3_tag_t tag) { return ((tag >> 12) & 0x3) == 2; } -static inline bool lfsr_tag_ismask12(lfsr_tag_t tag) { +static inline bool lfs3_tag_ismask12(lfs3_tag_t tag) { return ((tag >> 12) & 0x3) == 3; } -static inline lfsr_tag_t lfsr_tag_mask(lfsr_tag_t tag) { +static inline lfs3_tag_t lfs3_tag_mask(lfs3_tag_t tag) { return 0x0fff & (-1U << ((0xc820 >> (4*((tag >> 12) & 0x3))) & 0xf)); } // alt operations -static inline bool lfsr_tag_isblack(lfsr_tag_t tag) { - return !(tag & LFSR_TAG_R); +static inline bool lfs3_tag_isblack(lfs3_tag_t tag) { + return !(tag & LFS3_TAG_R); } -static inline bool lfsr_tag_isred(lfsr_tag_t tag) { - return tag & LFSR_TAG_R; +static inline bool lfs3_tag_isred(lfs3_tag_t tag) { + return tag & LFS3_TAG_R; } -static inline bool lfsr_tag_isle(lfsr_tag_t tag) { - return !(tag & LFSR_TAG_GT); +static inline bool lfs3_tag_isle(lfs3_tag_t tag) { + return !(tag & LFS3_TAG_GT); } -static inline bool lfsr_tag_isgt(lfsr_tag_t tag) { - return tag & LFSR_TAG_GT; +static inline bool lfs3_tag_isgt(lfs3_tag_t tag) { + return tag & LFS3_TAG_GT; } -static inline lfsr_tag_t lfsr_tag_isparallel(lfsr_tag_t a, lfsr_tag_t b) { - return (a & LFSR_TAG_GT) == (b & LFSR_TAG_GT); +static inline lfs3_tag_t lfs3_tag_isparallel(lfs3_tag_t a, lfs3_tag_t b) { + return (a & LFS3_TAG_GT) == (b & LFS3_TAG_GT); } -static inline bool lfsr_tag_follow( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid, - lfsr_srid_t rid, lfsr_tag_t tag) { +static inline bool lfs3_tag_follow( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid, + lfs3_srid_t rid, lfs3_tag_t tag) { // null tags break the following logic for unreachable alts - LFS_ASSERT(lfsr_tag_key(tag) != 0); + LFS3_ASSERT(lfs3_tag_key(tag) != 0); - if (lfsr_tag_isgt(alt)) { - return rid > upper_rid - (lfsr_srid_t)weight - 1 - || (rid == upper_rid - (lfsr_srid_t)weight - 1 - && lfsr_tag_key(tag) > lfsr_tag_key(alt)); + if (lfs3_tag_isgt(alt)) { + return rid > upper_rid - (lfs3_srid_t)weight - 1 + || (rid == upper_rid - (lfs3_srid_t)weight - 1 + && lfs3_tag_key(tag) > lfs3_tag_key(alt)); } else { - return rid < lower_rid + (lfsr_srid_t)weight - 1 - || (rid == lower_rid + (lfsr_srid_t)weight - 1 - && lfsr_tag_key(tag) <= lfsr_tag_key(alt)); + return rid < lower_rid + (lfs3_srid_t)weight - 1 + || (rid == lower_rid + (lfs3_srid_t)weight - 1 + && lfs3_tag_key(tag) <= lfs3_tag_key(alt)); } } -static inline bool lfsr_tag_follow2( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_tag_t alt2, lfsr_rid_t weight2, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid, - lfsr_srid_t rid, lfsr_tag_t tag) { - if (lfsr_tag_isred(alt2) && lfsr_tag_isparallel(alt, alt2)) { +static inline bool lfs3_tag_follow2( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_tag_t alt2, lfs3_rid_t weight2, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid, + lfs3_srid_t rid, lfs3_tag_t tag) { + if (lfs3_tag_isred(alt2) && lfs3_tag_isparallel(alt, alt2)) { weight += weight2; } - return lfsr_tag_follow(alt, weight, lower_rid, upper_rid, rid, tag); + return lfs3_tag_follow(alt, weight, lower_rid, upper_rid, rid, tag); } -static inline void lfsr_tag_flip( - lfsr_tag_t *alt, lfsr_rid_t *weight, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid) { - *alt = *alt ^ LFSR_TAG_GT; +static inline void lfs3_tag_flip( + lfs3_tag_t *alt, lfs3_rid_t *weight, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid) { + *alt = *alt ^ LFS3_TAG_GT; *weight = (upper_rid - lower_rid) - *weight; } -static inline void lfsr_tag_flip2( - lfsr_tag_t *alt, lfsr_rid_t *weight, - lfsr_tag_t alt2, lfsr_rid_t weight2, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid) { - if (lfsr_tag_isred(alt2)) { +static inline void lfs3_tag_flip2( + lfs3_tag_t *alt, lfs3_rid_t *weight, + lfs3_tag_t alt2, lfs3_rid_t weight2, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid) { + if (lfs3_tag_isred(alt2)) { *weight += weight2; } - lfsr_tag_flip(alt, weight, lower_rid, upper_rid); + lfs3_tag_flip(alt, weight, lower_rid, upper_rid); } -static inline void lfsr_tag_trim( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_srid_t *lower_rid, lfsr_srid_t *upper_rid, - lfsr_tag_t *lower_tag, lfsr_tag_t *upper_tag) { - LFS_ASSERT((lfsr_srid_t)weight >= 0); - if (lfsr_tag_isgt(alt)) { +static inline void lfs3_tag_trim( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_srid_t *lower_rid, lfs3_srid_t *upper_rid, + lfs3_tag_t *lower_tag, lfs3_tag_t *upper_tag) { + LFS3_ASSERT((lfs3_srid_t)weight >= 0); + if (lfs3_tag_isgt(alt)) { *upper_rid -= weight; if (upper_tag) { *upper_tag = alt + 1; @@ -1251,86 +1253,86 @@ static inline void lfsr_tag_trim( } } -static inline void lfsr_tag_trim2( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_tag_t alt2, lfsr_rid_t weight2, - lfsr_srid_t *lower_rid, lfsr_srid_t *upper_rid, - lfsr_tag_t *lower_tag, lfsr_tag_t *upper_tag) { - if (lfsr_tag_isred(alt2)) { - lfsr_tag_trim( +static inline void lfs3_tag_trim2( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_tag_t alt2, lfs3_rid_t weight2, + lfs3_srid_t *lower_rid, lfs3_srid_t *upper_rid, + lfs3_tag_t *lower_tag, lfs3_tag_t *upper_tag) { + if (lfs3_tag_isred(alt2)) { + lfs3_tag_trim( alt2, weight2, lower_rid, upper_rid, lower_tag, upper_tag); } - lfsr_tag_trim( + lfs3_tag_trim( alt, weight, lower_rid, upper_rid, lower_tag, upper_tag); } -static inline bool lfsr_tag_unreachable( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid, - lfsr_tag_t lower_tag, lfsr_tag_t upper_tag) { - if (lfsr_tag_isgt(alt)) { - return !lfsr_tag_follow( +static inline bool lfs3_tag_unreachable( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid, + lfs3_tag_t lower_tag, lfs3_tag_t upper_tag) { + if (lfs3_tag_isgt(alt)) { + return !lfs3_tag_follow( alt, weight, lower_rid, upper_rid, upper_rid-1, upper_tag-1); } else { - return !lfsr_tag_follow( + return !lfs3_tag_follow( alt, weight, lower_rid, upper_rid, lower_rid-1, lower_tag+1); } } -static inline bool lfsr_tag_unreachable2( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_tag_t alt2, lfsr_rid_t weight2, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid, - lfsr_tag_t lower_tag, lfsr_tag_t upper_tag) { - if (lfsr_tag_isred(alt2)) { - lfsr_tag_trim( +static inline bool lfs3_tag_unreachable2( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_tag_t alt2, lfs3_rid_t weight2, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid, + lfs3_tag_t lower_tag, lfs3_tag_t upper_tag) { + if (lfs3_tag_isred(alt2)) { + lfs3_tag_trim( alt2, weight2, &lower_rid, &upper_rid, &lower_tag, &upper_tag); } - return lfsr_tag_unreachable( + return lfs3_tag_unreachable( alt, weight, lower_rid, upper_rid, lower_tag, upper_tag); } -static inline bool lfsr_tag_diverging( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid, - lfsr_srid_t a_rid, lfsr_tag_t a_tag, - lfsr_srid_t b_rid, lfsr_tag_t b_tag) { - return lfsr_tag_follow( +static inline bool lfs3_tag_diverging( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid, + lfs3_srid_t a_rid, lfs3_tag_t a_tag, + lfs3_srid_t b_rid, lfs3_tag_t b_tag) { + return lfs3_tag_follow( alt, weight, lower_rid, upper_rid, a_rid, a_tag) - != lfsr_tag_follow( + != lfs3_tag_follow( alt, weight, lower_rid, upper_rid, b_rid, b_tag); } -static inline bool lfsr_tag_diverging2( - lfsr_tag_t alt, lfsr_rid_t weight, - lfsr_tag_t alt2, lfsr_rid_t weight2, - lfsr_srid_t lower_rid, lfsr_srid_t upper_rid, - lfsr_srid_t a_rid, lfsr_tag_t a_tag, - lfsr_srid_t b_rid, lfsr_tag_t b_tag) { - return lfsr_tag_follow2( +static inline bool lfs3_tag_diverging2( + lfs3_tag_t alt, lfs3_rid_t weight, + lfs3_tag_t alt2, lfs3_rid_t weight2, + lfs3_srid_t lower_rid, lfs3_srid_t upper_rid, + lfs3_srid_t a_rid, lfs3_tag_t a_tag, + lfs3_srid_t b_rid, lfs3_tag_t b_tag) { + return lfs3_tag_follow2( alt, weight, alt2, weight2, lower_rid, upper_rid, a_rid, a_tag) - != lfsr_tag_follow2( + != lfs3_tag_follow2( alt, weight, alt2, weight2, lower_rid, upper_rid, @@ -1345,25 +1347,25 @@ static inline bool lfsr_tag_diverging2( // | tag | weight | size | weight: 1 leb128 <=5 bytes // '---+---+---+- -+- -+- -+- -+---+- -+- -+- -' size: 1 leb128 <=4 bytes // total: <=11 bytes -#define LFSR_TAG_DSIZE (2+5+4) +#define LFS3_TAG_DSIZE (2+5+4) -// needed in lfsr_bd_readtag -#ifdef LFS_CKMETAPARITY -static inline bool lfsr_m_isckparity(uint32_t flags); +// needed in lfs3_bd_readtag +#ifdef LFS3_CKMETAPARITY +static inline bool lfs3_m_isckparity(uint32_t flags); #endif -static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - lfsr_tag_t *tag_, lfsr_rid_t *weight_, lfs_size_t *size_, +static lfs3_ssize_t lfs3_bd_readtag(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_size_t hint, + lfs3_tag_t *tag_, lfs3_rid_t *weight_, lfs3_size_t *size_, uint32_t *cksum) { // read the largest possible tag size - uint8_t tag_buf[LFSR_TAG_DSIZE]; - lfs_size_t tag_dsize = lfs_min(LFSR_TAG_DSIZE, lfs->cfg->block_size-off); + uint8_t tag_buf[LFS3_TAG_DSIZE]; + lfs3_size_t tag_dsize = lfs3_min(LFS3_TAG_DSIZE, lfs3->cfg->block_size-off); if (tag_dsize < 4) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } - int err = lfsr_bd_read(lfs, block, off, hint, + int err = lfs3_bd_read(lfs3, block, off, hint, tag_buf, tag_dsize); if (err < 0) { return err; @@ -1376,75 +1378,75 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, // // fortunately crc32cs are parity-preserving, so this is the // same as the parity of the checksum - if ((tag_buf[0] >> 7) != lfs_parity(*cksum)) { - return LFS_ERR_CORRUPT; + if ((tag_buf[0] >> 7) != lfs3_parity(*cksum)) { + return LFS3_ERR_CORRUPT; } } - lfsr_tag_t tag - = ((lfsr_tag_t)tag_buf[0] << 8) - | ((lfsr_tag_t)tag_buf[1] << 0); - lfs_ssize_t d = 2; + lfs3_tag_t tag + = ((lfs3_tag_t)tag_buf[0] << 8) + | ((lfs3_tag_t)tag_buf[1] << 0); + lfs3_ssize_t d = 2; - lfsr_rid_t weight; - lfs_ssize_t d_ = lfs_fromleb128(&weight, &tag_buf[d], tag_dsize-d); + lfs3_rid_t weight; + lfs3_ssize_t d_ = lfs3_fromleb128(&weight, &tag_buf[d], tag_dsize-d); if (d_ < 0) { return d_; } // weights should be limited to 31-bits if (weight > 0x7fffffff) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } d += d_; - lfs_size_t size; - d_ = lfs_fromleb128(&size, &tag_buf[d], tag_dsize-d); + lfs3_size_t size; + d_ = lfs3_fromleb128(&size, &tag_buf[d], tag_dsize-d); if (d_ < 0) { return d_; } // sizes should be limited to 28-bits if (size > 0x0fffffff) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } d += d_; // check our tag does not go out of bounds - if (!lfsr_tag_isalt(tag) && off+d + size > lfs->cfg->block_size) { - return LFS_ERR_CORRUPT; + if (!lfs3_tag_isalt(tag) && off+d + size > lfs3->cfg->block_size) { + return LFS3_ERR_CORRUPT; } - #ifdef LFS_CKMETAPARITY + #ifdef LFS3_CKMETAPARITY // check the parity if we're checking parity // // this requires reading all of the data as well, but with any luck // the data will stick around in the cache - if (lfsr_m_isckparity(lfs->flags) + if (lfs3_m_isckparity(lfs3->flags) // don't bother checking parity if we're already calculating // a checksum && !cksum) { // checksum the tag, including our valid bit - uint32_t cksum_ = lfs_crc32c(0, tag_buf, d); + uint32_t cksum_ = lfs3_crc32c(0, tag_buf, d); // checksum the data, if we have any - lfs_size_t hint_ = hint - lfs_min(d, hint); - lfs_size_t d_ = d; - if (!lfsr_tag_isalt(tag)) { - err = lfsr_bd_cksum(lfs, + lfs3_size_t hint_ = hint - lfs3_min(d, hint); + lfs3_size_t d_ = d; + if (!lfs3_tag_isalt(tag)) { + err = lfs3_bd_cksum(lfs3, // make sure hint includes our pesky parity byte - block, off+d_, lfs_max(hint_, size+1), + block, off+d_, lfs3_max(hint_, size+1), size, &cksum_); if (err) { return err; } - hint_ -= lfs_min(size, hint_); + hint_ -= lfs3_min(size, hint_); d_ += size; } // pesky parity byte - if (off+d_ > lfs->cfg->block_size-1) { - return LFS_ERR_CORRUPT; + if (off+d_ > lfs3->cfg->block_size-1) { + return LFS3_ERR_CORRUPT; } // read the pesky parity byte @@ -1458,13 +1460,13 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, // parity in in ptail? bool parity; - if (block == lfs->ptail.block && off+d_ == lfsr_ptail_off(lfs)) { - parity = lfsr_ptail_parity(lfs); + if (block == lfs3->ptail.block && off+d_ == lfs3_ptail_off(lfs3)) { + parity = lfs3_ptail_parity(lfs3); // parity on disk? } else { uint8_t p; - err = lfsr_bd_read(lfs, block, off+d_, hint_, + err = lfs3_bd_read(lfs3, block, off+d_, hint_, &p, 1); if (err) { return err; @@ -1474,13 +1476,13 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, } // does parity match? - if (lfs_parity(cksum_) != parity) { - LFS_ERROR("Found ckparity mismatch " + if (lfs3_parity(cksum_) != parity) { + LFS3_ERROR("Found ckparity mismatch " "0x%"PRIx32".%"PRIx32" %"PRId32", " "parity %01"PRIx32" (!= %01"PRIx32")", block, off, d_, - lfs_parity(cksum_), parity); - return LFS_ERR_CORRUPT; + lfs3_parity(cksum_), parity); + return LFS3_ERR_CORRUPT; } } #endif @@ -1490,7 +1492,7 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, // exclude valid bit from checksum *cksum ^= tag_buf[0] & 0x00000080; // calculate checksum - *cksum = lfs_crc32c(*cksum, tag_buf, d); + *cksum = lfs3_crc32c(*cksum, tag_buf, d); } // save what we found, clearing the valid bit, we don't need it @@ -1501,45 +1503,45 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, return d; } -static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, bool perturb, - lfsr_tag_t tag, lfsr_rid_t weight, lfs_size_t size, +static lfs3_ssize_t lfs3_bd_progtag(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, bool perturb, + lfs3_tag_t tag, lfs3_rid_t weight, lfs3_size_t size, uint32_t *cksum, bool align) { // we set the valid bit here - LFS_ASSERT(!(tag & 0x8000)); + LFS3_ASSERT(!(tag & 0x8000)); // bit 7 is reserved for future subtype extensions - LFS_ASSERT(!(tag & 0x80)); + LFS3_ASSERT(!(tag & 0x80)); // weight should not exceed 31-bits - LFS_ASSERT(weight <= 0x7fffffff); + LFS3_ASSERT(weight <= 0x7fffffff); // size should not exceed 28-bits - LFS_ASSERT(size <= 0x0fffffff); + LFS3_ASSERT(size <= 0x0fffffff); // set the valid bit to the parity of the current checksum, inverted // if the perturb bit is set, and exclude from the next checksum - LFS_ASSERT(cksum); - bool v = lfs_parity(*cksum) ^ perturb; - tag |= (lfsr_tag_t)v << 15; + LFS3_ASSERT(cksum); + bool v = lfs3_parity(*cksum) ^ perturb; + tag |= (lfs3_tag_t)v << 15; *cksum ^= (uint32_t)v << 7; // encode into a be16 and pair of leb128s - uint8_t tag_buf[LFSR_TAG_DSIZE]; + uint8_t tag_buf[LFS3_TAG_DSIZE]; tag_buf[0] = (uint8_t)(tag >> 8); tag_buf[1] = (uint8_t)(tag >> 0); - lfs_ssize_t d = 2; + lfs3_ssize_t d = 2; - lfs_ssize_t d_ = lfs_toleb128(weight, &tag_buf[d], 5); + lfs3_ssize_t d_ = lfs3_toleb128(weight, &tag_buf[d], 5); if (d_ < 0) { return d_; } d += d_; - d_ = lfs_toleb128(size, &tag_buf[d], 4); + d_ = lfs3_toleb128(size, &tag_buf[d], 4); if (d_ < 0) { return d_; } d += d_; - int err = lfsr_bd_prog(lfs, block, off, tag_buf, d, + int err = lfs3_bd_prog(lfs3, block, off, tag_buf, d, cksum, align); if (err < 0) { return err; @@ -1549,152 +1551,152 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs, } -/// lfsr_data_t stuff /// +/// lfs3_data_t stuff /// -#define LFSR_DATA_ONDISK 0x80000000 -#define LFSR_DATA_ISBPTR 0x40000000 +#define LFS3_DATA_ONDISK 0x80000000 +#define LFS3_DATA_ISBPTR 0x40000000 -#ifdef LFS_CKDATACKSUMREADS -#define LFSR_DATA_ISERASED 0x80000000 +#ifdef LFS3_CKDATACKSUMREADS +#define LFS3_DATA_ISERASED 0x80000000 #endif -#define LFSR_DATA_NULL() \ - ((lfsr_data_t){ \ +#define LFS3_DATA_NULL() \ + ((lfs3_data_t){ \ .size=0, \ .u.buffer=NULL}) -#define LFSR_DATA_BUF(_buffer, _size) \ - ((lfsr_data_t){ \ +#define LFS3_DATA_BUF(_buffer, _size) \ + ((lfs3_data_t){ \ .size=_size, \ .u.buffer=(const void*)(_buffer)}) -#define LFSR_DATA_DISK(_block, _off, _size) \ - ((lfsr_data_t){ \ - .size=LFSR_DATA_ONDISK | (_size), \ +#define LFS3_DATA_DISK(_block, _off, _size) \ + ((lfs3_data_t){ \ + .size=LFS3_DATA_ONDISK | (_size), \ .u.disk.block=_block, \ .u.disk.off=_off}) // data helpers -static inline bool lfsr_data_ondisk(lfsr_data_t data) { - return data.size & LFSR_DATA_ONDISK; +static inline bool lfs3_data_ondisk(lfs3_data_t data) { + return data.size & LFS3_DATA_ONDISK; } -static inline bool lfsr_data_isbuf(lfsr_data_t data) { - return !(data.size & LFSR_DATA_ONDISK); +static inline bool lfs3_data_isbuf(lfs3_data_t data) { + return !(data.size & LFS3_DATA_ONDISK); } -static inline bool lfsr_data_isbptr(lfsr_data_t data) { - return data.size & LFSR_DATA_ISBPTR; +static inline bool lfs3_data_isbptr(lfs3_data_t data) { + return data.size & LFS3_DATA_ISBPTR; } -static inline lfs_size_t lfsr_data_size(lfsr_data_t data) { - return data.size & ~LFSR_DATA_ONDISK & ~LFSR_DATA_ISBPTR; +static inline lfs3_size_t lfs3_data_size(lfs3_data_t data) { + return data.size & ~LFS3_DATA_ONDISK & ~LFS3_DATA_ISBPTR; } -#ifdef LFS_CKDATACKSUMREADS -static inline lfs_size_t lfsr_data_cksize(lfsr_data_t data) { - return data.u.disk.cksize & ~LFSR_DATA_ISERASED; +#ifdef LFS3_CKDATACKSUMREADS +static inline lfs3_size_t lfs3_data_cksize(lfs3_data_t data) { + return data.u.disk.cksize & ~LFS3_DATA_ISERASED; } #endif -#ifdef LFS_CKDATACKSUMREADS -static inline uint32_t lfsr_data_cksum(lfsr_data_t data) { +#ifdef LFS3_CKDATACKSUMREADS +static inline uint32_t lfs3_data_cksum(lfs3_data_t data) { return data.u.disk.cksum; } #endif // data slicing -#define LFSR_DATA_SLICE(_data, _off, _size) \ - ((struct {lfsr_data_t d;}){lfsr_data_fromslice(_data, _off, _size)}.d) +#define LFS3_DATA_SLICE(_data, _off, _size) \ + ((struct {lfs3_data_t d;}){lfs3_data_fromslice(_data, _off, _size)}.d) -LFS_FORCEINLINE -static inline lfsr_data_t lfsr_data_fromslice(lfsr_data_t data, - lfs_ssize_t off, lfs_ssize_t size) { +LFS3_FORCEINLINE +static inline lfs3_data_t lfs3_data_fromslice(lfs3_data_t data, + lfs3_ssize_t off, lfs3_ssize_t size) { // limit our off/size to data range, note the use of unsigned casts // here to treat -1 as unbounded - lfs_size_t off_ = lfs_min( - lfs_smax(off, 0), - lfsr_data_size(data)); - lfs_size_t size_ = lfs_min( - (lfs_size_t)size, - lfsr_data_size(data) - off_); + lfs3_size_t off_ = lfs3_min( + lfs3_smax(off, 0), + lfs3_data_size(data)); + lfs3_size_t size_ = lfs3_min( + (lfs3_size_t)size, + lfs3_data_size(data) - off_); // on-disk? - if (lfsr_data_ondisk(data)) { + if (lfs3_data_ondisk(data)) { data.u.disk.off += off_; - data.size -= lfsr_data_size(data) - size_; + data.size -= lfs3_data_size(data) - size_; // buffer? } else { data.u.buffer += off_; - data.size -= lfsr_data_size(data) - size_; + data.size -= lfs3_data_size(data) - size_; } return data; } -#define LFSR_DATA_TRUNCATE(_data, _size) \ - ((struct {lfsr_data_t d;}){lfsr_data_fromtruncate(_data, _size)}.d) +#define LFS3_DATA_TRUNCATE(_data, _size) \ + ((struct {lfs3_data_t d;}){lfs3_data_fromtruncate(_data, _size)}.d) -LFS_FORCEINLINE -static inline lfsr_data_t lfsr_data_fromtruncate(lfsr_data_t data, - lfs_size_t size) { - return LFSR_DATA_SLICE(data, -1, size); +LFS3_FORCEINLINE +static inline lfs3_data_t lfs3_data_fromtruncate(lfs3_data_t data, + lfs3_size_t size) { + return LFS3_DATA_SLICE(data, -1, size); } -#define LFSR_DATA_FRUNCATE(_data, _size) \ - ((struct {lfsr_data_t d;}){lfsr_data_fromfruncate(_data, _size)}.d) +#define LFS3_DATA_FRUNCATE(_data, _size) \ + ((struct {lfs3_data_t d;}){lfs3_data_fromfruncate(_data, _size)}.d) -LFS_FORCEINLINE -static inline lfsr_data_t lfsr_data_fromfruncate(lfsr_data_t data, - lfs_size_t size) { - return LFSR_DATA_SLICE(data, - lfsr_data_size(data) - lfs_min( +LFS3_FORCEINLINE +static inline lfs3_data_t lfs3_data_fromfruncate(lfs3_data_t data, + lfs3_size_t size) { + return LFS3_DATA_SLICE(data, + lfs3_data_size(data) - lfs3_min( size, - lfsr_data_size(data)), + lfs3_data_size(data)), -1); } // data <-> bd interactions -// lfsr_data_read* operations update the lfsr_data_t, effectively +// lfs3_data_read* operations update the lfs3_data_t, effectively // consuming the data -// needed in lfsr_data_read and friends -#ifdef LFS_CKDATACKSUMREADS -static inline bool lfsr_m_isckdatacksums(uint32_t flags); +// needed in lfs3_data_read and friends +#ifdef LFS3_CKDATACKSUMREADS +static inline bool lfs3_m_isckdatacksums(uint32_t flags); #endif -static lfs_ssize_t lfsr_data_read(lfs_t *lfs, lfsr_data_t *data, - void *buffer, lfs_size_t size) { +static lfs3_ssize_t lfs3_data_read(lfs3_t *lfs3, lfs3_data_t *data, + void *buffer, lfs3_size_t size) { // limit our size to data range - lfs_size_t d = lfs_min(size, lfsr_data_size(*data)); + lfs3_size_t d = lfs3_min(size, lfs3_data_size(*data)); // on-disk? - if (lfsr_data_ondisk(*data)) { + if (lfs3_data_ondisk(*data)) { // validating data cksums? - if (LFS_IFDEF_CKDATACKSUMREADS( - lfsr_m_isckdatacksums(lfs->flags) - && lfsr_data_isbptr(*data), + if (LFS3_IFDEF_CKDATACKSUMREADS( + lfs3_m_isckdatacksums(lfs3->flags) + && lfs3_data_isbptr(*data), false)) { - #ifdef LFS_CKDATACKSUMREADS - int err = lfsr_bd_readck(lfs, + #ifdef LFS3_CKDATACKSUMREADS + int err = lfs3_bd_readck(lfs3, data->u.disk.block, data->u.disk.off, // note our hint includes the full data range - lfsr_data_size(*data), + lfs3_data_size(*data), buffer, d, - lfsr_data_cksize(*data), lfsr_data_cksum(*data)); + lfs3_data_cksize(*data), lfs3_data_cksum(*data)); if (err < 0) { return err; } #endif } else { - int err = lfsr_bd_read(lfs, + int err = lfs3_bd_read(lfs3, data->u.disk.block, data->u.disk.off, // note our hint includes the full data range - lfsr_data_size(*data), + lfs3_data_size(*data), buffer, d); if (err < 0) { return err; @@ -1703,54 +1705,54 @@ static lfs_ssize_t lfsr_data_read(lfs_t *lfs, lfsr_data_t *data, // buffer? } else { - lfs_memcpy(buffer, data->u.buffer, d); + lfs3_memcpy(buffer, data->u.buffer, d); } - *data = LFSR_DATA_SLICE(*data, d, -1); + *data = LFS3_DATA_SLICE(*data, d, -1); return d; } -static int lfsr_data_readle32(lfs_t *lfs, lfsr_data_t *data, +static int lfs3_data_readle32(lfs3_t *lfs3, lfs3_data_t *data, uint32_t *word) { uint8_t buf[4]; - lfs_ssize_t d = lfsr_data_read(lfs, data, buf, 4); + lfs3_ssize_t d = lfs3_data_read(lfs3, data, buf, 4); if (d < 0) { return d; } // truncated? if (d < 4) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } - *word = lfs_fromle32(buf); + *word = lfs3_fromle32(buf); return 0; } // note all leb128s in our system reserve the sign bit -static int lfsr_data_readleb128(lfs_t *lfs, lfsr_data_t *data, +static int lfs3_data_readleb128(lfs3_t *lfs3, lfs3_data_t *data, uint32_t *word_) { // note we make sure not to update our data offset until after leb128 // decoding - lfsr_data_t data_ = *data; + lfs3_data_t data_ = *data; // for 32-bits we can assume worst-case leb128 size is 5-bytes uint8_t buf[5]; - lfs_ssize_t d = lfsr_data_read(lfs, &data_, buf, 5); + lfs3_ssize_t d = lfs3_data_read(lfs3, &data_, buf, 5); if (d < 0) { return d; } - d = lfs_fromleb128(word_, buf, d); + d = lfs3_fromleb128(word_, buf, d); if (d < 0) { return d; } // all leb128s in our system reserve the sign bit if (*word_ > 0x7fffffff) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } - *data = LFSR_DATA_SLICE(*data, d, -1); + *data = LFS3_DATA_SLICE(*data, d, -1); return 0; } @@ -1758,110 +1760,110 @@ static int lfsr_data_readleb128(lfs_t *lfs, lfsr_data_t *data, // // for 32-bit words, little-leb128s are truncated to 28-bits, so the // resulting leb128 encoding fits nicely in 4-bytes -static inline int lfsr_data_readlleb128(lfs_t *lfs, lfsr_data_t *data, +static inline int lfs3_data_readlleb128(lfs3_t *lfs3, lfs3_data_t *data, uint32_t *word_) { // just call readleb128 here - int err = lfsr_data_readleb128(lfs, data, word_); + int err = lfs3_data_readleb128(lfs3, data, word_); if (err) { return err; } // little-leb128s should be limited to 28-bits if (*word_ > 0x0fffffff) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } return 0; } -static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, lfsr_data_t data, - const void *buffer, lfs_size_t size) { +static lfs3_scmp_t lfs3_data_cmp(lfs3_t *lfs3, lfs3_data_t data, + const void *buffer, lfs3_size_t size) { // compare common prefix - lfs_size_t d = lfs_min(size, lfsr_data_size(data)); + lfs3_size_t d = lfs3_min(size, lfs3_data_size(data)); // on-disk? - if (lfsr_data_ondisk(data)) { + if (lfs3_data_ondisk(data)) { // validating data cksums? - if (LFS_IFDEF_CKDATACKSUMREADS( - lfsr_m_isckdatacksums(lfs->flags) - && lfsr_data_isbptr(data), + if (LFS3_IFDEF_CKDATACKSUMREADS( + lfs3_m_isckdatacksums(lfs3->flags) + && lfs3_data_isbptr(data), false)) { - #ifdef LFS_CKDATACKSUMREADS - int cmp = lfsr_bd_cmpck(lfs, + #ifdef LFS3_CKDATACKSUMREADS + int cmp = lfs3_bd_cmpck(lfs3, // note the 0 hint, we don't usually use any // following data data.u.disk.block, data.u.disk.off, 0, buffer, d, - lfsr_data_cksize(data), lfsr_data_cksum(data)); - if (cmp != LFS_CMP_EQ) { + lfs3_data_cksize(data), lfs3_data_cksum(data)); + if (cmp != LFS3_CMP_EQ) { return cmp; } #endif } else { - int cmp = lfsr_bd_cmp(lfs, + int cmp = lfs3_bd_cmp(lfs3, // note the 0 hint, we don't usually use any // following data data.u.disk.block, data.u.disk.off, 0, buffer, d); - if (cmp != LFS_CMP_EQ) { + if (cmp != LFS3_CMP_EQ) { return cmp; } } // buffer? } else { - int cmp = lfs_memcmp(data.u.buffer, buffer, d); + int cmp = lfs3_memcmp(data.u.buffer, buffer, d); if (cmp < 0) { - return LFS_CMP_LT; + return LFS3_CMP_LT; } else if (cmp > 0) { - return LFS_CMP_GT; + return LFS3_CMP_GT; } } // if data is equal, check for size mismatch - if (lfsr_data_size(data) < size) { - return LFS_CMP_LT; - } else if (lfsr_data_size(data) > size) { - return LFS_CMP_GT; + if (lfs3_data_size(data) < size) { + return LFS3_CMP_LT; + } else if (lfs3_data_size(data) > size) { + return LFS3_CMP_GT; } else { - return LFS_CMP_EQ; + return LFS3_CMP_EQ; } } -static lfs_scmp_t lfsr_data_namecmp(lfs_t *lfs, lfsr_data_t data, - lfsr_did_t did, const char *name, lfs_size_t name_len) { +static lfs3_scmp_t lfs3_data_namecmp(lfs3_t *lfs3, lfs3_data_t data, + lfs3_did_t did, const char *name, lfs3_size_t name_len) { // first compare the did - lfsr_did_t did_; - int err = lfsr_data_readleb128(lfs, &data, &did_); + lfs3_did_t did_; + int err = lfs3_data_readleb128(lfs3, &data, &did_); if (err < 0) { return err; } if (did_ < did) { - return LFS_CMP_LT; + return LFS3_CMP_LT; } else if (did_ > did) { - return LFS_CMP_GT; + return LFS3_CMP_GT; } // then compare the actual name - return lfsr_data_cmp(lfs, data, name, name_len); + return lfs3_data_cmp(lfs3, data, name, name_len); } -static int lfsr_bd_progdata(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfsr_data_t data, +static int lfs3_bd_progdata(lfs3_t *lfs3, + lfs3_block_t block, lfs3_size_t off, lfs3_data_t data, uint32_t *cksum, bool align) { // on-disk? - if (lfsr_data_ondisk(data)) { + if (lfs3_data_ondisk(data)) { // validating data cksums? - if (LFS_IFDEF_CKDATACKSUMREADS( - lfsr_m_isckdatacksums(lfs->flags) - && lfsr_data_isbptr(data), + if (LFS3_IFDEF_CKDATACKSUMREADS( + lfs3_m_isckdatacksums(lfs3->flags) + && lfs3_data_isbptr(data), false)) { - #ifdef LFS_CKDATACKSUMREADS - int err = lfsr_bd_cpyck(lfs, block, off, - data.u.disk.block, data.u.disk.off, lfsr_data_size(data), - lfsr_data_size(data), - lfsr_data_cksize(data), lfsr_data_cksum(data), + #ifdef LFS3_CKDATACKSUMREADS + int err = lfs3_bd_cpyck(lfs3, block, off, + data.u.disk.block, data.u.disk.off, lfs3_data_size(data), + lfs3_data_size(data), + lfs3_data_cksize(data), lfs3_data_cksum(data), cksum, align); if (err) { return err; @@ -1869,9 +1871,9 @@ static int lfsr_bd_progdata(lfs_t *lfs, #endif } else { - int err = lfsr_bd_cpy(lfs, block, off, - data.u.disk.block, data.u.disk.off, lfsr_data_size(data), - lfsr_data_size(data), + int err = lfs3_bd_cpy(lfs3, block, off, + data.u.disk.block, data.u.disk.off, lfs3_data_size(data), + lfs3_data_size(data), cksum, align); if (err) { return err; @@ -1880,7 +1882,7 @@ static int lfsr_bd_progdata(lfs_t *lfs, // buffer? } else { - int err = lfsr_bd_prog(lfs, block, off, + int err = lfs3_bd_prog(lfs3, block, off, data.u.buffer, data.size, cksum, align); if (err) { @@ -1900,12 +1902,12 @@ static int lfsr_bd_progdata(lfs_t *lfs, // | le32 | // '---+---+---+---' // -#define LFSR_LE32_DSIZE 4 +#define LFS3_LE32_DSIZE 4 -static inline lfsr_data_t lfsr_data_fromle32(uint32_t word, - uint8_t buffer[static LFSR_LE32_DSIZE]) { - lfs_tole32(word, buffer); - return LFSR_DATA_BUF(buffer, LFSR_LE32_DSIZE); +static inline lfs3_data_t lfs3_data_fromle32(uint32_t word, + uint8_t buffer[static LFS3_LE32_DSIZE]) { + lfs3_tole32(word, buffer); + return LFS3_DATA_BUF(buffer, LFS3_LE32_DSIZE); } // leb128 encoding: @@ -1913,19 +1915,19 @@ static inline lfsr_data_t lfsr_data_fromle32(uint32_t word, // | leb128 | // '---+- -+- -+- -+- -' // -#define LFSR_LEB128_DSIZE 5 +#define LFS3_LEB128_DSIZE 5 -static inline lfsr_data_t lfsr_data_fromleb128(uint32_t word, - uint8_t buffer[static LFSR_LEB128_DSIZE]) { +static inline lfs3_data_t lfs3_data_fromleb128(uint32_t word, + uint8_t buffer[static LFS3_LEB128_DSIZE]) { // leb128s should not exceed 31-bits - LFS_ASSERT(word <= 0x7fffffff); + LFS3_ASSERT(word <= 0x7fffffff); - lfs_ssize_t d = lfs_toleb128(word, buffer, LFSR_LEB128_DSIZE); + lfs3_ssize_t d = lfs3_toleb128(word, buffer, LFS3_LEB128_DSIZE); if (d < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } // lleb128 encoding: @@ -1933,19 +1935,19 @@ static inline lfsr_data_t lfsr_data_fromleb128(uint32_t word, // | lleb128 | // '---+- -+- -+- -' // -#define LFSR_LLEB128_DSIZE 4 +#define LFS3_LLEB128_DSIZE 4 -static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, - uint8_t buffer[static LFSR_LLEB128_DSIZE]) { +static inline lfs3_data_t lfs3_data_fromlleb128(uint32_t word, + uint8_t buffer[static LFS3_LLEB128_DSIZE]) { // little-leb128s should not exceed 28-bits - LFS_ASSERT(word <= 0x0fffffff); + LFS3_ASSERT(word <= 0x0fffffff); - lfs_ssize_t d = lfs_toleb128(word, buffer, LFSR_LLEB128_DSIZE); + lfs3_ssize_t d = lfs3_toleb128(word, buffer, LFS3_LLEB128_DSIZE); if (d < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } @@ -1958,7 +1960,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // | cksum | // '---+---+---+---' // -#define LFSR_ECKSUM_DSIZE (4+4) +#define LFS3_ECKSUM_DSIZE (4+4) // branch encoding: // .---+- -+- -+- -+- -. block: 1 leb128 <=5 bytes @@ -1969,7 +1971,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // | cksum | // '---+---+---+---' // -#define LFSR_BRANCH_DSIZE (5+4+4) +#define LFS3_BRANCH_DSIZE (5+4+4) // btree encoding: // .---+- -+- -+- -+- -. weight: 1 leb128 <=5 bytes @@ -1982,7 +1984,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // | cksum | // '---+---+---+---' // -#define LFSR_BTREE_DSIZE (5+LFSR_BRANCH_DSIZE) +#define LFS3_BTREE_DSIZE (5+LFS3_BRANCH_DSIZE) // bptr encoding: // .---+- -+- -+- -. size: 1 leb128 <=4 bytes @@ -1997,7 +1999,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // | cksum | // '---+---+---+---' // -#define LFSR_BPTR_DSIZE (4+5+4+4+4) +#define LFS3_BPTR_DSIZE (4+5+4+4+4) // shrub encoding: // .---+- -+- -+- -+- -. weight: 1 leb128 <=5 bytes @@ -2006,7 +2008,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // | trunk | // '---+- -+- -+- -' // -#define LFSR_SHRUB_DSIZE (5+4) +#define LFS3_SHRUB_DSIZE (5+4) // mptr encoding: // .---+- -+- -+- -+- -. blocks: 2 leb128s <=2x5 bytes @@ -2015,7 +2017,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // | | // '---+- -+- -+- -+- -' // -#define LFSR_MPTR_DSIZE (5+5) +#define LFS3_MPTR_DSIZE (5+5) // geometry encoding // .---+- -+- -+- -. block_size: 1 leb128 <=4 bytes @@ -2023,76 +2025,76 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // +---+- -+- -+- -+- -. total: <=9 bytes // | block_count | // '---+- -+- -+- -+- -' -#define LFSR_GEOMETRY_DSIZE (4+5) +#define LFS3_GEOMETRY_DSIZE (4+5) // operations on attribute lists // our core attribute type -typedef struct lfsr_rattr { - lfsr_tag_t tag; +typedef struct lfs3_rattr { + lfs3_tag_t tag; // ignoring lazy/special tags // sign(count)=0 => in-RAM buffer or estimate for lazy tags // sign(count)=1 => multiple concatenated datas int16_t count; - lfsr_srid_t weight; + lfs3_srid_t weight; union { const uint8_t *buffer; - const lfsr_data_t *datas; + const lfs3_data_t *datas; uint32_t le32; uint32_t leb128; uint32_t lleb128; const void *etc; } u; -} lfsr_rattr_t; +} lfs3_rattr_t; // low-level attr macro -#define LFSR_RATTR_(_tag, _weight, _u, _count) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_(_tag, _weight, _u, _count) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=_count, \ .weight=_weight, \ .u=_u}) // high-level attr macros -#define LFSR_RATTR(_tag, _weight) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR(_tag, _weight) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ .u.datas=NULL}) -#define LFSR_RATTR_BUF(_tag, _weight, _buffer, _size) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_BUF(_tag, _weight, _buffer, _size) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=(uint16_t){_size}, \ .weight=_weight, \ .u.buffer=(const void*)(_buffer)}) -#define LFSR_RATTR_DATA(_tag, _weight, _data) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_DATA(_tag, _weight, _data) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=-1, \ .weight=_weight, \ .u.datas=_data}) -#define LFSR_RATTR_CAT_(_tag, _weight, _datas, _data_count) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_CAT_(_tag, _weight, _datas, _data_count) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=-(uint16_t){_data_count}, \ .weight=_weight, \ .u.datas=_datas}) -#define LFSR_RATTR_CAT(_tag, _weight, ...) \ - LFSR_RATTR_CAT_( \ +#define LFS3_RATTR_CAT(_tag, _weight, ...) \ + LFS3_RATTR_CAT_( \ _tag, \ _weight, \ - ((const lfsr_data_t[]){__VA_ARGS__}), \ - sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t)) + ((const lfs3_data_t[]){__VA_ARGS__}), \ + sizeof((const lfs3_data_t[]){__VA_ARGS__}) / sizeof(lfs3_data_t)) -#define LFSR_RATTR_NOOP() \ - ((lfsr_rattr_t){ \ - .tag=LFSR_TAG_NULL, \ +#define LFS3_RATTR_NOOP() \ + ((lfs3_rattr_t){ \ + .tag=LFS3_TAG_NULL, \ .count=0, \ .weight=0, \ .u.buffer=NULL}) @@ -2100,171 +2102,171 @@ typedef struct lfsr_rattr { // as convenience we lazily encode single le32/leb128/lleb128 attrs // // this also avoids needing a stack allocation for these attrs -#define LFSR_RATTR_LE32(_tag, _weight, _le32) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_LE32(_tag, _weight, _le32) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ .u.le32=_le32}) -#define LFSR_RATTR_LEB128(_tag, _weight, _leb128) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_LEB128(_tag, _weight, _leb128) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ .u.leb128=_leb128}) -#define LFSR_RATTR_LLEB128(_tag, _weight, _lleb128) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_LLEB128(_tag, _weight, _lleb128) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ .u.lleb128=_lleb128}) // helper macro for did + name pairs -typedef struct lfsr_name { +typedef struct lfs3_name { uint32_t did; const char *name; - lfs_size_t name_len; -} lfsr_name_t; + lfs3_size_t name_len; +} lfs3_name_t; -#define LFSR_RATTR_NAME_(_tag, _weight, _name) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_NAME_(_tag, _weight, _name) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ - .u.etc=(const lfsr_name_t*){_name}}) + .u.etc=(const lfs3_name_t*){_name}}) -#define LFSR_RATTR_NAME(_tag, _weight, _did, _name, _name_len) \ - LFSR_RATTR_NAME_( \ +#define LFS3_RATTR_NAME(_tag, _weight, _did, _name, _name_len) \ + LFS3_RATTR_NAME_( \ _tag, \ _weight, \ - (&(const lfsr_name_t){ \ + (&(const lfs3_name_t){ \ .did=_did, \ .name=_name, \ .name_len=_name_len})) // macros for other lazily encoded attrs -#define LFSR_RATTR_GEOMETRY(_tag, _weight, _geometry) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_GEOMETRY(_tag, _weight, _geometry) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ - .u.etc=(const lfsr_geometry_t*){_geometry}}) + .u.etc=(const lfs3_geometry_t*){_geometry}}) -// note the LFSR_BPTR_DSIZE hint so shrub estimates work -#define LFSR_RATTR_BPTR(_tag, _weight, _bptr) \ - ((lfsr_rattr_t){ \ +// note the LFS3_BPTR_DSIZE hint so shrub estimates work +#define LFS3_RATTR_BPTR(_tag, _weight, _bptr) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ - .count=LFSR_BPTR_DSIZE, \ + .count=LFS3_BPTR_DSIZE, \ .weight=_weight, \ - .u.etc=(const lfsr_bptr_t*){_bptr}}) + .u.etc=(const lfs3_bptr_t*){_bptr}}) -#define LFSR_RATTR_SHRUB(_tag, _weight, _shrub) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_SHRUB(_tag, _weight, _shrub) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ - .u.etc=(const lfsr_shrub_t*){_shrub}}) + .u.etc=(const lfs3_shrub_t*){_shrub}}) -#define LFSR_RATTR_BTREE(_tag, _weight, _btree) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_BTREE(_tag, _weight, _btree) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ - .u.etc=(const lfsr_btree_t*){_btree}}) + .u.etc=(const lfs3_btree_t*){_btree}}) -#define LFSR_RATTR_MPTR(_tag, _weight, _mptr) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_MPTR(_tag, _weight, _mptr) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ - .u.etc=(const lfs_block_t*){_mptr}}) + .u.etc=(const lfs3_block_t*){_mptr}}) -#define LFSR_RATTR_ECKSUM(_tag, _weight, _ecksum) \ - ((lfsr_rattr_t){ \ +#define LFS3_RATTR_ECKSUM(_tag, _weight, _ecksum) \ + ((lfs3_rattr_t){ \ .tag=_tag, \ .count=0, \ .weight=_weight, \ - .u.etc=(const lfsr_ecksum_t*){_ecksum}}) + .u.etc=(const lfs3_ecksum_t*){_ecksum}}) // these are special attrs that trigger unique behavior in -// lfsr_mdir_commit__ -#define LFSR_RATTR_RATTRS(_rattrs, _rattr_count) \ - ((lfsr_rattr_t){ \ - .tag=LFSR_TAG_RATTRS, \ +// lfs3_mdir_commit__ +#define LFS3_RATTR_RATTRS(_rattrs, _rattr_count) \ + ((lfs3_rattr_t){ \ + .tag=LFS3_TAG_RATTRS, \ .count=(uint16_t){_rattr_count}, \ .weight=0, \ - .u.etc=(const lfsr_rattr_t*){_rattrs}}) + .u.etc=(const lfs3_rattr_t*){_rattrs}}) -#define LFSR_RATTR_SHRUBCOMMIT(_shrubcommit) \ - ((lfsr_rattr_t){ \ - .tag=LFSR_TAG_SHRUBCOMMIT, \ +#define LFS3_RATTR_SHRUBCOMMIT(_shrubcommit) \ + ((lfs3_rattr_t){ \ + .tag=LFS3_TAG_SHRUBCOMMIT, \ .count=0, \ .weight=0, \ - .u.etc=(const lfsr_shrubcommit_t*){_shrubcommit}}) + .u.etc=(const lfs3_shrubcommit_t*){_shrubcommit}}) -#define LFSR_RATTR_MOVE(_move) \ - ((lfsr_rattr_t){ \ - .tag=LFSR_TAG_MOVE, \ +#define LFS3_RATTR_MOVE(_move) \ + ((lfs3_rattr_t){ \ + .tag=LFS3_TAG_MOVE, \ .count=0, \ .weight=0, \ - .u.etc=(const lfsr_mdir_t*){_move}}) + .u.etc=(const lfs3_mdir_t*){_move}}) -#define LFSR_RATTR_ATTRS(_attrs, _attr_count) \ - ((lfsr_rattr_t){ \ - .tag=LFSR_TAG_ATTRS, \ +#define LFS3_RATTR_ATTRS(_attrs, _attr_count) \ + ((lfs3_rattr_t){ \ + .tag=LFS3_TAG_ATTRS, \ .count=(uint16_t){_attr_count}, \ .weight=0, \ - .u.etc=(const struct lfs_attr*){_attrs}}) + .u.etc=(const struct lfs3_attr*){_attrs}}) // create an attribute list -#define LFSR_RATTRS(...) \ - (const lfsr_rattr_t[]){__VA_ARGS__}, \ - sizeof((const lfsr_rattr_t[]){__VA_ARGS__}) / sizeof(lfsr_rattr_t) +#define LFS3_RATTRS(...) \ + (const lfs3_rattr_t[]){__VA_ARGS__}, \ + sizeof((const lfs3_rattr_t[]){__VA_ARGS__}) / sizeof(lfs3_rattr_t) // rattr helpers -static inline bool lfsr_rattr_isnoop(lfsr_rattr_t rattr) { +static inline bool lfs3_rattr_isnoop(lfs3_rattr_t rattr) { // noop rattrs must have zero weight - LFS_ASSERT(rattr.tag || rattr.weight == 0); + LFS3_ASSERT(rattr.tag || rattr.weight == 0); return !rattr.tag; } -static inline bool lfsr_rattr_isinsert(lfsr_rattr_t rattr) { - return !lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0; +static inline bool lfs3_rattr_isinsert(lfs3_rattr_t rattr) { + return !lfs3_tag_isgrow(rattr.tag) && rattr.weight > 0; } -static inline lfsr_srid_t lfsr_rattr_nextrid(lfsr_rattr_t rattr, - lfsr_srid_t rid) { - if (lfsr_rattr_isinsert(rattr)) { +static inline lfs3_srid_t lfs3_rattr_nextrid(lfs3_rattr_t rattr, + lfs3_srid_t rid) { + if (lfs3_rattr_isinsert(rattr)) { return rid + rattr.weight-1; } else { return rid + rattr.weight; } } -static inline lfsr_tag_t lfsr_rattr_dtag(lfsr_rattr_t rattr) { +static inline lfs3_tag_t lfs3_rattr_dtag(lfs3_rattr_t rattr) { // lazily tag encoding can be bypassed with explicit data, this is // necessary to allow copies during compaction, relocation, etc if (rattr.count >= 0) { return rattr.tag; } else { - return LFSR_TAG_DATA; + return LFS3_TAG_DATA; } } -static inline lfs_size_t lfsr_rattr_dsize(lfsr_rattr_t rattr) { +static inline lfs3_size_t lfs3_rattr_dsize(lfs3_rattr_t rattr) { // note this does not include the tag size // // this gets a bit complicated for concatenated data if (rattr.count >= 0) { return rattr.count; } else { - const lfsr_data_t *datas = rattr.u.datas; - lfs_size_t data_count = -rattr.count; - lfs_size_t size = 0; - for (lfs_size_t i = 0; i < data_count; i++) { - size += lfsr_data_size(datas[i]); + const lfs3_data_t *datas = rattr.u.datas; + lfs3_size_t data_count = -rattr.count; + lfs3_size_t size = 0; + for (lfs3_size_t i = 0; i < data_count; i++) { + size += lfs3_data_size(datas[i]); } return size; } @@ -2275,7 +2277,7 @@ static inline lfs_size_t lfsr_rattr_dsize(lfsr_rattr_t rattr) { // // a slightly different struct because it's user facing -static inline lfs_ssize_t lfsr_attr_size(const struct lfs_attr *attr) { +static inline lfs3_ssize_t lfs3_attr_size(const struct lfs3_attr *attr) { // we default to the buffer_size if a mutable size is not provided if (attr->size) { return *attr->size; @@ -2284,22 +2286,22 @@ static inline lfs_ssize_t lfsr_attr_size(const struct lfs_attr *attr) { } } -static inline bool lfsr_attr_isnoattr(const struct lfs_attr *attr) { - return lfsr_attr_size(attr) == LFS_ERR_NOATTR; +static inline bool lfs3_attr_isnoattr(const struct lfs3_attr *attr) { + return lfs3_attr_size(attr) == LFS3_ERR_NOATTR; } -static lfs_scmp_t lfsr_attr_cmp(lfs_t *lfs, const struct lfs_attr *attr, - const lfsr_data_t *data) { +static lfs3_scmp_t lfs3_attr_cmp(lfs3_t *lfs3, const struct lfs3_attr *attr, + const lfs3_data_t *data) { // note data=NULL => NOATTR if (!data) { - return (lfsr_attr_isnoattr(attr)) ? LFS_CMP_EQ : LFS_CMP_GT; + return (lfs3_attr_isnoattr(attr)) ? LFS3_CMP_EQ : LFS3_CMP_GT; } else { - if (lfsr_attr_isnoattr(attr)) { - return LFS_CMP_LT; + if (lfs3_attr_isnoattr(attr)) { + return LFS3_CMP_LT; } else { - return lfsr_data_cmp(lfs, *data, + return lfs3_data_cmp(lfs3, *data, attr->buffer, - lfsr_attr_size(attr)); + lfs3_attr_size(attr)); } } } @@ -2308,41 +2310,41 @@ static lfs_scmp_t lfsr_attr_cmp(lfs_t *lfs, const struct lfs_attr *attr, // operations on erased-state checksums // erased-state checksum -typedef struct lfsr_ecksum { +typedef struct lfs3_ecksum { // cksize=-1 indicates no ecksum - lfs_ssize_t cksize; + lfs3_ssize_t cksize; uint32_t cksum; -} lfsr_ecksum_t; +} lfs3_ecksum_t; // erased-state checksum on-disk encoding -static lfsr_data_t lfsr_data_fromecksum(const lfsr_ecksum_t *ecksum, - uint8_t buffer[static LFSR_ECKSUM_DSIZE]) { +static lfs3_data_t lfs3_data_fromecksum(const lfs3_ecksum_t *ecksum, + uint8_t buffer[static LFS3_ECKSUM_DSIZE]) { // you shouldn't try to encode a not-ecksum, that doesn't make sense - LFS_ASSERT(ecksum->cksize != -1); + LFS3_ASSERT(ecksum->cksize != -1); // cksize should not exceed 28-bits - LFS_ASSERT((lfs_size_t)ecksum->cksize <= 0x0fffffff); + LFS3_ASSERT((lfs3_size_t)ecksum->cksize <= 0x0fffffff); - lfs_ssize_t d = 0; - lfs_ssize_t d_ = lfs_toleb128(ecksum->cksize, &buffer[d], 4); + lfs3_ssize_t d = 0; + lfs3_ssize_t d_ = lfs3_toleb128(ecksum->cksize, &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - lfs_tole32(ecksum->cksum, &buffer[d]); + lfs3_tole32(ecksum->cksum, &buffer[d]); d += 4; - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data, - lfsr_ecksum_t *ecksum) { - int err = lfsr_data_readlleb128(lfs, data, (lfs_size_t*)&ecksum->cksize); +static int lfs3_data_readecksum(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_ecksum_t *ecksum) { + int err = lfs3_data_readlleb128(lfs3, data, (lfs3_size_t*)&ecksum->cksize); if (err) { return err; } - err = lfsr_data_readle32(lfs, data, &ecksum->cksum); + err = lfs3_data_readle32(lfs3, data, &ecksum->cksum); if (err) { return err; } @@ -2354,19 +2356,19 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data, /// block pointer things /// -#define LFSR_BPTR_ONDISK LFSR_DATA_ONDISK -#define LFSR_BPTR_ISBPTR LFSR_DATA_ISBPTR +#define LFS3_BPTR_ONDISK LFS3_DATA_ONDISK +#define LFS3_BPTR_ISBPTR LFS3_DATA_ISBPTR -#define LFSR_BPTR_ISERASED 0x80000000 +#define LFS3_BPTR_ISERASED 0x80000000 -static void lfsr_bptr_init(lfsr_bptr_t *bptr, - lfsr_data_t data, lfs_size_t cksize, uint32_t cksum) { +static void lfs3_bptr_init(lfs3_bptr_t *bptr, + lfs3_data_t data, lfs3_size_t cksize, uint32_t cksum) { // make sure the bptr flag is set - LFS_ASSERT(lfsr_data_ondisk(data)); - bptr->data.size = data.size | LFSR_DATA_ONDISK | LFSR_BPTR_ISBPTR; + LFS3_ASSERT(lfs3_data_ondisk(data)); + bptr->data.size = data.size | LFS3_DATA_ONDISK | LFS3_BPTR_ISBPTR; bptr->data.u.disk.block = data.u.disk.block; bptr->data.u.disk.off = data.u.disk.off; - #ifdef LFS_CKDATACKSUMREADS + #ifdef LFS3_CKDATACKSUMREADS bptr->data.u.disk.cksize = cksize; bptr->data.u.disk.cksum = cksum; #else @@ -2375,59 +2377,59 @@ static void lfsr_bptr_init(lfsr_bptr_t *bptr, #endif } -static inline void lfsr_bptr_discard(lfsr_bptr_t *bptr) { - bptr->data = LFSR_DATA_NULL(); - #ifndef LFS_CKDATACKSUMREADS +static inline void lfs3_bptr_discard(lfs3_bptr_t *bptr) { + bptr->data = LFS3_DATA_NULL(); + #ifndef LFS3_CKDATACKSUMREADS bptr->cksize = 0; bptr->cksum = 0; #endif } -static inline void lfsr_bptr_claim(lfsr_bptr_t *bptr) { - #ifdef LFS_CKDATACKSUMREADS - bptr->data.u.disk.cksize &= ~LFSR_BPTR_ISERASED; +static inline void lfs3_bptr_claim(lfs3_bptr_t *bptr) { + #ifdef LFS3_CKDATACKSUMREADS + bptr->data.u.disk.cksize &= ~LFS3_BPTR_ISERASED; #else - bptr->cksize &= ~LFSR_BPTR_ISERASED; + bptr->cksize &= ~LFS3_BPTR_ISERASED; #endif } -static inline bool lfsr_bptr_isbptr(const lfsr_bptr_t *bptr) { - return bptr->data.size & LFSR_BPTR_ISBPTR; +static inline bool lfs3_bptr_isbptr(const lfs3_bptr_t *bptr) { + return bptr->data.size & LFS3_BPTR_ISBPTR; } -static inline lfs_block_t lfsr_bptr_block(const lfsr_bptr_t *bptr) { +static inline lfs3_block_t lfs3_bptr_block(const lfs3_bptr_t *bptr) { return bptr->data.u.disk.block; } -static inline lfs_size_t lfsr_bptr_off(const lfsr_bptr_t *bptr) { +static inline lfs3_size_t lfs3_bptr_off(const lfs3_bptr_t *bptr) { return bptr->data.u.disk.off; } -static inline lfs_size_t lfsr_bptr_size(const lfsr_bptr_t *bptr) { - return bptr->data.size & ~LFSR_BPTR_ONDISK & ~LFSR_BPTR_ISBPTR; +static inline lfs3_size_t lfs3_bptr_size(const lfs3_bptr_t *bptr) { + return bptr->data.size & ~LFS3_BPTR_ONDISK & ~LFS3_BPTR_ISBPTR; } -// checked reads adds ck info to lfsr_data_t that we don't want to +// checked reads adds ck info to lfs3_data_t that we don't want to // unnecessarily duplicate, this makes accessing ck info annoyingly // messy... -static inline bool lfsr_bptr_iserased(const lfsr_bptr_t *bptr) { - #ifdef LFS_CKDATACKSUMREADS - return bptr->data.u.disk.cksize & LFSR_BPTR_ISERASED; +static inline bool lfs3_bptr_iserased(const lfs3_bptr_t *bptr) { + #ifdef LFS3_CKDATACKSUMREADS + return bptr->data.u.disk.cksize & LFS3_BPTR_ISERASED; #else - return bptr->cksize & LFSR_BPTR_ISERASED; + return bptr->cksize & LFS3_BPTR_ISERASED; #endif } -static inline lfs_size_t lfsr_bptr_cksize(const lfsr_bptr_t *bptr) { - #ifdef LFS_CKDATACKSUMREADS - return bptr->data.u.disk.cksize & ~LFSR_BPTR_ISERASED; +static inline lfs3_size_t lfs3_bptr_cksize(const lfs3_bptr_t *bptr) { + #ifdef LFS3_CKDATACKSUMREADS + return bptr->data.u.disk.cksize & ~LFS3_BPTR_ISERASED; #else - return bptr->cksize & ~LFSR_BPTR_ISERASED; + return bptr->cksize & ~LFS3_BPTR_ISERASED; #endif } -static inline uint32_t lfsr_bptr_cksum(const lfsr_bptr_t *bptr) { - #ifdef LFS_CKDATACKSUMREADS +static inline uint32_t lfs3_bptr_cksum(const lfs3_bptr_t *bptr) { + #ifdef LFS3_CKDATACKSUMREADS return bptr->data.u.disk.cksum; #else return bptr->cksum; @@ -2435,79 +2437,79 @@ static inline uint32_t lfsr_bptr_cksum(const lfsr_bptr_t *bptr) { } // bptr on-disk encoding -static lfsr_data_t lfsr_data_frombptr(const lfsr_bptr_t *bptr, - uint8_t buffer[static LFSR_BPTR_DSIZE]) { +static lfs3_data_t lfs3_data_frombptr(const lfs3_bptr_t *bptr, + uint8_t buffer[static LFS3_BPTR_DSIZE]) { // size should not exceed 28-bits - LFS_ASSERT(lfsr_data_size(bptr->data) <= 0x0fffffff); + LFS3_ASSERT(lfs3_data_size(bptr->data) <= 0x0fffffff); // block should not exceed 31-bits - LFS_ASSERT(lfsr_bptr_block(bptr) <= 0x7fffffff); + LFS3_ASSERT(lfs3_bptr_block(bptr) <= 0x7fffffff); // off should not exceed 28-bits - LFS_ASSERT(lfsr_bptr_off(bptr) <= 0x0fffffff); + LFS3_ASSERT(lfs3_bptr_off(bptr) <= 0x0fffffff); // cksize should not exceed 28-bits - LFS_ASSERT(lfsr_bptr_cksize(bptr) <= 0x0fffffff); - lfs_ssize_t d = 0; + LFS3_ASSERT(lfs3_bptr_cksize(bptr) <= 0x0fffffff); + lfs3_ssize_t d = 0; // write the block, offset, size - lfs_ssize_t d_ = lfs_toleb128(lfsr_data_size(bptr->data), &buffer[d], 4); + lfs3_ssize_t d_ = lfs3_toleb128(lfs3_data_size(bptr->data), &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - d_ = lfs_toleb128(lfsr_bptr_block(bptr), &buffer[d], 5); + d_ = lfs3_toleb128(lfs3_bptr_block(bptr), &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - d_ = lfs_toleb128(lfsr_bptr_off(bptr), &buffer[d], 4); + d_ = lfs3_toleb128(lfs3_bptr_off(bptr), &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; // write the cksize, cksum - d_ = lfs_toleb128(lfsr_bptr_cksize(bptr), &buffer[d], 4); + d_ = lfs3_toleb128(lfs3_bptr_cksize(bptr), &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - lfs_tole32(lfsr_bptr_cksum(bptr), &buffer[d]); + lfs3_tole32(lfs3_bptr_cksum(bptr), &buffer[d]); d += 4; - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readbptr(lfs_t *lfs, lfsr_data_t *data, - lfsr_bptr_t *bptr) { +static int lfs3_data_readbptr(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_bptr_t *bptr) { // read the block, offset, size - int err = lfsr_data_readlleb128(lfs, data, &bptr->data.size); + int err = lfs3_data_readlleb128(lfs3, data, &bptr->data.size); if (err) { return err; } - err = lfsr_data_readleb128(lfs, data, &bptr->data.u.disk.block); + err = lfs3_data_readleb128(lfs3, data, &bptr->data.u.disk.block); if (err) { return err; } - err = lfsr_data_readlleb128(lfs, data, &bptr->data.u.disk.off); + err = lfs3_data_readlleb128(lfs3, data, &bptr->data.u.disk.off); if (err) { return err; } // read the cksize, cksum - err = lfsr_data_readlleb128(lfs, data, - LFS_IFDEF_CKDATACKSUMREADS( + err = lfs3_data_readlleb128(lfs3, data, + LFS3_IFDEF_CKDATACKSUMREADS( &bptr->data.u.disk.cksize, &bptr->cksize)); if (err) { return err; } - err = lfsr_data_readle32(lfs, data, - LFS_IFDEF_CKDATACKSUMREADS( + err = lfs3_data_readle32(lfs3, data, + LFS3_IFDEF_CKDATACKSUMREADS( &bptr->data.u.disk.cksum, &bptr->cksum)); if (err) { @@ -2515,30 +2517,30 @@ static int lfsr_data_readbptr(lfs_t *lfs, lfsr_data_t *data, } // mark as on-disk + cksum - bptr->data.size |= LFSR_DATA_ONDISK | LFSR_DATA_ISBPTR; + bptr->data.size |= LFS3_DATA_ONDISK | LFS3_DATA_ISBPTR; return 0; } // check the contents of a bptr -static int lfsr_bptr_ck(lfs_t *lfs, const lfsr_bptr_t *bptr) { +static int lfs3_bptr_ck(lfs3_t *lfs3, const lfs3_bptr_t *bptr) { uint32_t cksum = 0; - int err = lfsr_bd_cksum(lfs, - lfsr_bptr_block(bptr), 0, 0, - lfsr_bptr_cksize(bptr), + int err = lfs3_bd_cksum(lfs3, + lfs3_bptr_block(bptr), 0, 0, + lfs3_bptr_cksize(bptr), &cksum); if (err) { return err; } // test that our cksum matches what's expected - if (cksum != lfsr_bptr_cksum(bptr)) { - LFS_ERROR("Found bptr cksum mismatch " + if (cksum != lfs3_bptr_cksum(bptr)) { + LFS3_ERROR("Found bptr cksum mismatch " "0x%"PRIx32".%"PRIx32" %"PRId32", " "cksum %08"PRIx32" (!= %08"PRIx32")", - lfsr_bptr_block(bptr), 0, - lfsr_bptr_cksize(bptr), - cksum, lfsr_bptr_cksum(bptr)); - return LFS_ERR_CORRUPT; + lfs3_bptr_block(bptr), 0, + lfs3_bptr_cksize(bptr), + cksum, lfs3_bptr_cksum(bptr)); + return LFS3_ERR_CORRUPT; } return 0; @@ -2549,11 +2551,11 @@ static int lfsr_bptr_ck(lfs_t *lfs, const lfsr_bptr_t *bptr) { /// Red-black-yellow Dhara tree operations /// -#define LFSR_RBYD_ISSHRUB 0x80000000 -#define LFSR_RBYD_ISPERTURB 0x80000000 +#define LFS3_RBYD_ISSHRUB 0x80000000 +#define LFS3_RBYD_ISPERTURB 0x80000000 // helper functions -static void lfsr_rbyd_init(lfsr_rbyd_t *rbyd, lfs_block_t block) { +static void lfs3_rbyd_init(lfs3_rbyd_t *rbyd, lfs3_block_t block) { rbyd->blocks[0] = block; rbyd->trunk = 0; rbyd->weight = 0; @@ -2561,33 +2563,33 @@ static void lfsr_rbyd_init(lfsr_rbyd_t *rbyd, lfs_block_t block) { rbyd->cksum = 0; } -static inline void lfsr_rbyd_claim(lfsr_rbyd_t *rbyd) { +static inline void lfs3_rbyd_claim(lfs3_rbyd_t *rbyd) { rbyd->eoff = -1; } -static inline bool lfsr_rbyd_isshrub(const lfsr_rbyd_t *rbyd) { - return rbyd->trunk & LFSR_RBYD_ISSHRUB; +static inline bool lfs3_rbyd_isshrub(const lfs3_rbyd_t *rbyd) { + return rbyd->trunk & LFS3_RBYD_ISSHRUB; } -static inline lfs_size_t lfsr_rbyd_trunk(const lfsr_rbyd_t *rbyd) { - return rbyd->trunk & ~LFSR_RBYD_ISSHRUB; +static inline lfs3_size_t lfs3_rbyd_trunk(const lfs3_rbyd_t *rbyd) { + return rbyd->trunk & ~LFS3_RBYD_ISSHRUB; } -static inline bool lfsr_rbyd_isfetched(const lfsr_rbyd_t *rbyd) { - return !lfsr_rbyd_trunk(rbyd) || rbyd->eoff; +static inline bool lfs3_rbyd_isfetched(const lfs3_rbyd_t *rbyd) { + return !lfs3_rbyd_trunk(rbyd) || rbyd->eoff; } -static inline bool lfsr_rbyd_isperturb(const lfsr_rbyd_t *rbyd) { - return rbyd->eoff & LFSR_RBYD_ISPERTURB; +static inline bool lfs3_rbyd_isperturb(const lfs3_rbyd_t *rbyd) { + return rbyd->eoff & LFS3_RBYD_ISPERTURB; } -static inline lfs_size_t lfsr_rbyd_eoff(const lfsr_rbyd_t *rbyd) { - return rbyd->eoff & ~LFSR_RBYD_ISPERTURB; +static inline lfs3_size_t lfs3_rbyd_eoff(const lfs3_rbyd_t *rbyd) { + return rbyd->eoff & ~LFS3_RBYD_ISPERTURB; } -static inline int lfsr_rbyd_cmp( - const lfsr_rbyd_t *a, - const lfsr_rbyd_t *b) { +static inline int lfs3_rbyd_cmp( + const lfs3_rbyd_t *a, + const lfs3_rbyd_t *b) { if (a->blocks[0] != b->blocks[0]) { return a->blocks[0] - b->blocks[0]; } else { @@ -2596,47 +2598,47 @@ static inline int lfsr_rbyd_cmp( } -// needed in lfsr_rbyd_alloc -static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase); +// needed in lfs3_rbyd_alloc +static lfs3_sblock_t lfs3_alloc(lfs3_t *lfs3, bool erase); // allocate an rbyd block -static int lfsr_rbyd_alloc(lfs_t *lfs, lfsr_rbyd_t *rbyd) { - lfs_sblock_t block = lfs_alloc(lfs, true); +static int lfs3_rbyd_alloc(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { + lfs3_sblock_t block = lfs3_alloc(lfs3, true); if (block < 0) { return block; } - lfsr_rbyd_init(rbyd, block); + lfs3_rbyd_init(rbyd, block); return 0; } -static int lfsr_rbyd_ckecksum(lfs_t *lfs, const lfsr_rbyd_t *rbyd, - const lfsr_ecksum_t *ecksum) { +static int lfs3_rbyd_ckecksum(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + const lfs3_ecksum_t *ecksum) { // check that the ecksum looks right - if (lfsr_rbyd_eoff(rbyd) + ecksum->cksize >= lfs->cfg->block_size - || lfsr_rbyd_eoff(rbyd) % lfs->cfg->prog_size != 0) { - return LFS_ERR_CORRUPT; + if (lfs3_rbyd_eoff(rbyd) + ecksum->cksize >= lfs3->cfg->block_size + || lfs3_rbyd_eoff(rbyd) % lfs3->cfg->prog_size != 0) { + return LFS3_ERR_CORRUPT; } // the next valid bit must _not_ match, or a commit was attempted, // this should hopefully stay in our cache uint8_t e; - int err = lfsr_bd_read(lfs, - rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), ecksum->cksize, + int err = lfs3_bd_read(lfs3, + rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), ecksum->cksize, &e, 1); if (err) { return err; } - if (((e >> 7)^lfsr_rbyd_isperturb(rbyd)) == lfs_parity(rbyd->cksum)) { - return LFS_ERR_CORRUPT; + if (((e >> 7)^lfs3_rbyd_isperturb(rbyd)) == lfs3_parity(rbyd->cksum)) { + return LFS3_ERR_CORRUPT; } // check that erased-state matches our checksum, if this fails // most likely a write was interrupted uint32_t ecksum_ = 0; - err = lfsr_bd_cksum(lfs, - rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), 0, + err = lfs3_bd_cksum(lfs3, + rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), 0, ecksum->cksize, &ecksum_); if (err) { @@ -2644,31 +2646,31 @@ static int lfsr_rbyd_ckecksum(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } // found erased-state? - return (ecksum_ == ecksum->cksum) ? 0 : LFS_ERR_CORRUPT; + return (ecksum_ == ecksum->cksum) ? 0 : LFS3_ERR_CORRUPT; } -// needed in lfsr_rbyd_fetch_ if debugging rbyd balance -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_, - lfsr_data_t *data_, - lfs_size_t *height_, lfs_size_t *bheight_); +// needed in lfs3_rbyd_fetch_ if debugging rbyd balance +static int lfs3_rbyd_lookupnext_(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, lfs3_tag_t tag, + lfs3_srid_t *rid_, lfs3_tag_t *tag_, lfs3_rid_t *weight_, + lfs3_data_t *data_, + lfs3_size_t *height_, lfs3_size_t *bheight_); // fetch an rbyd -static int lfsr_rbyd_fetch_(lfs_t *lfs, - lfsr_rbyd_t *rbyd, uint32_t *gcksumdelta, - lfs_block_t block, lfs_size_t trunk) { +static int lfs3_rbyd_fetch_(lfs3_t *lfs3, + lfs3_rbyd_t *rbyd, uint32_t *gcksumdelta, + lfs3_block_t block, lfs3_size_t trunk) { // set up some initial state rbyd->blocks[0] = block; - rbyd->trunk = (trunk & LFSR_RBYD_ISSHRUB) | 0; + rbyd->trunk = (trunk & LFS3_RBYD_ISSHRUB) | 0; rbyd->eoff = 0; // ignore the shrub bit here - trunk &= ~LFSR_RBYD_ISSHRUB; + trunk &= ~LFS3_RBYD_ISSHRUB; // checksum the revision count to get the cksum started uint32_t cksum = 0; - int err = lfsr_bd_cksum(lfs, block, 0, -1, sizeof(uint32_t), + int err = lfs3_bd_cksum(lfs3, block, 0, -1, sizeof(uint32_t), &cksum); if (err) { return err; @@ -2676,80 +2678,80 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, // temporary state until we validate a cksum uint32_t cksum_ = cksum; - lfs_size_t off = sizeof(uint32_t); - lfs_size_t trunk_ = 0; - lfs_size_t trunk__ = 0; - lfsr_rid_t weight = 0; - lfsr_rid_t weight_ = 0; + lfs3_size_t off = sizeof(uint32_t); + lfs3_size_t trunk_ = 0; + lfs3_size_t trunk__ = 0; + lfs3_rid_t weight = 0; + lfs3_rid_t weight_ = 0; // assume unerased until proven otherwise - lfsr_ecksum_t ecksum = {.cksize=-1}; - lfsr_ecksum_t ecksum_ = {.cksize=-1}; + lfs3_ecksum_t ecksum = {.cksize=-1}; + lfs3_ecksum_t ecksum_ = {.cksize=-1}; // also find gcksumdelta, though this is only used by mdirs uint32_t gcksumdelta_ = 0; // scan tags, checking valid bits, cksums, etc - while (off < lfs->cfg->block_size - && (!trunk || lfsr_rbyd_eoff(rbyd) <= trunk)) { + while (off < lfs3->cfg->block_size + && (!trunk || lfs3_rbyd_eoff(rbyd) <= trunk)) { // read next tag - lfsr_tag_t tag; - lfsr_rid_t weight__; - lfs_size_t size; - lfs_ssize_t d = lfsr_bd_readtag(lfs, block, off, -1, + lfs3_tag_t tag; + lfs3_rid_t weight__; + lfs3_size_t size; + lfs3_ssize_t d = lfs3_bd_readtag(lfs3, block, off, -1, &tag, &weight__, &size, &cksum_); if (d < 0) { - if (d == LFS_ERR_CORRUPT) { + if (d == LFS3_ERR_CORRUPT) { break; } return d; } - lfs_size_t off_ = off + d; + lfs3_size_t off_ = off + d; // readtag should already check we're in-bounds - LFS_ASSERT(lfsr_tag_isalt(tag) - || off_ + size <= lfs->cfg->block_size); + LFS3_ASSERT(lfs3_tag_isalt(tag) + || off_ + size <= lfs3->cfg->block_size); // take care of cksum - if (!lfsr_tag_isalt(tag)) { + if (!lfs3_tag_isalt(tag)) { // not an end-of-commit cksum - if (lfsr_tag_suptype(tag) != LFSR_TAG_CKSUM) { + if (lfs3_tag_suptype(tag) != LFS3_TAG_CKSUM) { // cksum the entry, hopefully leaving it in the cache - err = lfsr_bd_cksum(lfs, block, off_, -1, size, + err = lfs3_bd_cksum(lfs3, block, off_, -1, size, &cksum_); if (err) { - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } return err; } // found an ecksum? save for later - if (tag == LFSR_TAG_ECKSUM) { - err = lfsr_data_readecksum(lfs, - &LFSR_DATA_DISK(block, off_, + if (tag == LFS3_TAG_ECKSUM) { + err = lfs3_data_readecksum(lfs3, + &LFS3_DATA_DISK(block, off_, // note this size is to make the hint do // what we want - lfs->cfg->block_size - off_), + lfs3->cfg->block_size - off_), &ecksum_); if (err) { - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } return err; } // found gcksumdelta? save for later - } else if (tag == LFSR_TAG_GCKSUMDELTA) { - err = lfsr_data_readle32(lfs, - &LFSR_DATA_DISK(block, off_, + } else if (tag == LFS3_TAG_GCKSUMDELTA) { + err = lfs3_data_readle32(lfs3, + &LFS3_DATA_DISK(block, off_, // note this size is to make the hint do // what we want - lfs->cfg->block_size - off_), + lfs3->cfg->block_size - off_), &gcksumdelta_); if (err) { - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } return err; @@ -2764,22 +2766,22 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, } // check phase - if (lfsr_tag_phase(tag) != (block & 0x3)) { + if (lfs3_tag_phase(tag) != (block & 0x3)) { // uh oh, phase doesn't match, mounted incorrectly? break; } // check checksum uint32_t cksum__ = 0; - err = lfsr_bd_read(lfs, block, off_, -1, + err = lfs3_bd_read(lfs3, block, off_, -1, &cksum__, sizeof(uint32_t)); if (err) { - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } return err; } - cksum__ = lfs_fromle32(&cksum__); + cksum__ = lfs3_fromle32(&cksum__); if (cksum_ != cksum__) { // uh oh, checksums don't match @@ -2788,11 +2790,11 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, // save what we've found so far rbyd->eoff - = ((lfs_size_t)lfsr_tag_perturb(tag) - << (8*sizeof(lfs_size_t)-1)) + = ((lfs3_size_t)lfs3_tag_perturb(tag) + << (8*sizeof(lfs3_size_t)-1)) | (off_ + size); rbyd->cksum = cksum; - rbyd->trunk = (LFSR_RBYD_ISSHRUB & rbyd->trunk) | trunk_; + rbyd->trunk = (LFS3_RBYD_ISSHRUB & rbyd->trunk) | trunk_; rbyd->weight = weight; ecksum = ecksum_; ecksum_.cksize = -1; @@ -2803,14 +2805,14 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, // revert to canonical checksum and perturb if necessary cksum_ = cksum - ^ ((lfsr_rbyd_isperturb(rbyd)) - ? LFS_CRC32C_ODDZERO + ^ ((lfs3_rbyd_isperturb(rbyd)) + ? LFS3_CRC32C_ODDZERO : 0); } } // found a trunk? - if (lfsr_tag_istrunk(tag)) { + if (lfs3_tag_istrunk(tag)) { if (!(trunk && off > trunk && !trunk__)) { // start of trunk? if (!trunk__) { @@ -2829,9 +2831,9 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, weight_ += weight__; // end of trunk? - if (!lfsr_tag_isalt(tag)) { + if (!lfs3_tag_isalt(tag)) { // update trunk and weight, unless we are a shrub trunk - if (!lfsr_tag_isshrub(tag) || trunk__ == trunk) { + if (!lfs3_tag_isshrub(tag) || trunk__ == trunk) { trunk_ = trunk__; weight = weight_; } @@ -2843,13 +2845,13 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, // state, we don't want erased-state affecting our // canonical checksum cksum = cksum_ - ^ ((lfsr_rbyd_isperturb(rbyd)) - ? LFS_CRC32C_ODDZERO + ^ ((lfs3_rbyd_isperturb(rbyd)) + ? LFS3_CRC32C_ODDZERO : 0); } // skip data - if (!lfsr_tag_isalt(tag)) { + if (!lfs3_tag_isalt(tag)) { off_ += size; } @@ -2857,21 +2859,21 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, } // no valid commits? - if (!lfsr_rbyd_trunk(rbyd)) { - return LFS_ERR_CORRUPT; + if (!lfs3_rbyd_trunk(rbyd)) { + return LFS3_ERR_CORRUPT; } // did we end on a valid commit? we may have erased-state bool erased = false; if (ecksum.cksize != -1) { // check the erased-state checksum - err = lfsr_rbyd_ckecksum(lfs, rbyd, &ecksum); - if (err && err != LFS_ERR_CORRUPT) { + err = lfs3_rbyd_ckecksum(lfs3, rbyd, &ecksum); + if (err && err != LFS3_ERR_CORRUPT) { return err; } // found valid erased-state? - erased = (err != LFS_ERR_CORRUPT); + erased = (err != LFS3_ERR_CORRUPT); } // used eoff=-1 to indicate when there is no erased-state @@ -2879,76 +2881,76 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs, rbyd->eoff = -1; } - #ifdef LFS_DBGRBYDFETCHES - LFS_DEBUG("Fetched rbyd 0x%"PRIx32".%"PRIx32" w%"PRId32", " + #ifdef LFS3_DBGRBYDFETCHES + LFS3_DEBUG("Fetched rbyd 0x%"PRIx32".%"PRIx32" w%"PRId32", " "eoff %"PRId32", cksum %"PRIx32, - rbyd->blocks[0], lfsr_rbyd_trunk(rbyd), + rbyd->blocks[0], lfs3_rbyd_trunk(rbyd), rbyd->weight, - (lfsr_rbyd_eoff(rbyd) >= lfs->cfg->block_size) + (lfs3_rbyd_eoff(rbyd) >= lfs3->cfg->block_size) ? -1 - : (lfs_ssize_t)lfsr_rbyd_eoff(rbyd), + : (lfs3_ssize_t)lfs3_rbyd_eoff(rbyd), rbyd->cksum); #endif // debugging rbyd balance? check that all branches in the rbyd have // the same height - #ifdef LFS_DBGRBYDBALANCE - lfsr_srid_t rid = -1; - lfsr_tag_t tag = 0; - lfs_size_t min_height = 0; - lfs_size_t max_height = 0; - lfs_size_t min_bheight = 0; - lfs_size_t max_bheight = 0; + #ifdef LFS3_DBGRBYDBALANCE + lfs3_srid_t rid = -1; + lfs3_tag_t tag = 0; + lfs3_size_t min_height = 0; + lfs3_size_t max_height = 0; + lfs3_size_t min_bheight = 0; + lfs3_size_t max_bheight = 0; while (true) { - lfs_size_t height; - lfs_size_t bheight; - int err = lfsr_rbyd_lookupnext_(lfs, rbyd, + lfs3_size_t height; + lfs3_size_t bheight; + int err = lfs3_rbyd_lookupnext_(lfs3, rbyd, rid, tag+1, &rid, &tag, NULL, NULL, &height, &bheight); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; } // find the min/max height and bheight - min_height = (min_height) ? lfs_min(min_height, height) : height; - max_height = (max_height) ? lfs_max(max_height, height) : height; - min_bheight = (min_bheight) ? lfs_min(min_bheight, bheight) : bheight; - max_bheight = (max_bheight) ? lfs_max(max_bheight, bheight) : bheight; + min_height = (min_height) ? lfs3_min(min_height, height) : height; + max_height = (max_height) ? lfs3_max(max_height, height) : height; + min_bheight = (min_bheight) ? lfs3_min(min_bheight, bheight) : bheight; + max_bheight = (max_bheight) ? lfs3_max(max_bheight, bheight) : bheight; } - LFS_DEBUG("Fetched rbyd 0x%"PRIx32".%"PRIx32" w%"PRId32", " + LFS3_DEBUG("Fetched rbyd 0x%"PRIx32".%"PRIx32" w%"PRId32", " "height %"PRId32"-%"PRId32", " "bheight %"PRId32"-%"PRId32, - rbyd->blocks[0], lfsr_rbyd_trunk(rbyd), + rbyd->blocks[0], lfs3_rbyd_trunk(rbyd), rbyd->weight, min_height, max_height, min_bheight, max_bheight); // all branches in the rbyd should have the same bheight - LFS_ASSERT(max_bheight == min_bheight); + LFS3_ASSERT(max_bheight == min_bheight); // this limits alt height to no worse than 2*bheight+2 (2*bheight+1 // for normal appends, 2*bheight+2 with range removals) - LFS_ASSERT(max_height <= 2*min_height+2); + LFS3_ASSERT(max_height <= 2*min_height+2); #endif return 0; } -static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfs_block_t block, lfs_size_t trunk) { - return lfsr_rbyd_fetch_(lfs, rbyd, NULL, block, trunk); +static int lfs3_rbyd_fetch(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_block_t block, lfs3_size_t trunk) { + return lfs3_rbyd_fetch_(lfs3, rbyd, NULL, block, trunk); } // a more aggressive fetch when checksum is known -static int lfsr_rbyd_fetchck(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfs_block_t block, lfs_size_t trunk, +static int lfs3_rbyd_fetchck(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_block_t block, lfs3_size_t trunk, uint32_t cksum) { - int err = lfsr_rbyd_fetch(lfs, rbyd, block, trunk); + int err = lfs3_rbyd_fetch(lfs3, rbyd, block, trunk); if (err) { - if (err == LFS_ERR_CORRUPT) { - LFS_ERROR("Found corrupted rbyd 0x%"PRIx32".%"PRIx32", " + if (err == LFS3_ERR_CORRUPT) { + LFS3_ERROR("Found corrupted rbyd 0x%"PRIx32".%"PRIx32", " "cksum %08"PRIx32, block, trunk, cksum); } @@ -2961,16 +2963,16 @@ static int lfsr_rbyd_fetchck(lfs_t *lfs, lfsr_rbyd_t *rbyd, // above fetch failing, since that would require the rbyd to have the // same trunk and pass its internal cksum if (rbyd->cksum != cksum) { - LFS_ERROR("Found rbyd cksum mismatch 0x%"PRIx32".%"PRIx32", " + LFS3_ERROR("Found rbyd cksum mismatch 0x%"PRIx32".%"PRIx32", " "cksum %08"PRIx32" (!= %08"PRIx32")", - rbyd->blocks[0], lfsr_rbyd_trunk(rbyd), + rbyd->blocks[0], lfs3_rbyd_trunk(rbyd), rbyd->cksum, cksum); - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } // if trunk/weight mismatch _after_ cksums match, that's not a storage // error, that's a programming error - LFS_ASSERT(lfsr_rbyd_trunk(rbyd) == trunk); + LFS3_ASSERT(lfs3_rbyd_trunk(rbyd) == trunk); return 0; } @@ -2978,21 +2980,21 @@ 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_, - lfsr_data_t *data_, - lfs_size_t *height_, lfs_size_t *bheight_) { +static int lfs3_rbyd_lookupnext_(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, lfs3_tag_t tag, + lfs3_srid_t *rid_, lfs3_tag_t *tag_, lfs3_rid_t *weight_, + lfs3_data_t *data_, + lfs3_size_t *height_, lfs3_size_t *bheight_) { // these bits should be clear at this point - LFS_ASSERT(lfsr_tag_mode(tag) == 0); + LFS3_ASSERT(lfs3_tag_mode(tag) == 0); // make sure we never look up zero tags, the way we create // unreachable tags has a hole here - tag = lfs_max(tag, 0x1); + tag = lfs3_max(tag, 0x1); // out of bounds? no trunk yet? - if (rid >= (lfsr_srid_t)rbyd->weight || !lfsr_rbyd_trunk(rbyd)) { - return LFS_ERR_NOENT; + if (rid >= (lfs3_srid_t)rbyd->weight || !lfs3_rbyd_trunk(rbyd)) { + return LFS3_ERR_NOENT; } // optionally find height/bheight for debugging rbyd balance @@ -3004,16 +3006,16 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } // keep track of bounds as we descend down the tree - lfs_size_t branch = lfsr_rbyd_trunk(rbyd); - lfsr_srid_t lower_rid = 0; - lfsr_srid_t upper_rid = rbyd->weight; + lfs3_size_t branch = lfs3_rbyd_trunk(rbyd); + lfs3_srid_t lower_rid = 0; + lfs3_srid_t upper_rid = rbyd->weight; // descend down tree while (true) { - lfsr_tag_t alt; - lfsr_rid_t weight; - lfs_size_t jump; - lfs_ssize_t d = lfsr_bd_readtag(lfs, + lfs3_tag_t alt; + lfs3_rid_t weight; + lfs3_size_t jump; + lfs3_ssize_t d = lfs3_bd_readtag(lfs3, rbyd->blocks[0], branch, 0, &alt, &weight, &jump, NULL); @@ -3022,8 +3024,8 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } // found an alt? - if (lfsr_tag_isalt(alt)) { - lfs_size_t branch_ = branch + d; + if (lfs3_tag_isalt(alt)) { + lfs3_size_t branch_ = branch + d; // keep track of height for debugging if (height_) { @@ -3031,8 +3033,8 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } if (bheight_ // only count black+followed alts towards bheight - && (lfsr_tag_isblack(alt) - || lfsr_tag_follow( + && (lfs3_tag_isblack(alt) + || lfs3_tag_follow( alt, weight, lower_rid, upper_rid, rid, tag))) { @@ -3040,34 +3042,34 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } // take alt? - if (lfsr_tag_follow( + if (lfs3_tag_follow( alt, weight, lower_rid, upper_rid, rid, tag)) { - lfsr_tag_flip( + lfs3_tag_flip( &alt, &weight, lower_rid, upper_rid); branch_ = branch - jump; } - lfsr_tag_trim( + lfs3_tag_trim( alt, weight, &lower_rid, &upper_rid, NULL, NULL); - LFS_ASSERT(branch_ != branch); + LFS3_ASSERT(branch_ != branch); branch = branch_; // found end of tree? } else { // update the tag rid - lfsr_srid_t rid__ = upper_rid-1; - lfsr_tag_t tag__ = lfsr_tag_key(alt); + lfs3_srid_t rid__ = upper_rid-1; + lfs3_tag_t tag__ = lfs3_tag_key(alt); // not what we're looking for? if (!tag__ || rid__ < rid || (rid__ == rid && tag__ < tag)) { - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // save what we found @@ -3082,7 +3084,7 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, *weight_ = upper_rid - lower_rid; } if (data_) { - *data_ = LFSR_DATA_DISK(rbyd->blocks[0], branch + d, jump); + *data_ = LFS3_DATA_DISK(rbyd->blocks[0], branch + d, jump); } return 0; } @@ -3091,22 +3093,22 @@ 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_, - lfsr_data_t *data_) { - return lfsr_rbyd_lookupnext_(lfs, rbyd, rid, tag, +static int lfs3_rbyd_lookupnext(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, lfs3_tag_t tag, + lfs3_srid_t *rid_, lfs3_tag_t *tag_, lfs3_rid_t *weight_, + lfs3_data_t *data_) { + return lfs3_rbyd_lookupnext_(lfs3, rbyd, rid, tag, rid_, tag_, weight_, data_, 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_tag_t *tag_, lfsr_data_t *data_) { - lfsr_srid_t rid__; - lfsr_tag_t tag__; - int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid, lfsr_tag_key(tag), +static int lfs3_rbyd_lookup(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, lfs3_tag_t tag, + lfs3_tag_t *tag_, lfs3_data_t *data_) { + lfs3_srid_t rid__; + lfs3_tag_t tag__; + int err = lfs3_rbyd_lookupnext(lfs3, rbyd, rid, lfs3_tag_key(tag), &rid__, &tag__, NULL, data_); if (err) { return err; @@ -3115,8 +3117,8 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // lookup finds the next-smallest tag, all we need to do is fail if it // picks up the wrong tag if (rid__ != rid - || (tag__ & lfsr_tag_mask(tag)) != (tag & lfsr_tag_mask(tag))) { - return LFS_ERR_NOENT; + || (tag__ & lfs3_tag_mask(tag)) != (tag & lfs3_tag_mask(tag))) { + return LFS3_ERR_NOENT; } if (tag_) { @@ -3132,18 +3134,18 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // append a revision count // // this is optional, if not called revision count defaults to 0 (for btrees) -static int lfsr_rbyd_appendrev(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) { +static int lfs3_rbyd_appendrev(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, uint32_t rev) { // should only be called before any tags are written - LFS_ASSERT(rbyd->eoff == 0); - LFS_ASSERT(rbyd->cksum == 0); + LFS3_ASSERT(rbyd->eoff == 0); + LFS3_ASSERT(rbyd->cksum == 0); // revision count stored as le32, we don't use a leb128 encoding as we // intentionally allow the revision count to overflow uint8_t rev_buf[sizeof(uint32_t)]; - lfs_tole32(rev, &rev_buf); + lfs3_tole32(rev, &rev_buf); - int err = lfsr_bd_prog(lfs, - rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), + int err = lfs3_bd_prog(lfs3, + rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), &rev_buf, sizeof(uint32_t), &rbyd->cksum, false); if (err) { @@ -3155,21 +3157,21 @@ static int lfsr_rbyd_appendrev(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) { } // other low-level appends -static int lfsr_rbyd_appendtag(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_tag_t tag, lfsr_rid_t weight, lfs_size_t size) { +static int lfs3_rbyd_appendtag(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_tag_t tag, lfs3_rid_t weight, lfs3_size_t size) { // tag must not be internal at this point - LFS_ASSERT(!lfsr_tag_isinternal(tag)); + LFS3_ASSERT(!lfs3_tag_isinternal(tag)); // bit 7 is reserved for future subtype extensions - LFS_ASSERT(!(tag & 0x80)); + LFS3_ASSERT(!(tag & 0x80)); // do we fit? - if (lfsr_rbyd_eoff(rbyd) + LFSR_TAG_DSIZE - > lfs->cfg->block_size) { - return LFS_ERR_RANGE; + if (lfs3_rbyd_eoff(rbyd) + LFS3_TAG_DSIZE + > lfs3->cfg->block_size) { + return LFS3_ERR_RANGE; } - lfs_ssize_t d = lfsr_bd_progtag(lfs, - rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), lfsr_rbyd_isperturb(rbyd), + lfs3_ssize_t d = lfs3_bd_progtag(lfs3, + rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), lfs3_rbyd_isperturb(rbyd), tag, weight, size, &rbyd->cksum, false); if (d < 0) { @@ -3178,39 +3180,39 @@ static int lfsr_rbyd_appendtag(lfs_t *lfs, lfsr_rbyd_t *rbyd, rbyd->eoff += d; - #ifdef LFS_CKMETAPARITY + #ifdef LFS3_CKMETAPARITY // keep track of most recent parity - lfs->ptail.block = rbyd->blocks[0]; - lfs->ptail.off - = ((lfs_size_t)( - lfs_parity(rbyd->cksum) ^ lfsr_rbyd_isperturb(rbyd) - ) << (8*sizeof(lfs_size_t)-1)) - | lfsr_rbyd_eoff(rbyd); + lfs3->ptail.block = rbyd->blocks[0]; + lfs3->ptail.off + = ((lfs3_size_t)( + lfs3_parity(rbyd->cksum) ^ lfs3_rbyd_isperturb(rbyd) + ) << (8*sizeof(lfs3_size_t)-1)) + | lfs3_rbyd_eoff(rbyd); #endif return 0; } -// needed in lfsr_rbyd_appendrattr_ -typedef struct lfsr_geometry lfsr_geometry_t; -static lfsr_data_t lfsr_data_fromgeometry(const lfsr_geometry_t *geometry, - uint8_t buffer[static LFSR_GEOMETRY_DSIZE]); -static lfsr_data_t lfsr_data_frombptr(const lfsr_bptr_t *bptr, - uint8_t buffer[static LFSR_BPTR_DSIZE]); -static lfsr_data_t lfsr_data_fromshrub(const lfsr_shrub_t *shrub, - uint8_t buffer[static LFSR_SHRUB_DSIZE]); -static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree, - uint8_t buffer[static LFSR_BTREE_DSIZE]); -static lfsr_data_t lfsr_data_frommptr(const lfs_block_t mptr[static 2], - uint8_t buffer[static LFSR_MPTR_DSIZE]); +// needed in lfs3_rbyd_appendrattr_ +typedef struct lfs3_geometry lfs3_geometry_t; +static lfs3_data_t lfs3_data_fromgeometry(const lfs3_geometry_t *geometry, + uint8_t buffer[static LFS3_GEOMETRY_DSIZE]); +static lfs3_data_t lfs3_data_frombptr(const lfs3_bptr_t *bptr, + uint8_t buffer[static LFS3_BPTR_DSIZE]); +static lfs3_data_t lfs3_data_fromshrub(const lfs3_shrub_t *shrub, + uint8_t buffer[static LFS3_SHRUB_DSIZE]); +static lfs3_data_t lfs3_data_frombtree(const lfs3_btree_t *btree, + uint8_t buffer[static LFS3_BTREE_DSIZE]); +static lfs3_data_t lfs3_data_frommptr(const lfs3_block_t mptr[static 2], + uint8_t buffer[static LFS3_MPTR_DSIZE]); // encode rattrs -static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_rattr_t rattr) { +static int lfs3_rbyd_appendrattr_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_rattr_t rattr) { // tag must not be internal at this point - LFS_ASSERT(!lfsr_tag_isinternal(rattr.tag)); + LFS3_ASSERT(!lfs3_tag_isinternal(rattr.tag)); // bit 7 is reserved for future subtype extensions - LFS_ASSERT(!(rattr.tag & 0x80)); + LFS3_ASSERT(!(rattr.tag & 0x80)); // encode lazy tags? // @@ -3221,128 +3223,128 @@ static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // explicit data bypasses the lazy encoding, which is necessary to // allow copies during compaction, relocation, etc // - lfs_size_t size; + lfs3_size_t size; const void *data; int16_t count; struct { // uh, there's probably a better way to do this, but I'm not // sure what it is union { - uint8_t buf[LFS_MAX( - LFSR_LE32_DSIZE, - LFS_MAX( - LFSR_LEB128_DSIZE, - LFS_MAX( - LFSR_GEOMETRY_DSIZE, - LFS_MAX( - LFSR_BPTR_DSIZE, - LFS_MAX( - LFSR_SHRUB_DSIZE, - LFS_MAX( - LFSR_BTREE_DSIZE, - LFS_MAX( - LFSR_MPTR_DSIZE, - LFSR_ECKSUM_DSIZE)))))))]; + uint8_t buf[LFS3_MAX( + LFS3_LE32_DSIZE, + LFS3_MAX( + LFS3_LEB128_DSIZE, + LFS3_MAX( + LFS3_GEOMETRY_DSIZE, + LFS3_MAX( + LFS3_BPTR_DSIZE, + LFS3_MAX( + LFS3_SHRUB_DSIZE, + LFS3_MAX( + LFS3_BTREE_DSIZE, + LFS3_MAX( + LFS3_MPTR_DSIZE, + LFS3_ECKSUM_DSIZE)))))))]; struct { - lfsr_data_t datas[2]; - uint8_t buf[LFSR_LEB128_DSIZE]; + lfs3_data_t datas[2]; + uint8_t buf[LFS3_LEB128_DSIZE]; } name; } u; } ctx; // le32? if (rattr.count >= 0 - && (rattr.tag == LFSR_TAG_RCOMPAT - || rattr.tag == LFSR_TAG_WCOMPAT - || rattr.tag == LFSR_TAG_OCOMPAT - || rattr.tag == LFSR_TAG_GCKSUMDELTA)) { - lfsr_data_t data_ = lfsr_data_fromle32(rattr.u.le32, ctx.u.buf); - size = lfsr_data_size(data_); + && (rattr.tag == LFS3_TAG_RCOMPAT + || rattr.tag == LFS3_TAG_WCOMPAT + || rattr.tag == LFS3_TAG_OCOMPAT + || rattr.tag == LFS3_TAG_GCKSUMDELTA)) { + lfs3_data_t data_ = lfs3_data_fromle32(rattr.u.le32, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // leb128? } else if (rattr.count >= 0 - && (rattr.tag == LFSR_TAG_NAMELIMIT - || rattr.tag == LFSR_TAG_FILELIMIT - || rattr.tag == LFSR_TAG_DID)) { + && (rattr.tag == LFS3_TAG_NAMELIMIT + || rattr.tag == LFS3_TAG_FILELIMIT + || rattr.tag == LFS3_TAG_DID)) { // leb128s should not exceed 31-bits - LFS_ASSERT(rattr.u.leb128 <= 0x7fffffff); + LFS3_ASSERT(rattr.u.leb128 <= 0x7fffffff); // little-leb128s should not exceed 28-bits - LFS_ASSERT(rattr.tag != LFSR_TAG_NAMELIMIT + LFS3_ASSERT(rattr.tag != LFS3_TAG_NAMELIMIT || rattr.u.leb128 <= 0x0fffffff); - lfsr_data_t data_ = lfsr_data_fromleb128(rattr.u.leb128, ctx.u.buf); - size = lfsr_data_size(data_); + lfs3_data_t data_ = lfs3_data_fromleb128(rattr.u.leb128, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // geometry? } else if (rattr.count >= 0 - && rattr.tag == LFSR_TAG_GEOMETRY) { - lfsr_data_t data_ = lfsr_data_fromgeometry(rattr.u.etc, ctx.u.buf); - size = lfsr_data_size(data_); + && rattr.tag == LFS3_TAG_GEOMETRY) { + lfs3_data_t data_ = lfs3_data_fromgeometry(rattr.u.etc, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // name? } else if (rattr.count >= 0 - && lfsr_tag_suptype(rattr.tag) == LFSR_TAG_NAME) { - const lfsr_name_t *name = rattr.u.etc; - ctx.u.name.datas[0] = lfsr_data_fromleb128(name->did, ctx.u.name.buf); - ctx.u.name.datas[1] = LFSR_DATA_BUF(name->name, name->name_len); - size = lfsr_data_size(ctx.u.name.datas[0]) + name->name_len; + && lfs3_tag_suptype(rattr.tag) == LFS3_TAG_NAME) { + const lfs3_name_t *name = rattr.u.etc; + ctx.u.name.datas[0] = lfs3_data_fromleb128(name->did, ctx.u.name.buf); + ctx.u.name.datas[1] = LFS3_DATA_BUF(name->name, name->name_len); + size = lfs3_data_size(ctx.u.name.datas[0]) + name->name_len; data = &ctx.u.name.datas; count = -2; // bptr? } else if (rattr.count >= 0 - && (rattr.tag == LFSR_TAG_BLOCK - || rattr.tag == (LFSR_TAG_SHRUB | LFSR_TAG_BLOCK))) { - lfsr_data_t data_ = lfsr_data_frombptr(rattr.u.etc, ctx.u.buf); - size = lfsr_data_size(data_); + && (rattr.tag == LFS3_TAG_BLOCK + || rattr.tag == (LFS3_TAG_SHRUB | LFS3_TAG_BLOCK))) { + lfs3_data_t data_ = lfs3_data_frombptr(rattr.u.etc, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // shrub trunk? } else if (rattr.count >= 0 - && rattr.tag == LFSR_TAG_BSHRUB) { + && rattr.tag == LFS3_TAG_BSHRUB) { // note unlike the other lazy tags, we _need_ to lazily encode // shrub trunks, since they change underneath us during mdir // compactions, relocations, etc - lfsr_data_t data_ = lfsr_data_fromshrub(rattr.u.etc, ctx.u.buf); - size = lfsr_data_size(data_); + lfs3_data_t data_ = lfs3_data_fromshrub(rattr.u.etc, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // btree? } else if (rattr.count >= 0 - && (rattr.tag == LFSR_TAG_BTREE - || rattr.tag == LFSR_TAG_MTREE)) { - lfsr_data_t data_ = lfsr_data_frombtree(rattr.u.etc, ctx.u.buf); - size = lfsr_data_size(data_); + && (rattr.tag == LFS3_TAG_BTREE + || rattr.tag == LFS3_TAG_MTREE)) { + lfs3_data_t data_ = lfs3_data_frombtree(rattr.u.etc, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // mptr? } else if (rattr.count >= 0 - && (rattr.tag == LFSR_TAG_MROOT - || rattr.tag == LFSR_TAG_MDIR)) { - lfsr_data_t data_ = lfsr_data_frommptr(rattr.u.etc, ctx.u.buf); - size = lfsr_data_size(data_); + && (rattr.tag == LFS3_TAG_MROOT + || rattr.tag == LFS3_TAG_MDIR)) { + lfs3_data_t data_ = lfs3_data_frommptr(rattr.u.etc, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // ecksum? } else if (rattr.count >= 0 - && rattr.tag == LFSR_TAG_ECKSUM) { - lfsr_data_t data_ = lfsr_data_fromecksum(rattr.u.etc, ctx.u.buf); - size = lfsr_data_size(data_); + && rattr.tag == LFS3_TAG_ECKSUM) { + lfs3_data_t data_ = lfs3_data_fromecksum(rattr.u.etc, ctx.u.buf); + size = lfs3_data_size(data_); data = ctx.u.buf; count = size; // default to raw data } else { - size = lfsr_rattr_dsize(rattr); + size = lfs3_rattr_dsize(rattr); data = rattr.u.datas; count = rattr.count; } @@ -3350,13 +3352,13 @@ static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // now everything should be raw data, either in-ram or on-disk // do we fit? - if (lfsr_rbyd_eoff(rbyd) + LFSR_TAG_DSIZE + size - > lfs->cfg->block_size) { - return LFS_ERR_RANGE; + if (lfs3_rbyd_eoff(rbyd) + LFS3_TAG_DSIZE + size + > lfs3->cfg->block_size) { + return LFS3_ERR_RANGE; } // append tag - int err = lfsr_rbyd_appendtag(lfs, rbyd, + int err = lfs3_rbyd_appendtag(lfs3, rbyd, rattr.tag, rattr.weight, size); if (err) { return err; @@ -3364,8 +3366,8 @@ static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // direct buffer? if (count >= 0) { - err = lfsr_bd_prog(lfs, - rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), data, count, + err = lfs3_bd_prog(lfs3, + rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), data, count, &rbyd->cksum, false); if (err) { return err; @@ -3375,46 +3377,46 @@ static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // indirect concatenated data? } else { - const lfsr_data_t *datas = data; - lfs_size_t data_count = -count; - for (lfs_size_t i = 0; i < data_count; i++) { - err = lfsr_bd_progdata(lfs, - rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), datas[i], + const lfs3_data_t *datas = data; + lfs3_size_t data_count = -count; + for (lfs3_size_t i = 0; i < data_count; i++) { + err = lfs3_bd_progdata(lfs3, + rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), datas[i], &rbyd->cksum, false); if (err) { return err; } - rbyd->eoff += lfsr_data_size(datas[i]); + rbyd->eoff += lfs3_data_size(datas[i]); } } - #ifdef LFS_CKMETAPARITY + #ifdef LFS3_CKMETAPARITY // keep track of most recent parity - lfs->ptail.block = rbyd->blocks[0]; - lfs->ptail.off - = ((lfs_size_t)( - lfs_parity(rbyd->cksum) ^ lfsr_rbyd_isperturb(rbyd) - ) << (8*sizeof(lfs_size_t)-1)) - | lfsr_rbyd_eoff(rbyd); + lfs3->ptail.block = rbyd->blocks[0]; + lfs3->ptail.off + = ((lfs3_size_t)( + lfs3_parity(rbyd->cksum) ^ lfs3_rbyd_isperturb(rbyd) + ) << (8*sizeof(lfs3_size_t)-1)) + | lfs3_rbyd_eoff(rbyd); #endif return 0; } // checks before we append -static int lfsr_rbyd_appendinit(lfs_t *lfs, lfsr_rbyd_t *rbyd) { +static int lfs3_rbyd_appendinit(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { // must fetch before mutating! - LFS_ASSERT(lfsr_rbyd_isfetched(rbyd)); + LFS3_ASSERT(lfs3_rbyd_isfetched(rbyd)); // we can't do anything if we're not erased - if (lfsr_rbyd_eoff(rbyd) >= lfs->cfg->block_size) { - return LFS_ERR_RANGE; + if (lfs3_rbyd_eoff(rbyd) >= lfs3->cfg->block_size) { + return LFS3_ERR_RANGE; } // make sure every rbyd starts with a revision count if (rbyd->eoff == 0) { - int err = lfsr_rbyd_appendrev(lfs, rbyd, 0); + int err = lfs3_rbyd_appendrev(lfs3, rbyd, 0); if (err) { return err; } @@ -3424,15 +3426,15 @@ static int lfsr_rbyd_appendinit(lfs_t *lfs, lfsr_rbyd_t *rbyd) { } // helper functions for managing the 3-element fifo used in -// lfsr_rbyd_appendrattr -typedef struct lfsr_alt { - lfsr_tag_t alt; - lfsr_rid_t weight; - lfs_size_t jump; -} lfsr_alt_t; +// lfs3_rbyd_appendrattr +typedef struct lfs3_alt { + lfs3_tag_t alt; + lfs3_rid_t weight; + lfs3_size_t jump; +} lfs3_alt_t; -static int lfsr_rbyd_p_flush(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_alt_t p[static 3], +static int lfs3_rbyd_p_flush(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_alt_t p[static 3], int count) { // write out some number of alt pointers in our queue for (int i = 0; i < count; i++) { @@ -3440,15 +3442,15 @@ static int lfsr_rbyd_p_flush(lfs_t *lfs, lfsr_rbyd_t *rbyd, // jump=0 represents an unreachable alt, we do write out // unreachable alts sometimes in order to maintain the // balance of the tree - LFS_ASSERT(p[3-1-i].jump || lfsr_tag_isblack(p[3-1-i].alt)); - lfsr_tag_t alt = p[3-1-i].alt; - lfsr_rid_t weight = p[3-1-i].weight; + LFS3_ASSERT(p[3-1-i].jump || lfs3_tag_isblack(p[3-1-i].alt)); + lfs3_tag_t alt = p[3-1-i].alt; + lfs3_rid_t weight = p[3-1-i].weight; // change to a relative jump at the last minute - lfs_size_t jump = (p[3-1-i].jump) - ? lfsr_rbyd_eoff(rbyd) - p[3-1-i].jump + lfs3_size_t jump = (p[3-1-i].jump) + ? lfs3_rbyd_eoff(rbyd) - p[3-1-i].jump : 0; - int err = lfsr_rbyd_appendtag(lfs, rbyd, alt, weight, jump); + int err = lfs3_rbyd_appendtag(lfs3, rbyd, alt, weight, jump); if (err) { return err; } @@ -3458,37 +3460,37 @@ static int lfsr_rbyd_p_flush(lfs_t *lfs, lfsr_rbyd_t *rbyd, return 0; } -static inline int lfsr_rbyd_p_push(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_alt_t p[static 3], - lfsr_tag_t alt, lfsr_rid_t weight, lfs_size_t jump) { +static inline int lfs3_rbyd_p_push(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_alt_t p[static 3], + lfs3_tag_t alt, lfs3_rid_t weight, lfs3_size_t jump) { // jump should actually be in the rbyd - LFS_ASSERT(jump < lfsr_rbyd_eoff(rbyd)); + LFS3_ASSERT(jump < lfs3_rbyd_eoff(rbyd)); - int err = lfsr_rbyd_p_flush(lfs, rbyd, p, 1); + int err = lfs3_rbyd_p_flush(lfs3, rbyd, p, 1); if (err) { return err; } - lfs_memmove(p+1, p, 2*sizeof(lfsr_alt_t)); + lfs3_memmove(p+1, p, 2*sizeof(lfs3_alt_t)); p[0].alt = alt; p[0].weight = weight; p[0].jump = jump; return 0; } -static inline void lfsr_rbyd_p_pop( - lfsr_alt_t p[static 3]) { - lfs_memmove(p, p+1, 2*sizeof(lfsr_alt_t)); +static inline void lfs3_rbyd_p_pop( + lfs3_alt_t p[static 3]) { + lfs3_memmove(p, p+1, 2*sizeof(lfs3_alt_t)); p[2].alt = 0; } -static void lfsr_rbyd_p_recolor( - lfsr_alt_t p[static 3]) { +static void lfs3_rbyd_p_recolor( + lfs3_alt_t p[static 3]) { // propagate a red edge upwards - p[0].alt &= ~LFSR_TAG_R; + p[0].alt &= ~LFS3_TAG_R; if (p[1].alt) { - p[1].alt |= LFSR_TAG_R; + p[1].alt |= LFS3_TAG_R; // unreachable alt? we can prune this now if (!p[1].jump) { @@ -3496,70 +3498,70 @@ static void lfsr_rbyd_p_recolor( p[2].alt = 0; // reorder so that top two edges always go in the same direction - } else if (lfsr_tag_isred(p[2].alt)) { - if (lfsr_tag_isparallel(p[1].alt, p[2].alt)) { + } else if (lfs3_tag_isred(p[2].alt)) { + if (lfs3_tag_isparallel(p[1].alt, p[2].alt)) { // no reorder needed - } else if (lfsr_tag_isparallel(p[0].alt, p[2].alt)) { - lfsr_tag_t alt_ = p[1].alt; - lfsr_rid_t weight_ = p[1].weight; - lfs_size_t jump_ = p[1].jump; - p[1].alt = p[0].alt | LFSR_TAG_R; + } else if (lfs3_tag_isparallel(p[0].alt, p[2].alt)) { + lfs3_tag_t alt_ = p[1].alt; + lfs3_rid_t weight_ = p[1].weight; + lfs3_size_t jump_ = p[1].jump; + p[1].alt = p[0].alt | LFS3_TAG_R; p[1].weight = p[0].weight; p[1].jump = p[0].jump; - p[0].alt = alt_ & ~LFSR_TAG_R; + p[0].alt = alt_ & ~LFS3_TAG_R; p[0].weight = weight_; p[0].jump = jump_; - } else if (lfsr_tag_isparallel(p[0].alt, p[1].alt)) { - lfsr_tag_t alt_ = p[2].alt; - lfsr_rid_t weight_ = p[2].weight; - lfs_size_t jump_ = p[2].jump; - p[2].alt = p[1].alt | LFSR_TAG_R; + } else if (lfs3_tag_isparallel(p[0].alt, p[1].alt)) { + lfs3_tag_t alt_ = p[2].alt; + lfs3_rid_t weight_ = p[2].weight; + lfs3_size_t jump_ = p[2].jump; + p[2].alt = p[1].alt | LFS3_TAG_R; p[2].weight = p[1].weight; p[2].jump = p[1].jump; - p[1].alt = p[0].alt | LFSR_TAG_R; + p[1].alt = p[0].alt | LFS3_TAG_R; p[1].weight = p[0].weight; p[1].jump = p[0].jump; - p[0].alt = alt_ & ~LFSR_TAG_R; + p[0].alt = alt_ & ~LFS3_TAG_R; p[0].weight = weight_; p[0].jump = jump_; } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } } } // our core rbyd append algorithm -static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_srid_t rid, lfsr_rattr_t rattr) { +static int lfs3_rbyd_appendrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, lfs3_rattr_t rattr) { // must fetch before mutating! - LFS_ASSERT(lfsr_rbyd_isfetched(rbyd)); + LFS3_ASSERT(lfs3_rbyd_isfetched(rbyd)); // tag must not be internal at this point - LFS_ASSERT(!lfsr_tag_isinternal(rattr.tag)); + LFS3_ASSERT(!lfs3_tag_isinternal(rattr.tag)); // bit 7 is reserved for future subtype extensions - LFS_ASSERT(!(rattr.tag & 0x80)); + LFS3_ASSERT(!(rattr.tag & 0x80)); // you can't delete more than what's in the rbyd - LFS_ASSERT(rattr.weight >= -(lfsr_srid_t)rbyd->weight); + LFS3_ASSERT(rattr.weight >= -(lfs3_srid_t)rbyd->weight); // ignore noops - if (lfsr_rattr_isnoop(rattr)) { + if (lfs3_rattr_isnoop(rattr)) { return 0; } // begin appending - int err = lfsr_rbyd_appendinit(lfs, rbyd); + int err = lfs3_rbyd_appendinit(lfs3, rbyd); if (err) { return err; } // figure out what range of tags we're operating on - lfsr_srid_t a_rid; - lfsr_srid_t b_rid; - lfsr_tag_t a_tag; - lfsr_tag_t b_tag; - if (!lfsr_tag_isgrow(rattr.tag) && rattr.weight != 0) { + lfs3_srid_t a_rid; + lfs3_srid_t b_rid; + lfs3_tag_t a_tag; + lfs3_tag_t b_tag; + if (!lfs3_tag_isgrow(rattr.tag) && rattr.weight != 0) { if (rattr.weight > 0) { - LFS_ASSERT(rid <= (lfsr_srid_t)rbyd->weight); + LFS3_ASSERT(rid <= (lfs3_srid_t)rbyd->weight); // it's a bit ugly, but adjusting the rid here makes the following // logic work out more consistently @@ -3567,12 +3569,12 @@ static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, a_rid = rid + 1; b_rid = rid + 1; } else { - LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight); + LFS3_ASSERT(rid < (lfs3_srid_t)rbyd->weight); // it's a bit ugly, but adjusting the rid here makes the following // logic work out more consistently rid += 1; - a_rid = rid - lfs_smax(-rattr.weight, 0); + a_rid = rid - lfs3_smax(-rattr.weight, 0); b_rid = rid; } @@ -3580,32 +3582,32 @@ static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, b_tag = 0; } else { - LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight); + LFS3_ASSERT(rid < (lfs3_srid_t)rbyd->weight); - a_rid = rid - lfs_smax(-rattr.weight, 0); + a_rid = rid - lfs3_smax(-rattr.weight, 0); b_rid = rid; // note both normal and rm wide-tags have the same bounds, really it's // the normal non-wide-tags that are an outlier here - if (lfsr_tag_ismask12(rattr.tag)) { + if (lfs3_tag_ismask12(rattr.tag)) { a_tag = 0x000; b_tag = 0xfff; - } else if (lfsr_tag_ismask8(rattr.tag)) { + } else if (lfs3_tag_ismask8(rattr.tag)) { a_tag = (rattr.tag & 0xf00); b_tag = (rattr.tag & 0xf00) + 0x100; - } else if (lfsr_tag_ismask2(rattr.tag)) { + } else if (lfs3_tag_ismask2(rattr.tag)) { a_tag = (rattr.tag & 0xffc); b_tag = (rattr.tag & 0xffc) + 0x004; - } else if (lfsr_tag_isrm(rattr.tag)) { - a_tag = lfsr_tag_key(rattr.tag); - b_tag = lfsr_tag_key(rattr.tag) + 1; + } else if (lfs3_tag_isrm(rattr.tag)) { + a_tag = lfs3_tag_key(rattr.tag); + b_tag = lfs3_tag_key(rattr.tag) + 1; } else { - a_tag = lfsr_tag_key(rattr.tag); - b_tag = lfsr_tag_key(rattr.tag); + a_tag = lfs3_tag_key(rattr.tag); + b_tag = lfs3_tag_key(rattr.tag); } } - a_tag = lfs_max(a_tag, 0x1); - b_tag = lfs_max(b_tag, 0x1); + a_tag = lfs3_max(a_tag, 0x1); + b_tag = lfs3_max(b_tag, 0x1); // keep track of diverged state // @@ -3618,25 +3620,25 @@ static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, // two diverged trunks together where they diverged // bool diverged = false; - lfsr_tag_t d_tag = 0; - lfsr_srid_t d_weight = 0; + lfs3_tag_t d_tag = 0; + lfs3_srid_t d_weight = 0; // follow the current trunk - lfs_size_t branch = lfsr_rbyd_trunk(rbyd); + lfs3_size_t branch = lfs3_rbyd_trunk(rbyd); trunk:; // the new trunk starts here - lfs_size_t trunk_ = lfsr_rbyd_eoff(rbyd); + lfs3_size_t trunk_ = lfs3_rbyd_eoff(rbyd); // keep track of bounds as we descend down the tree // // this gets a bit confusing as we also may need to keep // track of both the lower and upper bounds of diverging paths // in the case of range deletions - lfsr_srid_t lower_rid = 0; - lfsr_srid_t upper_rid = rbyd->weight; - lfsr_tag_t lower_tag = 0x000; - lfsr_tag_t upper_tag = 0xfff; + lfs3_srid_t lower_rid = 0; + lfs3_srid_t upper_rid = rbyd->weight; + lfs3_tag_t lower_tag = 0x000; + lfs3_tag_t upper_tag = 0xfff; // no trunk yet? if (!branch) { @@ -3644,24 +3646,24 @@ trunk:; } // queue of pending alts we can emulate rotations with - lfsr_alt_t p[3] = {{0}, {0}, {0}}; + lfs3_alt_t p[3] = {{0}, {0}, {0}}; // keep track of the last incoming branch for yellow splits - lfs_size_t y_branch = 0; + lfs3_size_t y_branch = 0; // keep track of the tag we find at the end of the trunk - lfsr_tag_t tag_ = 0; + lfs3_tag_t tag_ = 0; // descend down tree, building alt pointers while (true) { // keep track of incoming branch - if (lfsr_tag_isblack(p[0].alt)) { + if (lfs3_tag_isblack(p[0].alt)) { y_branch = branch; } // read the alt pointer - lfsr_tag_t alt; - lfsr_rid_t weight; - lfs_size_t jump; - lfs_ssize_t d = lfsr_bd_readtag(lfs, + lfs3_tag_t alt; + lfs3_rid_t weight; + lfs3_size_t jump; + lfs3_ssize_t d = lfs3_bd_readtag(lfs3, rbyd->blocks[0], branch, 0, &alt, &weight, &jump, NULL); @@ -3670,29 +3672,29 @@ trunk:; } // found an alt? - if (lfsr_tag_isalt(alt)) { + if (lfs3_tag_isalt(alt)) { // make jump absolute jump = branch - jump; - lfs_size_t branch_ = branch + d; + lfs3_size_t branch_ = branch + d; // yellow alts should be parallel - LFS_ASSERT(!(lfsr_tag_isred(alt) && lfsr_tag_isred(p[0].alt)) - || lfsr_tag_isparallel(alt, p[0].alt)); + LFS3_ASSERT(!(lfs3_tag_isred(alt) && lfs3_tag_isred(p[0].alt)) + || lfs3_tag_isparallel(alt, p[0].alt)); // take black alt? needs a flip // b // .-'| => .-'| // 1 2 1 2 1 - if (lfsr_tag_follow2( + if (lfs3_tag_follow2( alt, weight, p[0].alt, p[0].weight, lower_rid, upper_rid, a_rid, a_tag)) { - lfsr_tag_flip2( + lfs3_tag_flip2( &alt, &weight, p[0].alt, p[0].weight, lower_rid, upper_rid); - LFS_SWAP(lfs_size_t, &jump, &branch_); + LFS3_SWAP(lfs3_size_t, &jump, &branch_); } // should've taken red alt? needs a flip @@ -3701,22 +3703,22 @@ trunk:; // | | >b // | .-'| .--|-'| // 1 2 3 1 2 3 1 - if (lfsr_tag_isred(p[0].alt) - && lfsr_tag_follow( + if (lfs3_tag_isred(p[0].alt) + && lfs3_tag_follow( p[0].alt, p[0].weight, lower_rid, upper_rid, a_rid, a_tag)) { - LFS_SWAP(lfsr_tag_t, &p[0].alt, &alt); - LFS_SWAP(lfsr_rid_t, &p[0].weight, &weight); - LFS_SWAP(lfs_size_t, &p[0].jump, &jump); - alt = (alt & ~LFSR_TAG_R) | (p[0].alt & LFSR_TAG_R); - p[0].alt |= LFSR_TAG_R; + LFS3_SWAP(lfs3_tag_t, &p[0].alt, &alt); + LFS3_SWAP(lfs3_rid_t, &p[0].weight, &weight); + LFS3_SWAP(lfs3_size_t, &p[0].jump, &jump); + alt = (alt & ~LFS3_TAG_R) | (p[0].alt & LFS3_TAG_R); + p[0].alt |= LFS3_TAG_R; - lfsr_tag_flip2( + lfs3_tag_flip2( &alt, &weight, p[0].alt, p[0].weight, lower_rid, upper_rid); - LFS_SWAP(lfs_size_t, &jump, &branch_); + LFS3_SWAP(lfs3_size_t, &jump, &branch_); } // do bounds want to take different paths? begin diverging @@ -3727,14 +3729,14 @@ trunk:; // b_rid || a_tag > b_tag) { - LFS_ASSERT(!diverging_r); + LFS3_ASSERT(!diverging_r); - alt = LFSR_TAG_ALT( - alt & LFSR_TAG_R, - LFSR_TAG_LE, + alt = LFS3_TAG_ALT( + alt & LFS3_TAG_R, + LFS3_TAG_LE, d_tag); weight -= d_weight; lower_rid += d_weight; @@ -3798,7 +3800,7 @@ trunk:; // .-'| .--' // 3 4 3 4 x if (diverging_b) { - lfsr_tag_trim( + lfs3_tag_trim( alt, weight, &lower_rid, &upper_rid, &lower_tag, &upper_tag); @@ -3819,14 +3821,14 @@ trunk:; // | | branch) { - alt &= ~LFSR_TAG_R; - lfsr_rbyd_p_pop(p); + alt &= ~LFS3_TAG_R; + lfs3_rbyd_p_pop(p); // prune unreachable yellow-split red alts // b @@ -3838,22 +3840,22 @@ trunk:; // | | branch) { - alt = p[0].alt & ~LFSR_TAG_R; + alt = p[0].alt & ~LFS3_TAG_R; weight = p[0].weight; jump = p[0].jump; - lfsr_rbyd_p_pop(p); + lfs3_rbyd_p_pop(p); } // prune red alts - if (lfsr_tag_isred(p[0].alt) - && lfsr_tag_unreachable( + if (lfs3_tag_isred(p[0].alt) + && lfs3_tag_unreachable( p[0].alt, p[0].weight, lower_rid, upper_rid, lower_tag, upper_tag)) { @@ -3863,12 +3865,12 @@ trunk:; // | nb // .-'| .--' // 3 4 3 4 x - } else if (lfsr_tag_isblack(alt)) { - alt = LFSR_TAG_ALT( - LFSR_TAG_B, - LFSR_TAG_LE, + } else if (lfs3_tag_isblack(alt)) { + alt = LFS3_TAG_ALT( + LFS3_TAG_B, + LFS3_TAG_LE, (diverged && (a_rid > b_rid || a_tag > b_tag)) ? d_tag : lower_tag); - LFS_ASSERT(weight == 0); + LFS3_ASSERT(weight == 0); // jump=0 also asserts the alt is unreachable (or // else we loop indefinitely), and uses the minimum // alt encoding @@ -3923,7 +3925,7 @@ trunk:; // // note we've lost the original yellow edge because of flips, but // we know the red edge is the only branch_ > branch - if (lfsr_tag_isred(alt) && lfsr_tag_isred(p[0].alt)) { + if (lfs3_tag_isred(alt) && lfs3_tag_isred(p[0].alt)) { // if we take the red or yellow alt we can just point // to the black alt // b @@ -3935,17 +3937,17 @@ trunk:; // 1 2 3 4 1 2 3 4 1 if (branch_ < branch) { if (jump > branch) { - LFS_SWAP(lfsr_tag_t, &p[0].alt, &alt); - LFS_SWAP(lfsr_rid_t, &p[0].weight, &weight); - LFS_SWAP(lfs_size_t, &p[0].jump, &jump); + LFS3_SWAP(lfs3_tag_t, &p[0].alt, &alt); + LFS3_SWAP(lfs3_rid_t, &p[0].weight, &weight); + LFS3_SWAP(lfs3_size_t, &p[0].jump, &jump); } - alt &= ~LFSR_TAG_R; + alt &= ~LFS3_TAG_R; - lfsr_tag_trim( + lfs3_tag_trim( p[0].alt, p[0].weight, &lower_rid, &upper_rid, &lower_tag, &upper_tag); - lfsr_rbyd_p_recolor(p); + lfs3_rbyd_p_recolor(p); // otherwise we need to point to the yellow alt and // prune later @@ -3959,16 +3961,16 @@ trunk:; // | | .-'| | | .----'| // 1 2 3 4 1 2 3 4 4 } else { - LFS_ASSERT(y_branch != 0); + LFS3_ASSERT(y_branch != 0); p[0].alt = alt; p[0].weight += weight; p[0].jump = y_branch; - lfsr_tag_trim( + lfs3_tag_trim( p[0].alt, p[0].weight, &lower_rid, &upper_rid, &lower_tag, &upper_tag); - lfsr_rbyd_p_recolor(p); + lfs3_rbyd_p_recolor(p); branch = branch_; continue; @@ -3976,20 +3978,20 @@ trunk:; } // red alt? we need to read the rest of the 2-3-4 node - if (lfsr_tag_isred(alt)) { + if (lfs3_tag_isred(alt)) { // undo flip temporarily if (branch_ < branch) { - lfsr_tag_flip2( + lfs3_tag_flip2( &alt, &weight, p[0].alt, p[0].weight, lower_rid, upper_rid); - LFS_SWAP(lfs_size_t, &jump, &branch_); + LFS3_SWAP(lfs3_size_t, &jump, &branch_); } // black alt? terminate 2-3-4 nodes } else { // trim alts from our current bounds - lfsr_tag_trim2( + lfs3_tag_trim2( alt, weight, p[0].alt, p[0].weight, &lower_rid, &upper_rid, @@ -3997,24 +3999,24 @@ trunk:; } // push alt onto our queue - err = lfsr_rbyd_p_push(lfs, rbyd, p, + err = lfs3_rbyd_p_push(lfs3, rbyd, p, alt, weight, jump); if (err) { return err; } // continue to next alt - LFS_ASSERT(branch_ != branch); + LFS3_ASSERT(branch_ != branch); branch = branch_; continue; // found end of tree? } else { // update the found tag - tag_ = lfsr_tag_key(alt); + tag_ = lfs3_tag_key(alt); // the last alt should always end up black - LFS_ASSERT(lfsr_tag_isblack(p[0].alt)); + LFS3_ASSERT(lfs3_tag_isblack(p[0].alt)); if (diverged) { // diverged lower trunk? move on to upper trunk @@ -4024,15 +4026,15 @@ trunk:; d_weight = upper_rid - lower_rid; // flush any pending alts - err = lfsr_rbyd_p_flush(lfs, rbyd, p, 3); + err = lfs3_rbyd_p_flush(lfs3, rbyd, p, 3); if (err) { return err; } // terminate diverged trunk with an unreachable tag - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR( - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) - | LFSR_TAG_NULL, + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR( + (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) + | LFS3_TAG_NULL, 0)); if (err) { return err; @@ -4041,8 +4043,8 @@ trunk:; // swap tag/rid and move on to upper trunk diverged = false; branch = trunk_; - LFS_SWAP(lfsr_tag_t, &a_tag, &b_tag); - LFS_SWAP(lfsr_srid_t, &a_rid, &b_rid); + LFS3_SWAP(lfs3_tag_t, &a_tag, &b_tag); + LFS3_SWAP(lfs3_srid_t, &a_rid, &b_rid); goto trunk; } else { @@ -4060,7 +4062,7 @@ trunk:; stem:; // split leaf nodes? // - // note we bias the weights here so that lfsr_rbyd_lookupnext + // note we bias the weights here so that lfs3_rbyd_lookupnext // always finds the next biggest tag // // note also if tag_ is null, we found a removed tag that we should just @@ -4072,22 +4074,22 @@ stem:; // - rm-bit set => never split, but emit alt-always tags, making our // tag effectively unreachable // - lfsr_tag_t alt = 0; - lfsr_rid_t weight = 0; + lfs3_tag_t alt = 0; + lfs3_rid_t weight = 0; if (tag_ - && (upper_rid-1 < rid-lfs_smax(-rattr.weight, 0) - || (upper_rid-1 == rid-lfs_smax(-rattr.weight, 0) - && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0) - || ((tag_ & lfsr_tag_mask(rattr.tag)) - < (rattr.tag & lfsr_tag_mask(rattr.tag))))))) { - if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) { + && (upper_rid-1 < rid-lfs3_smax(-rattr.weight, 0) + || (upper_rid-1 == rid-lfs3_smax(-rattr.weight, 0) + && ((!lfs3_tag_isgrow(rattr.tag) && rattr.weight > 0) + || ((tag_ & lfs3_tag_mask(rattr.tag)) + < (rattr.tag & lfs3_tag_mask(rattr.tag))))))) { + if (lfs3_tag_isrm(rattr.tag) || !lfs3_tag_key(rattr.tag)) { // if removed, make our tag unreachable - alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag); + alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, lower_tag); weight = upper_rid - lower_rid + rattr.weight; upper_rid -= weight; } else { // split less than - alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_LE, tag_); + alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_LE, tag_); weight = upper_rid - lower_rid; lower_rid += weight; } @@ -4095,35 +4097,35 @@ stem:; } else if (tag_ && (upper_rid-1 > rid || (upper_rid-1 == rid - && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0) - || ((tag_ & lfsr_tag_mask(rattr.tag)) - > (rattr.tag & lfsr_tag_mask(rattr.tag))))))) { - if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) { + && ((!lfs3_tag_isgrow(rattr.tag) && rattr.weight > 0) + || ((tag_ & lfs3_tag_mask(rattr.tag)) + > (rattr.tag & lfs3_tag_mask(rattr.tag))))))) { + if (lfs3_tag_isrm(rattr.tag) || !lfs3_tag_key(rattr.tag)) { // if removed, make our tag unreachable - alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag); + alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, lower_tag); weight = upper_rid - lower_rid + rattr.weight; upper_rid -= weight; } else { // split greater than - alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, rattr.tag); + alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, rattr.tag); weight = upper_rid - (rid+1); upper_rid -= weight; } } if (alt) { - err = lfsr_rbyd_p_push(lfs, rbyd, p, + err = lfs3_rbyd_p_push(lfs3, rbyd, p, alt, weight, branch); if (err) { return err; } // introduce a red edge - lfsr_rbyd_p_recolor(p); + lfs3_rbyd_p_recolor(p); } // flush any pending alts - err = lfsr_rbyd_p_flush(lfs, rbyd, p, 3); + err = lfs3_rbyd_p_flush(lfs3, rbyd, p, 3); if (err) { return err; } @@ -4133,13 +4135,13 @@ leaf:; // // note we always need a non-alt to terminate the trunk, otherwise we // can't find trunks during fetch - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_( + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR_( // mark as shrub if we are a shrub - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) + (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) // rm => null, otherwise strip off control bits - | ((lfsr_tag_isrm(rattr.tag)) - ? LFSR_TAG_NULL - : lfsr_tag_key(rattr.tag)), + | ((lfs3_tag_isrm(rattr.tag)) + ? LFS3_TAG_NULL + : lfs3_tag_key(rattr.tag)), upper_rid - lower_rid + rattr.weight, rattr.u, rattr.count)); if (err) { @@ -4147,12 +4149,12 @@ leaf:; } // update the trunk and weight - rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | trunk_; + rbyd->trunk = (rbyd->trunk & LFS3_RBYD_ISSHRUB) | trunk_; rbyd->weight += rattr.weight; return 0; } -static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd, +static int lfs3_rbyd_appendcksum_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, uint32_t cksum) { // align to the next prog unit // @@ -4178,55 +4180,55 @@ static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // | cksum | cksum cksum: 1 le32 4 bytes // '---+---+---+---' total: <=11 bytes // - lfs_size_t off_ = lfs_alignup( - lfsr_rbyd_eoff(rbyd) + 2+1+1+4+4 + 2+1+4+4, - lfs->cfg->prog_size); + lfs3_size_t off_ = lfs3_alignup( + lfs3_rbyd_eoff(rbyd) + 2+1+1+4+4 + 2+1+4+4, + lfs3->cfg->prog_size); // space for ecksum? bool perturb = false; - if (off_ < lfs->cfg->block_size) { + if (off_ < lfs3->cfg->block_size) { // read the leading byte in case we need to perturb the next commit, // this should hopefully stay in our cache uint8_t e = 0; - int err = lfsr_bd_read(lfs, - rbyd->blocks[0], off_, lfs->cfg->prog_size, + int err = lfs3_bd_read(lfs3, + rbyd->blocks[0], off_, lfs3->cfg->prog_size, &e, 1); - if (err && err != LFS_ERR_CORRUPT) { + if (err && err != LFS3_ERR_CORRUPT) { return err; } // we don't want the next commit to appear as valid, so we // intentionally perturb the commit if this happens, this is // roughly equivalent to inverting all tags' valid bits - perturb = ((e >> 7) == lfs_parity(cksum)); + perturb = ((e >> 7) == lfs3_parity(cksum)); // calculate the erased-state checksum uint32_t ecksum = 0; - err = lfsr_bd_cksum(lfs, - rbyd->blocks[0], off_, lfs->cfg->prog_size, - lfs->cfg->prog_size, + err = lfs3_bd_cksum(lfs3, + rbyd->blocks[0], off_, lfs3->cfg->prog_size, + lfs3->cfg->prog_size, &ecksum); - if (err && err != LFS_ERR_CORRUPT) { + if (err && err != LFS3_ERR_CORRUPT) { return err; } - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_ECKSUM( - LFSR_TAG_ECKSUM, 0, - (&(lfsr_ecksum_t){ - .cksize=lfs->cfg->prog_size, + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR_ECKSUM( + LFS3_TAG_ECKSUM, 0, + (&(lfs3_ecksum_t){ + .cksize=lfs3->cfg->prog_size, .cksum=ecksum}))); if (err) { return err; } // at least space for a cksum? - } else if (lfsr_rbyd_eoff(rbyd) + 2+1+4+4 <= lfs->cfg->block_size) { + } else if (lfs3_rbyd_eoff(rbyd) + 2+1+4+4 <= lfs3->cfg->block_size) { // note this implicitly marks the rbyd as unerased - off_ = lfs->cfg->block_size; + off_ = lfs3->cfg->block_size; // not even space for a cksum? we can't finish the commit } else { - return LFS_ERR_RANGE; + return LFS3_ERR_RANGE; } // build the end-of-commit checksum tag @@ -4235,12 +4237,12 @@ static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // depends leb-encoding depends on... to get around this catch-22 we // just always write a fully-expanded leb128 encoding // - bool v = lfs_parity(rbyd->cksum) ^ lfsr_rbyd_isperturb(rbyd); + bool v = lfs3_parity(rbyd->cksum) ^ lfs3_rbyd_isperturb(rbyd); uint8_t cksum_buf[2+1+4+4]; - cksum_buf[0] = (uint8_t)(LFSR_TAG_CKSUM >> 8) + cksum_buf[0] = (uint8_t)(LFS3_TAG_CKSUM >> 8) // set the valid bit to the cksum parity | ((uint8_t)v << 7); - cksum_buf[1] = (uint8_t)(LFSR_TAG_CKSUM >> 0) + cksum_buf[1] = (uint8_t)(LFS3_TAG_CKSUM >> 0) // set the perturb bit so next commit is invalid | ((uint8_t)perturb << 2) // include the lower 2 bits of the block address to help @@ -4248,7 +4250,7 @@ static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd, | (rbyd->blocks[0] & 0x3); cksum_buf[2] = 0; - lfs_size_t padding = off_ - (lfsr_rbyd_eoff(rbyd) + 2+1+4); + lfs3_size_t padding = off_ - (lfs3_rbyd_eoff(rbyd) + 2+1+4); cksum_buf[3] = 0x80 | (0x7f & (padding >> 0)); cksum_buf[4] = 0x80 | (0x7f & (padding >> 7)); cksum_buf[5] = 0x80 | (0x7f & (padding >> 14)); @@ -4257,17 +4259,17 @@ static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd, // exclude the valid bit uint32_t cksum_ = rbyd->cksum ^ ((uint32_t)v << 7); // calculate the commit checksum - cksum_ = lfs_crc32c(cksum_, cksum_buf, 2+1+4); + cksum_ = lfs3_crc32c(cksum_, cksum_buf, 2+1+4); // and perturb, perturbing the commit checksum avoids a perturb hole // after the last valid bit // // note the odd-parity zero preserves our position in the crc32c // ring while only changing the parity - cksum_ ^= (lfsr_rbyd_isperturb(rbyd)) ? LFS_CRC32C_ODDZERO : 0; - lfs_tole32(cksum_, &cksum_buf[2+1+4]); + cksum_ ^= (lfs3_rbyd_isperturb(rbyd)) ? LFS3_CRC32C_ODDZERO : 0; + lfs3_tole32(cksum_, &cksum_buf[2+1+4]); // prog, when this lands on disk commit is committed - int err = lfsr_bd_prog(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), + int err = lfs3_bd_prog(lfs3, rbyd->blocks[0], lfs3_rbyd_eoff(rbyd), cksum_buf, 2+1+4+4, NULL, false); if (err) { @@ -4275,50 +4277,50 @@ static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // flush any pending progs - err = lfsr_bd_flush(lfs, NULL, false); + err = lfs3_bd_flush(lfs3, NULL, false); if (err) { return err; } // update the eoff and perturb rbyd->eoff - = ((lfs_size_t)perturb << (8*sizeof(lfs_size_t)-1)) + = ((lfs3_size_t)perturb << (8*sizeof(lfs3_size_t)-1)) | off_; // revert to canonical checksum rbyd->cksum = cksum; - #ifdef LFS_DBGRBYDCOMMITS - LFS_DEBUG("Committed rbyd 0x%"PRIx32".%"PRIx32" w%"PRId32", " + #ifdef LFS3_DBGRBYDCOMMITS + LFS3_DEBUG("Committed rbyd 0x%"PRIx32".%"PRIx32" w%"PRId32", " "eoff %"PRId32", cksum %"PRIx32, - rbyd->blocks[0], lfsr_rbyd_trunk(rbyd), + rbyd->blocks[0], lfs3_rbyd_trunk(rbyd), rbyd->weight, - (lfsr_rbyd_eoff(rbyd) >= lfs->cfg->block_size) + (lfs3_rbyd_eoff(rbyd) >= lfs3->cfg->block_size) ? -1 - : (lfs_ssize_t)lfsr_rbyd_eoff(rbyd), + : (lfs3_ssize_t)lfs3_rbyd_eoff(rbyd), rbyd->cksum); #endif return 0; } -static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { +static int lfs3_rbyd_appendcksum(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { // begin appending - int err = lfsr_rbyd_appendinit(lfs, rbyd); + int err = lfs3_rbyd_appendinit(lfs3, rbyd); if (err) { return err; } // append checksum stuff - return lfsr_rbyd_appendcksum_(lfs, rbyd, rbyd->cksum); + return lfs3_rbyd_appendcksum_(lfs3, rbyd, rbyd->cksum); } -static int lfsr_rbyd_appendrattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_srid_t rid, lfsr_srid_t start_rid, lfsr_srid_t end_rid, - const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { +static int lfs3_rbyd_appendrattrs(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, lfs3_srid_t start_rid, lfs3_srid_t end_rid, + const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // append each tag to the tree - for (lfs_size_t i = 0; i < rattr_count; i++) { + for (lfs3_size_t i = 0; i < rattr_count; i++) { // treat inserts after the first tag as though they are splits, // sequential inserts don't really make sense otherwise - if (i > 0 && lfsr_rattr_isinsert(rattrs[i])) { + if (i > 0 && lfs3_rattr_isinsert(rattrs[i])) { rid += 1; } @@ -4327,9 +4329,9 @@ static int lfsr_rbyd_appendrattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, // note the use of rid+1 and unsigned comparison here to // treat end_rid=-1 as "unbounded" in such a way that rid=-1 // is still included - && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) { - int err = lfsr_rbyd_appendrattr(lfs, rbyd, - rid - lfs_smax(start_rid, 0), + && (lfs3_size_t)(rid + 1) <= (lfs3_size_t)end_rid) { + int err = lfs3_rbyd_appendrattr(lfs3, rbyd, + rid - lfs3_smax(start_rid, 0), rattrs[i]); if (err) { return err; @@ -4346,23 +4348,23 @@ static int lfsr_rbyd_appendrattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // adjust rid - rid = lfsr_rattr_nextrid(rattrs[i], rid); + rid = lfs3_rattr_nextrid(rattrs[i], rid); } return 0; } -static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_srid_t rid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { +static int lfs3_rbyd_commit(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_srid_t rid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // append each tag to the tree - int err = lfsr_rbyd_appendrattrs(lfs, rbyd, rid, -1, -1, + int err = lfs3_rbyd_appendrattrs(lfs3, rbyd, rid, -1, -1, rattrs, rattr_count); if (err) { return err; } // append a cksum, finalizing the commit - err = lfsr_rbyd_appendcksum(lfs, rbyd); + err = lfs3_rbyd_appendcksum(lfs3, rbyd); if (err) { return err; } @@ -4378,48 +4380,48 @@ static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, // This also returns a good split_rid in case the rbyd needs to be split. // // TODO do we need to include commit overhead here? -static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, - lfsr_srid_t start_rid, lfsr_srid_t end_rid, - lfsr_srid_t *split_rid_) { +static lfs3_ssize_t lfs3_rbyd_estimate(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + lfs3_srid_t start_rid, lfs3_srid_t end_rid, + lfs3_srid_t *split_rid_) { // calculate dsize by starting from the outside ids and working inwards, // this naturally gives us a split rid // - // TODO adopt this a/b naming scheme in lfsr_rbyd_appendrattr? - lfsr_srid_t a_rid = start_rid; - lfsr_srid_t b_rid = lfs_min(rbyd->weight, end_rid); - lfs_size_t a_dsize = 0; - lfs_size_t b_dsize = 0; - lfs_size_t rbyd_dsize = 0; + // TODO adopt this a/b naming scheme in lfs3_rbyd_appendrattr? + lfs3_srid_t a_rid = start_rid; + lfs3_srid_t b_rid = lfs3_min(rbyd->weight, end_rid); + lfs3_size_t a_dsize = 0; + lfs3_size_t b_dsize = 0; + lfs3_size_t rbyd_dsize = 0; while (a_rid != b_rid) { if (a_dsize > b_dsize // bias so lower dsize >= upper dsize || (a_dsize == b_dsize && a_rid > b_rid)) { - LFS_SWAP(lfsr_srid_t, &a_rid, &b_rid); - LFS_SWAP(lfs_size_t, &a_dsize, &b_dsize); + LFS3_SWAP(lfs3_srid_t, &a_rid, &b_rid); + LFS3_SWAP(lfs3_size_t, &a_dsize, &b_dsize); } if (a_rid > b_rid) { a_rid -= 1; } - lfsr_tag_t tag = 0; - lfsr_rid_t weight = 0; - lfs_size_t dsize_ = 0; + lfs3_tag_t tag = 0; + lfs3_rid_t weight = 0; + lfs3_size_t dsize_ = 0; while (true) { - lfsr_srid_t rid_; - lfsr_rid_t weight_; - lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, rbyd, + lfs3_srid_t rid_; + lfs3_rid_t weight_; + lfs3_data_t data; + int err = lfs3_rbyd_lookupnext(lfs3, rbyd, a_rid, tag+1, &rid_, &tag, &weight_, &data); if (err < 0) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; } - if (rid_ > a_rid+lfs_smax(weight_-1, 0)) { + if (rid_ > a_rid+lfs3_smax(weight_-1, 0)) { break; } @@ -4428,7 +4430,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, weight += weight_; // include the cost of this tag - dsize_ += lfs->rattr_estimate + lfsr_data_size(data); + dsize_ += lfs3->rattr_estimate + lfs3_data_size(data); } if (a_rid == -1) { @@ -4440,7 +4442,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, if (a_rid < b_rid) { a_rid += 1; } else { - a_rid -= lfs_smax(weight-1, 0); + a_rid -= lfs3_smax(weight-1, 0); } } @@ -4455,17 +4457,17 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // be appended in order! // // also note rattr.weight here is total weight not delta weight -static int lfsr_rbyd_appendcompactrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_rattr_t rattr) { +static int lfs3_rbyd_appendcompactrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_rattr_t rattr) { // begin appending - int err = lfsr_rbyd_appendinit(lfs, rbyd); + int err = lfs3_rbyd_appendinit(lfs3, rbyd); if (err) { return err; } // write the tag - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_( - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | rattr.tag, + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR_( + (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) | rattr.tag, rattr.weight, rattr.u, rattr.count)); if (err) { @@ -4475,19 +4477,19 @@ static int lfsr_rbyd_appendcompactrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, return 0; } -static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, - const lfsr_rbyd_t *rbyd, lfsr_srid_t start_rid, lfsr_srid_t end_rid) { +static int lfs3_rbyd_appendcompactrbyd(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, + const lfs3_rbyd_t *rbyd, lfs3_srid_t start_rid, lfs3_srid_t end_rid) { // copy over tags in the rbyd in order - lfsr_srid_t rid = start_rid; - lfsr_tag_t tag = 0; + lfs3_srid_t rid = start_rid; + lfs3_tag_t tag = 0; while (true) { - lfsr_rid_t weight; - lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, rbyd, + lfs3_rid_t weight; + lfs3_data_t data; + int err = lfs3_rbyd_lookupnext(lfs3, rbyd, rid, tag+1, &rid, &tag, &weight, &data); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -4495,12 +4497,12 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, // end of range? note the use of rid+1 and unsigned comparison here to // treat end_rid=-1 as "unbounded" in such a way that rid=-1 is still // included - if ((lfs_size_t)(rid + 1) > (lfs_size_t)end_rid) { + if ((lfs3_size_t)(rid + 1) > (lfs3_size_t)end_rid) { break; } // write the tag - err = lfsr_rbyd_appendcompactrattr(lfs, rbyd_, LFSR_RATTR_DATA( + err = lfs3_rbyd_appendcompactrattr(lfs3, rbyd_, LFS3_RATTR_DATA( tag, weight, &data)); if (err) { return err; @@ -4510,53 +4512,53 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, return 0; } -static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfs_size_t off) { +static int lfs3_rbyd_appendcompaction(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + lfs3_size_t off) { // begin appending - int err = lfsr_rbyd_appendinit(lfs, rbyd); + int err = lfs3_rbyd_appendinit(lfs3, rbyd); if (err) { return err; } // clamp offset to be after the revision count - off = lfs_max(off, sizeof(uint32_t)); + off = lfs3_max(off, sizeof(uint32_t)); // empty rbyd? write a null tag so our trunk can still point to something - if (lfsr_rbyd_eoff(rbyd) == off) { - err = lfsr_rbyd_appendtag(lfs, rbyd, + if (lfs3_rbyd_eoff(rbyd) == off) { + err = lfs3_rbyd_appendtag(lfs3, rbyd, // mark as shrub if we are a shrub - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) - | LFSR_TAG_NULL, + (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) + | LFS3_TAG_NULL, 0, 0); if (err) { return err; } - rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | off; + rbyd->trunk = (rbyd->trunk & LFS3_RBYD_ISSHRUB) | off; rbyd->weight = 0; return 0; } // connect every other trunk together, building layers of a perfectly // balanced binary tree upwards until we have a single trunk - lfs_size_t layer = off; - lfsr_rid_t weight = 0; - lfsr_tag_t tag_ = 0; + lfs3_size_t layer = off; + lfs3_rid_t weight = 0; + lfs3_tag_t tag_ = 0; while (true) { - lfs_size_t layer_ = lfsr_rbyd_eoff(rbyd); + lfs3_size_t layer_ = lfs3_rbyd_eoff(rbyd); off = layer; while (off < layer_) { // connect two trunks together with a new binary trunk for (int i = 0; i < 2 && off < layer_; i++) { - lfs_size_t trunk = off; - lfsr_tag_t tag = 0; + lfs3_size_t trunk = off; + lfs3_tag_t tag = 0; weight = 0; while (true) { - lfsr_tag_t tag__; - lfsr_rid_t weight__; - lfs_size_t size__; - lfs_ssize_t d = lfsr_bd_readtag(lfs, + lfs3_tag_t tag__; + lfs3_rid_t weight__; + lfs3_size_t size__; + lfs3_ssize_t d = lfs3_bd_readtag(lfs3, rbyd->blocks[0], off, layer_ - off, &tag__, &weight__, &size__, NULL); @@ -4566,15 +4568,15 @@ static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, off += d; // skip any data - if (!lfsr_tag_isalt(tag__)) { + if (!lfs3_tag_isalt(tag__)) { off += size__; } // ignore shrub trunks, unless we are actually compacting // a shrub tree - if (!lfsr_tag_isalt(tag__) - && lfsr_tag_isshrub(tag__) - && !lfsr_rbyd_isshrub(rbyd)) { + if (!lfs3_tag_isalt(tag__) + && lfs3_tag_isshrub(tag__) + && !lfs3_rbyd_isshrub(rbyd)) { trunk = off; weight = 0; continue; @@ -4587,12 +4589,12 @@ static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, // Because of how we construct each layer, the last // non-null tag is the largest tag in that part of // the tree - if (tag__ & ~LFSR_TAG_SHRUB) { + if (tag__ & ~LFS3_TAG_SHRUB) { tag = tag__; } // did we hit a tag that terminates our trunk? - if (!lfsr_tag_isalt(tag__)) { + if (!lfs3_tag_isalt(tag__)) { break; } } @@ -4608,18 +4610,18 @@ static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, // so we know the largest tag when building the next // layer, but for that last tag we need an altgt so // future appends maintain the balance of the tree - err = lfsr_rbyd_appendtag(lfs, rbyd, + err = lfs3_rbyd_appendtag(lfs3, rbyd, (off < layer_) - ? LFSR_TAG_ALT( - (i == 0) ? LFSR_TAG_R : LFSR_TAG_B, - LFSR_TAG_LE, + ? LFS3_TAG_ALT( + (i == 0) ? LFS3_TAG_R : LFS3_TAG_B, + LFS3_TAG_LE, tag) - : LFSR_TAG_ALT( - LFSR_TAG_B, - LFSR_TAG_GT, + : LFS3_TAG_ALT( + LFS3_TAG_B, + LFS3_TAG_GT, tag_), weight, - lfsr_rbyd_eoff(rbyd) - trunk); + lfs3_rbyd_eoff(rbyd) - trunk); if (err) { return err; } @@ -4629,10 +4631,10 @@ static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // terminate with a null tag - err = lfsr_rbyd_appendtag(lfs, rbyd, + err = lfs3_rbyd_appendtag(lfs3, rbyd, // mark as shrub if we are a shrub - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) - | LFSR_TAG_NULL, + (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) + | LFS3_TAG_NULL, 0, 0); if (err) { @@ -4646,23 +4648,23 @@ static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, done:; // done! just need to update our trunk. Note we could have no trunks // after compaction. Leave this to upper layers to take care of this. - rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | layer; + rbyd->trunk = (rbyd->trunk & LFS3_RBYD_ISSHRUB) | layer; rbyd->weight = weight; return 0; } -static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, - const lfsr_rbyd_t *rbyd, lfsr_srid_t start_rid, lfsr_srid_t end_rid) { +static int lfs3_rbyd_compact(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, + const lfs3_rbyd_t *rbyd, lfs3_srid_t start_rid, lfs3_srid_t end_rid) { // append rbyd - int err = lfsr_rbyd_appendcompactrbyd(lfs, rbyd_, + int err = lfs3_rbyd_appendcompactrbyd(lfs3, rbyd_, rbyd, start_rid, end_rid); if (err) { return err; } // compact - err = lfsr_rbyd_appendcompaction(lfs, rbyd_, 0); + err = lfs3_rbyd_appendcompaction(lfs3, rbyd_, 0); if (err) { return err; } @@ -4671,21 +4673,21 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } // append a secondary "shrub" tree -static int lfsr_rbyd_appendshrub(lfs_t *lfs, lfsr_rbyd_t *rbyd, - const lfsr_shrub_t *shrub) { +static int lfs3_rbyd_appendshrub(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, + const lfs3_shrub_t *shrub) { // keep track of the start of the new tree - lfs_size_t off = lfsr_rbyd_eoff(rbyd); + lfs3_size_t off = lfs3_rbyd_eoff(rbyd); // mark as shrub - rbyd->trunk |= LFSR_RBYD_ISSHRUB; + rbyd->trunk |= LFS3_RBYD_ISSHRUB; // compact our shrub - int err = lfsr_rbyd_appendcompactrbyd(lfs, rbyd, + int err = lfs3_rbyd_appendcompactrbyd(lfs3, rbyd, shrub, -1, -1); if (err) { return err; } - err = lfsr_rbyd_appendcompaction(lfs, rbyd, off); + err = lfs3_rbyd_appendcompaction(lfs3, rbyd, off); if (err) { return err; } @@ -4700,48 +4702,48 @@ static int lfsr_rbyd_appendshrub(lfs_t *lfs, lfsr_rbyd_t *rbyd, // binary search an rbyd for a name, leaving the rid_/tag_/weight_/data_ // with the best matching name if not found -static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, - lfsr_did_t did, const char *name, lfs_size_t name_len, - lfsr_srid_t *rid_, - lfsr_tag_t *tag_, lfsr_rid_t *weight_, lfsr_data_t *data_) { +static lfs3_scmp_t lfs3_rbyd_namelookup(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, + lfs3_did_t did, const char *name, lfs3_size_t name_len, + lfs3_srid_t *rid_, + lfs3_tag_t *tag_, lfs3_rid_t *weight_, lfs3_data_t *data_) { // empty rbyd? leave it up to upper layers to handle this if (rbyd->weight == 0) { - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // binary search for our name - lfsr_srid_t lower_rid = 0; - lfsr_srid_t upper_rid = rbyd->weight; - lfs_scmp_t cmp; + lfs3_srid_t lower_rid = 0; + lfs3_srid_t upper_rid = rbyd->weight; + lfs3_scmp_t cmp; while (lower_rid < upper_rid) { - lfsr_tag_t tag__; - lfsr_srid_t rid__; - lfsr_rid_t weight__; - lfsr_data_t data__; - int err = lfsr_rbyd_lookupnext(lfs, rbyd, + lfs3_tag_t tag__; + lfs3_srid_t rid__; + lfs3_rid_t weight__; + lfs3_data_t data__; + int err = lfs3_rbyd_lookupnext(lfs3, rbyd, // lookup ~middle rid, note we may end up in the middle // of a weighted rid with this lower_rid + (upper_rid-1-lower_rid)/2, 0, &rid__, &tag__, &weight__, &data__); if (err < 0) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // if we have no name, treat this rid as always lt - if (lfsr_tag_suptype(tag__) != LFSR_TAG_NAME) { - cmp = LFS_CMP_LT; + if (lfs3_tag_suptype(tag__) != LFS3_TAG_NAME) { + cmp = LFS3_CMP_LT; // compare names } else { - cmp = lfsr_data_namecmp(lfs, data__, did, name, name_len); + cmp = lfs3_data_namecmp(lfs3, data__, did, name, name_len); if (cmp < 0) { return cmp; } } // bisect search space - if (cmp > LFS_CMP_EQ) { + if (cmp > LFS3_CMP_EQ) { upper_rid = rid__ - (weight__-1); // only keep track of best-match rids > our target if we haven't @@ -4761,7 +4763,7 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } } - } else if (cmp < LFS_CMP_EQ) { + } else if (cmp < LFS3_CMP_EQ) { lower_rid = rid__ + 1; // keep track of best-matching rid < our target @@ -4792,14 +4794,14 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, if (data_) { *data_ = data__; } - return LFS_CMP_EQ; + return LFS3_CMP_EQ; } } // no match, return if found name was lt/gt expect // // this will always be lt unless all rids are gt - return (lower_rid == 0) ? LFS_CMP_GT : LFS_CMP_LT; + return (lower_rid == 0) ? LFS3_CMP_GT : LFS3_CMP_LT; } @@ -4808,70 +4810,70 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, /// B-tree operations /// // create an empty btree -static void lfsr_btree_init(lfsr_btree_t *btree) { +static void lfs3_btree_init(lfs3_btree_t *btree) { btree->weight = 0; btree->blocks[0] = -1; btree->trunk = 0; } // convenience operations -static inline void lfsr_btree_claim(lfsr_btree_t *btree) { - lfsr_rbyd_claim(btree); +static inline void lfs3_btree_claim(lfs3_btree_t *btree) { + lfs3_rbyd_claim(btree); } -static inline int lfsr_btree_cmp( - const lfsr_btree_t *a, - const lfsr_btree_t *b) { - return lfsr_rbyd_cmp(a, b); +static inline int lfs3_btree_cmp( + const lfs3_btree_t *a, + const lfs3_btree_t *b) { + return lfs3_rbyd_cmp(a, b); } // branch on-disk encoding -static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch, - uint8_t buffer[static LFSR_BRANCH_DSIZE]) { +static lfs3_data_t lfs3_data_frombranch(const lfs3_rbyd_t *branch, + uint8_t buffer[static LFS3_BRANCH_DSIZE]) { // block should not exceed 31-bits - LFS_ASSERT(branch->blocks[0] <= 0x7fffffff); + LFS3_ASSERT(branch->blocks[0] <= 0x7fffffff); // trunk should not exceed 28-bits - LFS_ASSERT(lfsr_rbyd_trunk(branch) <= 0x0fffffff); - lfs_ssize_t d = 0; + LFS3_ASSERT(lfs3_rbyd_trunk(branch) <= 0x0fffffff); + lfs3_ssize_t d = 0; - lfs_ssize_t d_ = lfs_toleb128(branch->blocks[0], &buffer[d], 5); + lfs3_ssize_t d_ = lfs3_toleb128(branch->blocks[0], &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - d_ = lfs_toleb128(lfsr_rbyd_trunk(branch), &buffer[d], 4); + d_ = lfs3_toleb128(lfs3_rbyd_trunk(branch), &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - lfs_tole32(branch->cksum, &buffer[d]); + lfs3_tole32(branch->cksum, &buffer[d]); d += 4; - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readbranch(lfs_t *lfs, - lfsr_data_t *data, lfsr_bid_t weight, - lfsr_rbyd_t *branch) { +static int lfs3_data_readbranch(lfs3_t *lfs3, + lfs3_data_t *data, lfs3_bid_t weight, + lfs3_rbyd_t *branch) { // setting off to 0 here will trigger asserts if we try to append // without fetching first branch->eoff = 0; branch->weight = weight; - int err = lfsr_data_readleb128(lfs, data, &branch->blocks[0]); + int err = lfs3_data_readleb128(lfs3, data, &branch->blocks[0]); if (err) { return err; } - err = lfsr_data_readlleb128(lfs, data, &branch->trunk); + err = lfs3_data_readlleb128(lfs3, data, &branch->trunk); if (err) { return err; } - err = lfsr_data_readle32(lfs, data, &branch->cksum); + err = lfs3_data_readle32(lfs3, data, &branch->cksum); if (err) { return err; } @@ -4879,48 +4881,48 @@ static int lfsr_data_readbranch(lfs_t *lfs, return 0; } -// needed in lfsr_branch_fetch -#ifdef LFS_CKFETCHES -static inline bool lfsr_m_isckfetches(uint32_t flags); +// needed in lfs3_branch_fetch +#ifdef LFS3_CKFETCHES +static inline bool lfs3_m_isckfetches(uint32_t flags); #endif -static int lfsr_branch_fetch(lfs_t *lfs, lfsr_rbyd_t *branch, - lfs_block_t block, lfs_size_t trunk, lfsr_bid_t weight, +static int lfs3_branch_fetch(lfs3_t *lfs3, lfs3_rbyd_t *branch, + lfs3_block_t block, lfs3_size_t trunk, lfs3_bid_t weight, uint32_t cksum) { - (void)lfs; + (void)lfs3; branch->blocks[0] = block; branch->trunk = trunk; branch->weight = weight; branch->eoff = 0; branch->cksum = cksum; - #ifdef LFS_CKFETCHES + #ifdef LFS3_CKFETCHES // checking fetches? - if (lfsr_m_isckfetches(lfs->flags)) { - int err = lfsr_rbyd_fetchck(lfs, branch, - branch->blocks[0], lfsr_rbyd_trunk(branch), + if (lfs3_m_isckfetches(lfs3->flags)) { + int err = lfs3_rbyd_fetchck(lfs3, branch, + branch->blocks[0], lfs3_rbyd_trunk(branch), branch->cksum); if (err) { return err; } - LFS_ASSERT(branch->weight == weight); + LFS3_ASSERT(branch->weight == weight); } #endif return 0; } -static int lfsr_data_fetchbranch(lfs_t *lfs, - lfsr_data_t *data, lfsr_bid_t weight, - lfsr_rbyd_t *branch) { +static int lfs3_data_fetchbranch(lfs3_t *lfs3, + lfs3_data_t *data, lfs3_bid_t weight, + lfs3_rbyd_t *branch) { // decode branch and fetch - int err = lfsr_data_readbranch(lfs, data, weight, + int err = lfs3_data_readbranch(lfs3, data, weight, branch); if (err) { return err; } - return lfsr_branch_fetch(lfs, branch, + return lfs3_branch_fetch(lfs3, branch, branch->blocks[0], branch->trunk, branch->weight, branch->cksum); } @@ -4930,33 +4932,33 @@ static int lfsr_data_fetchbranch(lfs_t *lfs, // // this is the same as the branch on-disk econding, but prefixed with the // btree's weight -static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree, - uint8_t buffer[static LFSR_BTREE_DSIZE]) { +static lfs3_data_t lfs3_data_frombtree(const lfs3_btree_t *btree, + uint8_t buffer[static LFS3_BTREE_DSIZE]) { // weight should not exceed 31-bits - LFS_ASSERT(btree->weight <= 0x7fffffff); - lfs_ssize_t d = 0; + LFS3_ASSERT(btree->weight <= 0x7fffffff); + lfs3_ssize_t d = 0; - lfs_ssize_t d_ = lfs_toleb128(btree->weight, &buffer[d], 5); + lfs3_ssize_t d_ = lfs3_toleb128(btree->weight, &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - lfsr_data_t data = lfsr_data_frombranch(btree, &buffer[d]); - d += lfsr_data_size(data); + lfs3_data_t data = lfs3_data_frombranch(btree, &buffer[d]); + d += lfs3_data_size(data); - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readbtree(lfs_t *lfs, lfsr_data_t *data, - lfsr_btree_t *btree) { - lfsr_bid_t weight; - int err = lfsr_data_readleb128(lfs, data, &weight); +static int lfs3_data_readbtree(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_btree_t *btree) { + lfs3_bid_t weight; + int err = lfs3_data_readleb128(lfs3, data, &weight); if (err) { return err; } - err = lfsr_data_readbranch(lfs, data, weight, btree); + err = lfs3_data_readbranch(lfs3, data, weight, btree); if (err) { return err; } @@ -4967,80 +4969,80 @@ static int lfsr_data_readbtree(lfs_t *lfs, lfsr_data_t *data, // core btree operations -static int lfsr_btree_fetch(lfs_t *lfs, lfsr_btree_t *btree, - lfs_block_t block, lfs_size_t trunk, lfsr_bid_t weight, +static int lfs3_btree_fetch(lfs3_t *lfs3, lfs3_btree_t *btree, + lfs3_block_t block, lfs3_size_t trunk, lfs3_bid_t weight, uint32_t cksum) { // btree/branch fetch really are the same once we know the weight - int err = lfsr_branch_fetch(lfs, btree, + int err = lfs3_branch_fetch(lfs3, btree, block, trunk, weight, cksum); if (err) { return err; } - #ifdef LFS_DBGBTREEFETCHES - LFS_DEBUG("Fetched btree 0x%"PRIx32".%"PRIx32" w%"PRId32", " + #ifdef LFS3_DBGBTREEFETCHES + LFS3_DEBUG("Fetched btree 0x%"PRIx32".%"PRIx32" w%"PRId32", " "cksum %"PRIx32, - btree->blocks[0], lfsr_rbyd_trunk(btree), + btree->blocks[0], lfs3_rbyd_trunk(btree), btree->weight, btree->cksum); #endif return 0; } -static int lfsr_data_fetchbtree(lfs_t *lfs, lfsr_data_t *data, - lfsr_btree_t *btree) { +static int lfs3_data_fetchbtree(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_btree_t *btree) { // decode btree and fetch - int err = lfsr_data_readbtree(lfs, data, + int err = lfs3_data_readbtree(lfs3, data, btree); if (err) { return err; } - return lfsr_btree_fetch(lfs, btree, + return lfs3_btree_fetch(lfs3, btree, btree->blocks[0], btree->trunk, btree->weight, btree->cksum); } // 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_) { +static int lfs3_btree_lookupleaf(lfs3_t *lfs3, const lfs3_btree_t *btree, + lfs3_bid_t bid, + lfs3_bid_t *bid_, lfs3_rbyd_t *rbyd_, lfs3_srid_t *rid_, + lfs3_tag_t *tag_, lfs3_bid_t *weight_, lfs3_data_t *data_) { // descend down the btree looking for our bid *rbyd_ = *btree; - lfsr_srid_t rid = bid; + lfs3_srid_t rid = bid; while (true) { // each branch is a pair of optional name + on-disk structure // lookup our bid in the rbyd - lfsr_srid_t rid__; - lfsr_tag_t tag__; - lfsr_rid_t weight__; - lfsr_data_t data__; - int err = lfsr_rbyd_lookupnext(lfs, rbyd_, rid, 0, + lfs3_srid_t rid__; + lfs3_tag_t tag__; + lfs3_rid_t weight__; + lfs3_data_t data__; + int err = lfs3_rbyd_lookupnext(lfs3, rbyd_, rid, 0, &rid__, &tag__, &weight__, &data__); if (err) { return err; } // if we found a bname, lookup the branch - if (tag__ == LFSR_TAG_BNAME) { - err = lfsr_rbyd_lookup(lfs, rbyd_, rid__, LFSR_TAG_BRANCH, + if (tag__ == LFS3_TAG_BNAME) { + err = lfs3_rbyd_lookup(lfs3, rbyd_, rid__, LFS3_TAG_BRANCH, &tag__, &data__); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } // found another branch - if (tag__ == LFSR_TAG_BRANCH) { + if (tag__ == LFS3_TAG_BRANCH) { // adjust rid with subtree's weight rid -= (rid__ - (weight__-1)); // fetch the next branch - err = lfsr_data_fetchbranch(lfs, &data__, weight__, + err = lfs3_data_fetchbranch(lfs3, &data__, weight__, rbyd_); if (err) { return err; @@ -5071,26 +5073,26 @@ static int lfsr_btree_lookupleaf(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_) { - lfsr_rbyd_t rbyd; - return lfsr_btree_lookupleaf(lfs, btree, bid, +static int lfs3_btree_lookupnext(lfs3_t *lfs3, const lfs3_btree_t *btree, + lfs3_bid_t bid, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bid_t *weight_, + lfs3_data_t *data_) { + lfs3_rbyd_t rbyd; + return lfs3_btree_lookupleaf(lfs3, btree, bid, bid_, &rbyd, NULL, tag_, weight_, data_); } -// lfsr_btree_lookup assumes a known bid, matching lfsr_rbyd_lookup's +// lfs3_btree_lookup assumes a known bid, matching lfs3_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_tag_t *tag_, lfsr_data_t *data_) { +// lfs3_btree_lookupnext, or lfs3_btree_lookupleaf + lfs3_rbyd_lookup +static int lfs3_btree_lookup(lfs3_t *lfs3, const lfs3_btree_t *btree, + lfs3_bid_t bid, lfs3_tag_t tag, + lfs3_tag_t *tag_, lfs3_data_t *data_) { // lookup rbyd in btree - lfsr_bid_t bid__; - lfsr_rbyd_t rbyd__; - lfsr_srid_t rid__; - int err = lfsr_btree_lookupleaf(lfs, btree, bid, + lfs3_bid_t bid__; + lfs3_rbyd_t rbyd__; + lfs3_srid_t rid__; + int err = lfs3_btree_lookupleaf(lfs3, btree, bid, &bid__, &rbyd__, &rid__, NULL, NULL, NULL); if (err) { return err; @@ -5099,65 +5101,65 @@ static int lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree, // lookup finds the next-smallest bid, all we need to do is fail if it // picks up the wrong bid if (bid__ != bid) { - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // lookup tag in rbyd - return lfsr_rbyd_lookup(lfs, &rbyd__, rid__, tag, + return lfs3_rbyd_lookup(lfs3, &rbyd__, rid__, tag, tag_, data_); } -// TODO should lfsr_btree_lookupnext/lfsr_btree_parent be deduplicated? -static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, - lfsr_bid_t bid, const lfsr_rbyd_t *child, - lfsr_rbyd_t *rbyd_, lfsr_srid_t *rid_) { +// TODO should lfs3_btree_lookupnext/lfs3_btree_parent be deduplicated? +static int lfs3_btree_parent(lfs3_t *lfs3, const lfs3_btree_t *btree, + lfs3_bid_t bid, const lfs3_rbyd_t *child, + lfs3_rbyd_t *rbyd_, lfs3_srid_t *rid_) { // we should only call this when we actually have parents - LFS_ASSERT(bid < (lfsr_bid_t)btree->weight); - LFS_ASSERT(lfsr_rbyd_cmp(btree, child) != 0); + LFS3_ASSERT(bid < (lfs3_bid_t)btree->weight); + LFS3_ASSERT(lfs3_rbyd_cmp(btree, child) != 0); // descend down the btree looking for our rid *rbyd_ = *btree; - lfsr_srid_t rid = bid; + lfs3_srid_t rid = bid; while (true) { // each branch is a pair of optional name + on-disk structure - lfsr_srid_t rid__; - lfsr_tag_t tag__; - lfsr_rid_t weight__; - lfsr_data_t data__; - int err = lfsr_rbyd_lookupnext(lfs, rbyd_, rid, 0, + lfs3_srid_t rid__; + lfs3_tag_t tag__; + lfs3_rid_t weight__; + lfs3_data_t data__; + int err = lfs3_rbyd_lookupnext(lfs3, rbyd_, rid, 0, &rid__, &tag__, &weight__, &data__); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // if we found a bname, lookup the branch - if (tag__ == LFSR_TAG_BNAME) { - err = lfsr_rbyd_lookup(lfs, rbyd_, rid__, LFSR_TAG_BRANCH, + if (tag__ == LFS3_TAG_BNAME) { + err = lfs3_rbyd_lookup(lfs3, rbyd_, rid__, LFS3_TAG_BRANCH, &tag__, &data__); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } // didn't find our child? - if (tag__ != LFSR_TAG_BRANCH) { - return LFS_ERR_NOENT; + if (tag__ != LFS3_TAG_BRANCH) { + return LFS3_ERR_NOENT; } // adjust rid with subtree's weight rid -= (rid__ - (weight__-1)); // fetch the next branch - lfsr_rbyd_t child_; - err = lfsr_data_readbranch(lfs, &data__, weight__, &child_); + lfs3_rbyd_t child_; + err = lfs3_data_readbranch(lfs3, &data__, weight__, &child_); if (err) { return err; } // found our child? - if (lfsr_rbyd_cmp(&child_, child) == 0) { + if (lfs3_rbyd_cmp(&child_, child) == 0) { // TODO how many of these should be conditional? if (rid_) { *rid_ = rid__; @@ -5165,7 +5167,7 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, return 0; } - err = lfsr_branch_fetch(lfs, rbyd_, + err = lfs3_branch_fetch(lfs3, rbyd_, child_.blocks[0], child_.trunk, child_.weight, child_.cksum); if (err) { @@ -5175,15 +5177,15 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, } -// extra state needed for non-terminating lfsr_btree_commit_ calls -typedef struct lfsr_bctx { - lfsr_rattr_t rattrs[4]; - lfsr_data_t split_name; - uint8_t buf[2*LFSR_BRANCH_DSIZE]; -} lfsr_bctx_t; +// extra state needed for non-terminating lfs3_btree_commit_ calls +typedef struct lfs3_bctx { + lfs3_rattr_t rattrs[4]; + lfs3_data_t split_name; + uint8_t buf[2*LFS3_BRANCH_DSIZE]; +} lfs3_bctx_t; -// needed in lfsr_btree_commit_ -static inline uint32_t lfsr_rev_btree(lfs_t *lfs); +// needed in lfs3_btree_commit_ +static inline uint32_t lfs3_rev_btree(lfs3_t *lfs3); // core btree algorithm // @@ -5197,7 +5199,7 @@ static inline uint32_t lfsr_rev_btree(lfs_t *lfs); // // This is because our btrees contain vestigial names, i.e. our inner // nodes may contain names no longer in the tree. This simplifies -// lfsr_btree_commit_, but means insert-before-bid+1 is _not_ the same +// lfs3_btree_commit_, but means insert-before-bid+1 is _not_ the same // as insert-after-bid when named btrees are involved. If you try this // it _will not_ work and if try to make it work you _will_ cry: // @@ -5213,37 +5215,37 @@ static inline uint32_t lfsr_rev_btree(lfs_t *lfs); // a c d g h i k // ^ // -// The problem is that lfsr_btree_commit_ needs to find the same leaf -// rbyd as lfsr_btree_namelookup, and potentially insert-before the +// The problem is that lfs3_btree_commit_ needs to find the same leaf +// rbyd as lfs3_btree_namelookup, and potentially insert-before the // first rid or insert-after the last rid. // // Instead of separate insert-before/after flags, we make the first tag // in a commit insert-before, and all following non-grow tags // insert-after (splits). // -static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, - lfsr_bctx_t *bctx, - lfsr_bid_t *bid, - const lfsr_rattr_t **rattrs, lfs_size_t *rattr_count) { - lfsr_bid_t bid_ = *bid; - LFS_ASSERT(bid_ <= (lfsr_bid_t)btree->weight); - const lfsr_rattr_t *rattrs_ = *rattrs; - lfs_size_t rattr_count_ = *rattr_count; +static int lfs3_btree_commit_(lfs3_t *lfs3, lfs3_btree_t *btree, + lfs3_bctx_t *bctx, + lfs3_bid_t *bid, + const lfs3_rattr_t **rattrs, lfs3_size_t *rattr_count) { + lfs3_bid_t bid_ = *bid; + LFS3_ASSERT(bid_ <= (lfs3_bid_t)btree->weight); + const lfs3_rattr_t *rattrs_ = *rattrs; + lfs3_size_t rattr_count_ = *rattr_count; // lookup which leaf our bid resides // - // for lfsr_btree_commit_ operations to work out, we need to + // for lfs3_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 child = *btree; - lfsr_srid_t rid_ = bid_; + lfs3_rbyd_t child = *btree; + lfs3_srid_t rid_ = bid_; if (btree->weight > 0) { - lfsr_srid_t rid__; - int err = lfsr_btree_lookupleaf(lfs, btree, - lfs_min(bid_, btree->weight-1), + lfs3_srid_t rid__; + int err = lfs3_btree_lookupleaf(lfs3, btree, + lfs3_min(bid_, btree->weight-1), &bid_, &child, &rid__, NULL, NULL, NULL); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } @@ -5254,31 +5256,31 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // tail-recursively commit to btree while (true) { // we will always need our parent, so go ahead and find it - lfsr_rbyd_t parent = {.trunk=0, .weight=0}; - lfsr_srid_t pid = 0; + lfs3_rbyd_t parent = {.trunk=0, .weight=0}; + lfs3_srid_t pid = 0; // are we root? - if (!lfsr_rbyd_trunk(&child) + if (!lfs3_rbyd_trunk(&child) || child.blocks[0] == btree->blocks[0]) { // new root? shrub root? yield the final root commit to // higher-level btree/bshrub logic - if (!lfsr_rbyd_trunk(&child) - || lfsr_rbyd_isshrub(btree)) { + if (!lfs3_rbyd_trunk(&child) + || lfs3_rbyd_isshrub(btree)) { *bid = rid_; *rattrs = rattrs_; *rattr_count = rattr_count_; - return (!lfsr_rbyd_trunk(&child)) ? LFS_ERR_RANGE : 0; + return (!lfs3_rbyd_trunk(&child)) ? LFS3_ERR_RANGE : 0; } // mark btree as unerased in case of failure, our btree rbyd and // root rbyd can diverge if there's a split, but we would have // marked the old root as unerased earlier anyways - lfsr_btree_claim(btree); + lfs3_btree_claim(btree); } else { - int err = lfsr_btree_parent(lfs, btree, bid_, &child, + int err = lfs3_btree_parent(lfs3, btree, bid_, &child, &parent, &pid); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } @@ -5290,9 +5292,9 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // unfetched // // a funny benefit is we cache the root of our btree this way - if (!lfsr_rbyd_isfetched(&child)) { - int err = lfsr_rbyd_fetchck(lfs, &child, - child.blocks[0], lfsr_rbyd_trunk(&child), + if (!lfs3_rbyd_isfetched(&child)) { + int err = lfs3_rbyd_fetchck(lfs3, &child, + child.blocks[0], lfs3_rbyd_trunk(&child), child.cksum); if (err) { return err; @@ -5302,11 +5304,11 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // is rbyd erased? can we sneak our commit into any remaining // erased bytes? note that the btree trunk field prevents this from // interacting with other references to the rbyd - lfsr_rbyd_t child_ = child; - int err = lfsr_rbyd_commit(lfs, &child_, rid_, + lfs3_rbyd_t child_ = child; + int err = lfs3_rbyd_commit(lfs3, &child_, rid_, rattrs_, rattr_count_); if (err) { - if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_RANGE || err == LFS3_ERR_CORRUPT) { goto compact; } return err; @@ -5316,59 +5318,59 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, compact:; // estimate our compacted size - lfsr_srid_t split_rid; - lfs_ssize_t estimate = lfsr_rbyd_estimate(lfs, &child, -1, -1, + lfs3_srid_t split_rid; + lfs3_ssize_t estimate = lfs3_rbyd_estimate(lfs3, &child, -1, -1, &split_rid); if (estimate < 0) { return estimate; } // are we too big? need to split? - if ((lfs_size_t)estimate > lfs->cfg->block_size/2) { + if ((lfs3_size_t)estimate > lfs3->cfg->block_size/2) { // need to split goto split; } // before we compact, can we merge with our siblings? - lfsr_rbyd_t sibling; - if ((lfs_size_t)estimate <= lfs->cfg->block_size/4 + lfs3_rbyd_t sibling; + if ((lfs3_size_t)estimate <= lfs3->cfg->block_size/4 // no parent? can't merge - && lfsr_rbyd_trunk(&parent)) { + && lfs3_rbyd_trunk(&parent)) { // try the right sibling - if (pid+1 < (lfsr_srid_t)parent.weight) { + if (pid+1 < (lfs3_srid_t)parent.weight) { // try looking up the sibling - lfsr_srid_t sibling_rid; - lfsr_tag_t sibling_tag; - lfsr_rid_t sibling_weight; - lfsr_data_t sibling_data; - err = lfsr_rbyd_lookupnext(lfs, &parent, pid+1, 0, + lfs3_srid_t sibling_rid; + lfs3_tag_t sibling_tag; + lfs3_rid_t sibling_weight; + lfs3_data_t sibling_data; + err = lfs3_rbyd_lookupnext(lfs3, &parent, pid+1, 0, &sibling_rid, &sibling_tag, &sibling_weight, &sibling_data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // if we found a bname, lookup the branch - if (sibling_tag == LFSR_TAG_BNAME) { - err = lfsr_rbyd_lookup(lfs, &parent, - sibling_rid, LFSR_TAG_BRANCH, + if (sibling_tag == LFS3_TAG_BNAME) { + err = lfs3_rbyd_lookup(lfs3, &parent, + sibling_rid, LFS3_TAG_BRANCH, &sibling_tag, &sibling_data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } - LFS_ASSERT(sibling_tag == LFSR_TAG_BRANCH); - err = lfsr_data_fetchbranch(lfs, &sibling_data, sibling_weight, + LFS3_ASSERT(sibling_tag == LFS3_TAG_BRANCH); + err = lfs3_data_fetchbranch(lfs3, &sibling_data, sibling_weight, &sibling); if (err) { return err; } // estimate if our sibling will fit - lfs_ssize_t sibling_estimate = lfsr_rbyd_estimate(lfs, + lfs3_ssize_t sibling_estimate = lfs3_rbyd_estimate(lfs3, &sibling, -1, -1, NULL); if (sibling_estimate < 0) { @@ -5376,47 +5378,47 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, } // fits? try to merge - if ((lfs_size_t)(estimate + sibling_estimate) - < lfs->cfg->block_size/2) { + if ((lfs3_size_t)(estimate + sibling_estimate) + < lfs3->cfg->block_size/2) { goto merge; } } // try the left sibling - if (pid-(lfsr_srid_t)child.weight >= 0) { + if (pid-(lfs3_srid_t)child.weight >= 0) { // try looking up the sibling - lfsr_srid_t sibling_rid; - lfsr_tag_t sibling_tag; - lfsr_rid_t sibling_weight; - lfsr_data_t sibling_data; - err = lfsr_rbyd_lookupnext(lfs, &parent, pid-child.weight, 0, + lfs3_srid_t sibling_rid; + lfs3_tag_t sibling_tag; + lfs3_rid_t sibling_weight; + lfs3_data_t sibling_data; + err = lfs3_rbyd_lookupnext(lfs3, &parent, pid-child.weight, 0, &sibling_rid, &sibling_tag, &sibling_weight, &sibling_data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // if we found a bname, lookup the branch - if (sibling_tag == LFSR_TAG_BNAME) { - err = lfsr_rbyd_lookup(lfs, &parent, - sibling_rid, LFSR_TAG_BRANCH, + if (sibling_tag == LFS3_TAG_BNAME) { + err = lfs3_rbyd_lookup(lfs3, &parent, + sibling_rid, LFS3_TAG_BRANCH, &sibling_tag, &sibling_data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } - LFS_ASSERT(sibling_tag == LFSR_TAG_BRANCH); - err = lfsr_data_fetchbranch(lfs, &sibling_data, sibling_weight, + LFS3_ASSERT(sibling_tag == LFS3_TAG_BRANCH); + err = lfs3_data_fetchbranch(lfs3, &sibling_data, sibling_weight, &sibling); if (err) { return err; } // estimate if our sibling will fit - lfs_ssize_t sibling_estimate = lfsr_rbyd_estimate(lfs, + lfs3_ssize_t sibling_estimate = lfs3_rbyd_estimate(lfs3, &sibling, -1, -1, NULL); if (sibling_estimate < 0) { @@ -5424,8 +5426,8 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, } // fits? try to merge - if ((lfs_size_t)(estimate + sibling_estimate) - < lfs->cfg->block_size/2) { + if ((lfs3_size_t)(estimate + sibling_estimate) + < lfs3->cfg->block_size/2) { // if we're merging our left sibling, swap our rbyds // so our sibling is on the right bid_ -= sibling.weight; @@ -5443,17 +5445,17 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, relocate:; // allocate a new rbyd - err = lfsr_rbyd_alloc(lfs, &child_); + err = lfs3_rbyd_alloc(lfs3, &child_); if (err) { return err; } - #if defined(LFS_REVDBG) || defined(LFS_REVNOISE) + #if defined(LFS3_REVDBG) || defined(LFS3_REVNOISE) // append a revision count? - err = lfsr_rbyd_appendrev(lfs, &child_, lfsr_rev_btree(lfs)); + err = lfs3_rbyd_appendrev(lfs3, &child_, lfs3_rev_btree(lfs3)); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -5461,11 +5463,11 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, #endif // try to compact - err = lfsr_rbyd_compact(lfs, &child_, &child, -1, -1); + err = lfs3_rbyd_compact(lfs3, &child_, &child, -1, -1); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -5473,12 +5475,12 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // append any pending rattrs, it's up to upper // layers to make sure these always fit - err = lfsr_rbyd_commit(lfs, &child_, rid_, + err = lfs3_rbyd_commit(lfs3, &child_, rid_, rattrs_, rattr_count_); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -5488,22 +5490,22 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, split:; // we should have something to split here - LFS_ASSERT(split_rid > 0 - && split_rid < (lfsr_srid_t)child.weight); + LFS3_ASSERT(split_rid > 0 + && split_rid < (lfs3_srid_t)child.weight); split_relocate_l:; // allocate a new rbyd - err = lfsr_rbyd_alloc(lfs, &child_); + err = lfs3_rbyd_alloc(lfs3, &child_); if (err) { return err; } - #if defined(LFS_REVDBG) || defined(LFS_REVNOISE) + #if defined(LFS3_REVDBG) || defined(LFS3_REVNOISE) // append a revision count? - err = lfsr_rbyd_appendrev(lfs, &child_, lfsr_rev_btree(lfs)); + err = lfs3_rbyd_appendrev(lfs3, &child_, lfs3_rev_btree(lfs3)); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_l; } return err; @@ -5511,11 +5513,11 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, #endif // copy over tags < split_rid - err = lfsr_rbyd_compact(lfs, &child_, &child, -1, split_rid); + err = lfs3_rbyd_compact(lfs3, &child_, &child, -1, split_rid); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_l; } return err; @@ -5525,23 +5527,23 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendrattrs(lfs, &child_, rid_, -1, split_rid, + err = lfs3_rbyd_appendrattrs(lfs3, &child_, rid_, -1, split_rid, rattrs_, rattr_count_); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_l; } return err; } // finalize commit - err = lfsr_rbyd_appendcksum(lfs, &child_); + err = lfs3_rbyd_appendcksum(lfs3, &child_); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_l; } return err; @@ -5549,17 +5551,17 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, split_relocate_r:; // allocate a sibling - err = lfsr_rbyd_alloc(lfs, &sibling); + err = lfs3_rbyd_alloc(lfs3, &sibling); if (err) { return err; } - #if defined(LFS_REVDBG) || defined(LFS_REVNOISE) + #if defined(LFS3_REVDBG) || defined(LFS3_REVNOISE) // append a revision count? - err = lfsr_rbyd_appendrev(lfs, &sibling, lfsr_rev_btree(lfs)); + err = lfs3_rbyd_appendrev(lfs3, &sibling, lfs3_rev_btree(lfs3)); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_r; } return err; @@ -5567,11 +5569,11 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, #endif // copy over tags >= split_rid - err = lfsr_rbyd_compact(lfs, &sibling, &child, split_rid, -1); + err = lfs3_rbyd_compact(lfs3, &sibling, &child, split_rid, -1); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_r; } return err; @@ -5581,23 +5583,23 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendrattrs(lfs, &sibling, rid_, split_rid, -1, + err = lfs3_rbyd_appendrattrs(lfs3, &sibling, rid_, split_rid, -1, rattrs_, rattr_count_); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_r; } return err; } // finalize commit - err = lfsr_rbyd_appendcksum(lfs, &sibling); + err = lfs3_rbyd_appendcksum(lfs3, &sibling); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate_r; } return err; @@ -5616,55 +5618,55 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // // note we need to do this after playing out pending rattrs in case // they introduce a new name! - lfsr_tag_t split_tag; - err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, 0, + lfs3_tag_t split_tag; + err = lfs3_rbyd_lookupnext(lfs3, &sibling, 0, 0, NULL, &split_tag, NULL, &bctx->split_name); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // prepare commit to parent, tail recursing upwards - LFS_ASSERT(child_.weight > 0); - LFS_ASSERT(sibling.weight > 0); + LFS3_ASSERT(child_.weight > 0); + LFS3_ASSERT(sibling.weight > 0); rattr_count_ = 0; // new root? - if (!lfsr_rbyd_trunk(&parent)) { - lfsr_data_t branch_l = lfsr_data_frombranch( - &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]); - bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF( - LFSR_TAG_BRANCH, +child_.weight, - branch_l.u.buffer, lfsr_data_size(branch_l)); - lfsr_data_t branch_r = lfsr_data_frombranch( - &sibling, &bctx->buf[1*LFSR_BRANCH_DSIZE]); - bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF( - LFSR_TAG_BRANCH, +sibling.weight, - branch_r.u.buffer, lfsr_data_size(branch_r)); - if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - bctx->rattrs[rattr_count_++] = LFSR_RATTR_DATA( - LFSR_TAG_BNAME, 0, + if (!lfs3_rbyd_trunk(&parent)) { + lfs3_data_t branch_l = lfs3_data_frombranch( + &child_, &bctx->buf[0*LFS3_BRANCH_DSIZE]); + bctx->rattrs[rattr_count_++] = LFS3_RATTR_BUF( + LFS3_TAG_BRANCH, +child_.weight, + branch_l.u.buffer, lfs3_data_size(branch_l)); + lfs3_data_t branch_r = lfs3_data_frombranch( + &sibling, &bctx->buf[1*LFS3_BRANCH_DSIZE]); + bctx->rattrs[rattr_count_++] = LFS3_RATTR_BUF( + LFS3_TAG_BRANCH, +sibling.weight, + branch_r.u.buffer, lfs3_data_size(branch_r)); + if (lfs3_tag_suptype(split_tag) == LFS3_TAG_NAME) { + bctx->rattrs[rattr_count_++] = LFS3_RATTR_DATA( + LFS3_TAG_BNAME, 0, &bctx->split_name); } // split root? } else { bid_ -= pid - (child.weight-1); - lfsr_data_t branch_l = lfsr_data_frombranch( - &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]); - bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF( - LFSR_TAG_BRANCH, 0, - branch_l.u.buffer, lfsr_data_size(branch_l)); + lfs3_data_t branch_l = lfs3_data_frombranch( + &child_, &bctx->buf[0*LFS3_BRANCH_DSIZE]); + bctx->rattrs[rattr_count_++] = LFS3_RATTR_BUF( + LFS3_TAG_BRANCH, 0, + branch_l.u.buffer, lfs3_data_size(branch_l)); if (child_.weight != child.weight) { - bctx->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_GROW, -child.weight + child_.weight); + bctx->rattrs[rattr_count_++] = LFS3_RATTR( + LFS3_TAG_GROW, -child.weight + child_.weight); } - lfsr_data_t branch_r = lfsr_data_frombranch( - &sibling, &bctx->buf[1*LFSR_BRANCH_DSIZE]); - bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF( - LFSR_TAG_BRANCH, +sibling.weight, - branch_r.u.buffer, lfsr_data_size(branch_r)); - if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - bctx->rattrs[rattr_count_++] = LFSR_RATTR_DATA( - LFSR_TAG_BNAME, 0, + lfs3_data_t branch_r = lfs3_data_frombranch( + &sibling, &bctx->buf[1*LFS3_BRANCH_DSIZE]); + bctx->rattrs[rattr_count_++] = LFS3_RATTR_BUF( + LFS3_TAG_BRANCH, +sibling.weight, + branch_r.u.buffer, lfs3_data_size(branch_r)); + if (lfs3_tag_suptype(split_tag) == LFS3_TAG_NAME) { + bctx->rattrs[rattr_count_++] = LFS3_RATTR_DATA( + LFS3_TAG_BNAME, 0, &bctx->split_name); } } @@ -5677,17 +5679,17 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, merge:; merge_relocate:; // allocate a new rbyd - err = lfsr_rbyd_alloc(lfs, &child_); + err = lfs3_rbyd_alloc(lfs3, &child_); if (err) { return err; } - #if defined(LFS_REVDBG) || defined(LFS_REVNOISE) + #if defined(LFS3_REVDBG) || defined(LFS3_REVNOISE) // append a revision count? - err = lfsr_rbyd_appendrev(lfs, &child_, lfsr_rev_btree(lfs)); + err = lfs3_rbyd_appendrev(lfs3, &child_, lfs3_rev_btree(lfs3)); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto merge_relocate; } return err; @@ -5695,31 +5697,31 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, #endif // merge the siblings together - err = lfsr_rbyd_appendcompactrbyd(lfs, &child_, &child, -1, -1); + err = lfs3_rbyd_appendcompactrbyd(lfs3, &child_, &child, -1, -1); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto merge_relocate; } return err; } - err = lfsr_rbyd_appendcompactrbyd(lfs, &child_, &sibling, -1, -1); + err = lfs3_rbyd_appendcompactrbyd(lfs3, &child_, &sibling, -1, -1); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto merge_relocate; } return err; } - err = lfsr_rbyd_appendcompaction(lfs, &child_, 0); + err = lfs3_rbyd_appendcompaction(lfs3, &child_, 0); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto merge_relocate; } return err; @@ -5727,12 +5729,12 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // append any pending rattrs, it's up to upper // layers to make sure these always fit - err = lfsr_rbyd_commit(lfs, &child_, rid_, + err = lfs3_rbyd_commit(lfs3, &child_, rid_, rattrs_, rattr_count_); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto merge_relocate; } return err; @@ -5740,7 +5742,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // we must have a parent at this point, but is our parent the root // and is the root degenerate? - LFS_ASSERT(lfsr_rbyd_trunk(&parent)); + LFS3_ASSERT(lfs3_rbyd_trunk(&parent)); if (child.weight+sibling.weight == btree->weight) { // collapse the root, decreasing the height of the tree *btree = child_; @@ -5750,20 +5752,20 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, } // prepare commit to parent, tail recursing upwards - LFS_ASSERT(child_.weight > 0); + LFS3_ASSERT(child_.weight > 0); rattr_count_ = 0; // build attr list bid_ -= pid - (child.weight-1); - bctx->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_RM, -sibling.weight); - lfsr_data_t branch = lfsr_data_frombranch( - &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]); - bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF( - LFSR_TAG_BRANCH, 0, - branch.u.buffer, lfsr_data_size(branch)); + bctx->rattrs[rattr_count_++] = LFS3_RATTR( + LFS3_TAG_RM, -sibling.weight); + lfs3_data_t branch = lfs3_data_frombranch( + &child_, &bctx->buf[0*LFS3_BRANCH_DSIZE]); + bctx->rattrs[rattr_count_++] = LFS3_RATTR_BUF( + LFS3_TAG_BRANCH, 0, + branch.u.buffer, lfs3_data_size(branch)); if (child_.weight != child.weight) { - bctx->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_GROW, -child.weight + child_.weight); + bctx->rattrs[rattr_count_++] = LFS3_RATTR( + LFS3_TAG_GROW, -child.weight + child_.weight); } rattrs_ = bctx->rattrs; @@ -5773,7 +5775,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, commit:; // done? - if (!lfsr_rbyd_trunk(&parent)) { + if (!lfs3_rbyd_trunk(&parent)) { // update the root *btree = child_; // no new root needed @@ -5797,17 +5799,17 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, rattr_count_ = 0; bid_ -= pid - (child.weight-1); if (child_.weight == 0) { - bctx->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_RM, -child.weight); + bctx->rattrs[rattr_count_++] = LFS3_RATTR( + LFS3_TAG_RM, -child.weight); } else { - lfsr_data_t branch = lfsr_data_frombranch( - &child_, &bctx->buf[0*LFSR_BRANCH_DSIZE]); - bctx->rattrs[rattr_count_++] = LFSR_RATTR_BUF( - LFSR_TAG_BRANCH, 0, - branch.u.buffer, lfsr_data_size(branch)); + lfs3_data_t branch = lfs3_data_frombranch( + &child_, &bctx->buf[0*LFS3_BRANCH_DSIZE]); + bctx->rattrs[rattr_count_++] = LFS3_RATTR_BUF( + LFS3_TAG_BRANCH, 0, + branch.u.buffer, lfs3_data_size(branch)); if (child_.weight != child.weight) { - bctx->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_GROW, -child.weight + child_.weight); + bctx->rattrs[rattr_count_++] = LFS3_RATTR( + LFS3_TAG_GROW, -child.weight + child_.weight); } } rattrs_ = bctx->rattrs; @@ -5819,22 +5821,22 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, } // commit/alloc a new btree root -static int lfsr_btree_commitroot_(lfs_t *lfs, lfsr_btree_t *btree, +static int lfs3_btree_commitroot_(lfs3_t *lfs3, lfs3_btree_t *btree, bool split, - lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { + lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { relocate:; - lfsr_rbyd_t rbyd_; - int err = lfsr_rbyd_alloc(lfs, &rbyd_); + lfs3_rbyd_t rbyd_; + int err = lfs3_rbyd_alloc(lfs3, &rbyd_); if (err) { return err; } - #if defined(LFS_REVDBG) || defined(LFS_REVNOISE) + #if defined(LFS3_REVDBG) || defined(LFS3_REVNOISE) // append a revision count? - err = lfsr_rbyd_appendrev(lfs, &rbyd_, lfsr_rev_btree(lfs)); + err = lfs3_rbyd_appendrev(lfs3, &rbyd_, lfs3_rev_btree(lfs3)); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -5843,22 +5845,22 @@ relocate:; // bshrubs may call this just to migrate rattrs to a btree if (!split) { - err = lfsr_rbyd_compact(lfs, &rbyd_, btree, -1, -1); + err = lfs3_rbyd_compact(lfs3, &rbyd_, btree, -1, -1); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; } } - err = lfsr_rbyd_commit(lfs, &rbyd_, bid, rattrs, rattr_count); + err = lfs3_rbyd_commit(lfs3, &rbyd_, bid, rattrs, rattr_count); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -5870,32 +5872,32 @@ relocate:; } // 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) { +static int lfs3_btree_commit(lfs3_t *lfs3, lfs3_btree_t *btree, + lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // try to commit to the btree - lfsr_bctx_t bctx; - int err = lfsr_btree_commit_(lfs, btree, &bctx, + lfs3_bctx_t bctx; + int err = lfs3_btree_commit_(lfs3, btree, &bctx, &bid, &rattrs, &rattr_count); - if (err && err != LFS_ERR_RANGE) { + if (err && err != LFS3_ERR_RANGE) { return err; } // needs a new root? - if (err == LFS_ERR_RANGE) { - LFS_ASSERT(rattr_count > 0); + if (err == LFS3_ERR_RANGE) { + LFS3_ASSERT(rattr_count > 0); - err = lfsr_btree_commitroot_(lfs, btree, true, + err = lfs3_btree_commitroot_(lfs3, btree, true, bid, rattrs, rattr_count); if (err) { return err; } } - LFS_ASSERT(lfsr_rbyd_trunk(btree)); - #ifdef LFS_DBGBTREECOMMITS - LFS_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", " + LFS3_ASSERT(lfs3_rbyd_trunk(btree)); + #ifdef LFS3_DBGBTREECOMMITS + LFS3_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", " "cksum %"PRIx32, - btree->blocks[0], lfsr_rbyd_trunk(btree), + btree->blocks[0], lfs3_rbyd_trunk(btree), btree->weight, btree->cksum); #endif @@ -5903,53 +5905,53 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree, } // lookup in a btree by name -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_rbyd_t *rbyd_, lfsr_srid_t *rid_, - lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { +static lfs3_scmp_t lfs3_btree_namelookupleaf(lfs3_t *lfs3, + const lfs3_btree_t *btree, + lfs3_did_t did, const char *name, lfs3_size_t name_len, + lfs3_bid_t *bid_, lfs3_rbyd_t *rbyd_, lfs3_srid_t *rid_, + lfs3_tag_t *tag_, lfs3_bid_t *weight_, lfs3_data_t *data_) { // an empty tree? if (btree->weight == 0) { - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // descend down the btree looking for our name *rbyd_ = *btree; - lfsr_bid_t bid = 0; + lfs3_bid_t bid = 0; while (true) { // each branch is a pair of optional name + on-disk structure // lookup our name in the rbyd via binary search - lfsr_srid_t rid__; - lfsr_tag_t tag__; - lfsr_rid_t weight__; - lfsr_data_t data__; - lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, rbyd_, + lfs3_srid_t rid__; + lfs3_tag_t tag__; + lfs3_rid_t weight__; + lfs3_data_t data__; + lfs3_scmp_t cmp = lfs3_rbyd_namelookup(lfs3, rbyd_, did, name, name_len, &rid__, &tag__, &weight__, &data__); if (cmp < 0) { - LFS_ASSERT(cmp != LFS_ERR_NOENT); + LFS3_ASSERT(cmp != LFS3_ERR_NOENT); return cmp; } // if we found a bname, lookup the branch - if (tag__ == LFSR_TAG_BNAME) { - int err = lfsr_rbyd_lookup(lfs, rbyd_, rid__, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + if (tag__ == LFS3_TAG_BNAME) { + int err = lfs3_rbyd_lookup(lfs3, rbyd_, rid__, + LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag__, &data__); if (err < 0) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } // found another branch - if (tag__ == LFSR_TAG_BRANCH) { + if (tag__ == LFS3_TAG_BRANCH) { // update our bid bid += rid__ - (weight__-1); // fetch the next branch - int err = lfsr_data_fetchbranch(lfs, &data__, weight__, + int err = lfs3_data_fetchbranch(lfs3, &data__, weight__, rbyd_); if (err < 0) { return err; @@ -5978,13 +5980,13 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs, } } -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_) { - lfsr_rbyd_t rbyd; - return lfsr_btree_namelookupleaf(lfs, btree, +static lfs3_scmp_t lfs3_btree_namelookup(lfs3_t *lfs3, + const lfs3_btree_t *btree, + lfs3_did_t did, const char *name, lfs3_size_t name_len, + lfs3_bid_t *bid_, + lfs3_tag_t *tag_, lfs3_bid_t *weight_, lfs3_data_t *data_) { + lfs3_rbyd_t rbyd; + return lfs3_btree_namelookupleaf(lfs3, btree, did, name, name_len, bid_, &rbyd, NULL, tag_, weight_, data_); } @@ -5992,17 +5994,17 @@ static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, // incremental btree traversal // // note this is different from iteration, iteration should use -// lfsr_btree_lookupnext, traversal includes inner btree nodes +// lfs3_btree_lookupnext, traversal includes inner btree nodes -static void lfsr_btraversal_init(lfsr_btraversal_t *bt) { +static void lfs3_btraversal_init(lfs3_btraversal_t *bt) { bt->bid = 0; bt->branch = NULL; bt->rid = 0; } -static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, - lfsr_btraversal_t *bt, - lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_data_t *data_) { +static int lfs3_btree_traverse(lfs3_t *lfs3, const lfs3_btree_t *btree, + lfs3_btraversal_t *bt, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_data_t *data_) { // explicitly traverse the root even if weight=0 if (!bt->branch) { bt->branch = btree; @@ -6011,14 +6013,14 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, // traverse the root if (bt->bid == 0 // unless we don't even have a root yet - && lfsr_rbyd_trunk(btree) != 0 + && lfs3_rbyd_trunk(btree) != 0 // or are a shrub - && !lfsr_rbyd_isshrub(btree)) { + && !lfs3_rbyd_isshrub(btree)) { if (bid_) { *bid_ = btree->weight-1; } if (tag_) { - *tag_ = LFSR_TAG_BRANCH; + *tag_ = LFS3_TAG_BRANCH; } if (data_) { data_->u.buffer = (const uint8_t*)bt->branch; @@ -6028,40 +6030,40 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, } // need to restart from the root? - if (bt->rid >= (lfsr_srid_t)bt->branch->weight) { + if (bt->rid >= (lfs3_srid_t)bt->branch->weight) { bt->branch = btree; bt->rid = bt->bid; } // descend down the tree while (true) { - lfsr_srid_t rid__; - lfsr_tag_t tag__; - lfsr_rid_t weight__; - lfsr_data_t data__; - int err = lfsr_rbyd_lookupnext(lfs, bt->branch, bt->rid, 0, + lfs3_srid_t rid__; + lfs3_tag_t tag__; + lfs3_rid_t weight__; + lfs3_data_t data__; + int err = lfs3_rbyd_lookupnext(lfs3, bt->branch, bt->rid, 0, &rid__, &tag__, &weight__, &data__); if (err) { return err; } // if we found a bname, lookup the branch - if (tag__ == LFSR_TAG_BNAME) { - err = lfsr_rbyd_lookup(lfs, bt->branch, rid__, LFSR_TAG_BRANCH, + if (tag__ == LFS3_TAG_BNAME) { + err = lfs3_rbyd_lookup(lfs3, bt->branch, rid__, LFS3_TAG_BRANCH, &tag__, &data__); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } // found another branch - if (tag__ == LFSR_TAG_BRANCH) { + if (tag__ == LFS3_TAG_BRANCH) { // adjust rid with subtree's weight bt->rid -= (rid__ - (weight__-1)); // fetch the next branch - err = lfsr_data_fetchbranch(lfs, &data__, weight__, + err = lfs3_data_fetchbranch(lfs3, &data__, weight__, &bt->rbyd); if (err) { return err; @@ -6075,7 +6077,7 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, *bid_ = bt->bid + (rid__ - bt->rid); } if (tag_) { - *tag_ = LFSR_TAG_BRANCH; + *tag_ = LFS3_TAG_BRANCH; } if (data_) { data_->u.buffer = (const uint8_t*)bt->branch; @@ -6089,7 +6091,7 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, // // note this effectively traverses a full leaf without redoing // the btree walk - lfsr_bid_t bid__ = bt->bid + (rid__ - bt->rid); + lfs3_bid_t bid__ = bt->bid + (rid__ - bt->rid); bt->bid = bid__ + 1; bt->rid = rid__ + 1; @@ -6115,105 +6117,105 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, // shrub things // helper functions -static inline bool lfsr_shrub_isshrub(const lfsr_shrub_t *shrub) { - return lfsr_rbyd_isshrub(shrub); +static inline bool lfs3_shrub_isshrub(const lfs3_shrub_t *shrub) { + return lfs3_rbyd_isshrub(shrub); } -static inline lfs_size_t lfsr_shrub_trunk(const lfsr_shrub_t *shrub) { - return lfsr_rbyd_trunk(shrub); +static inline lfs3_size_t lfs3_shrub_trunk(const lfs3_shrub_t *shrub) { + return lfs3_rbyd_trunk(shrub); } -static inline int lfsr_shrub_cmp( - const lfsr_shrub_t *a, - const lfsr_shrub_t *b) { - return lfsr_rbyd_cmp(a, b); +static inline int lfs3_shrub_cmp( + const lfs3_shrub_t *a, + const lfs3_shrub_t *b) { + return lfs3_rbyd_cmp(a, b); } // shrub on-disk encoding -static lfsr_data_t lfsr_data_fromshrub(const lfsr_shrub_t *shrub, - uint8_t buffer[static LFSR_SHRUB_DSIZE]) { +static lfs3_data_t lfs3_data_fromshrub(const lfs3_shrub_t *shrub, + uint8_t buffer[static LFS3_SHRUB_DSIZE]) { // shrub trunks should never be null - LFS_ASSERT(lfsr_shrub_trunk(shrub) != 0); + LFS3_ASSERT(lfs3_shrub_trunk(shrub) != 0); // weight should not exceed 31-bits - LFS_ASSERT(shrub->weight <= 0x7fffffff); + LFS3_ASSERT(shrub->weight <= 0x7fffffff); // trunk should not exceed 28-bits - LFS_ASSERT(lfsr_shrub_trunk(shrub) <= 0x0fffffff); - lfs_ssize_t d = 0; + LFS3_ASSERT(lfs3_shrub_trunk(shrub) <= 0x0fffffff); + lfs3_ssize_t d = 0; // just write the trunk and weight, the rest of the rbyd is contextual - lfs_ssize_t d_ = lfs_toleb128(shrub->weight, &buffer[d], 5); + lfs3_ssize_t d_ = lfs3_toleb128(shrub->weight, &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - d_ = lfs_toleb128(lfsr_shrub_trunk(shrub), + d_ = lfs3_toleb128(lfs3_shrub_trunk(shrub), &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readshrub(lfs_t *lfs, lfsr_data_t *data, - const lfsr_mdir_t *mdir, - lfsr_shrub_t *shrub) { +static int lfs3_data_readshrub(lfs3_t *lfs3, lfs3_data_t *data, + const lfs3_mdir_t *mdir, + lfs3_shrub_t *shrub) { // copy the mdir block shrub->blocks[0] = mdir->rbyd.blocks[0]; // force estimate recalculation if we write to this shrub shrub->eoff = -1; - int err = lfsr_data_readleb128(lfs, data, &shrub->weight); + int err = lfs3_data_readleb128(lfs3, data, &shrub->weight); if (err) { return err; } - err = lfsr_data_readlleb128(lfs, data, &shrub->trunk); + err = lfs3_data_readlleb128(lfs3, data, &shrub->trunk); if (err) { return err; } // shrub trunks should never be null - LFS_ASSERT(lfsr_shrub_trunk(shrub)); + LFS3_ASSERT(lfs3_shrub_trunk(shrub)); // set the shrub bit in our trunk - shrub->trunk |= LFSR_RBYD_ISSHRUB; + shrub->trunk |= LFS3_RBYD_ISSHRUB; return 0; } -// needed in lfsr_shrub_estimate -static inline bool lfsr_o_isbshrub(uint32_t flags); +// needed in lfs3_shrub_estimate +static inline bool lfs3_o_isbshrub(uint32_t flags); // these are used in mdir commit/compaction -static lfs_ssize_t lfsr_shrub_estimate(lfs_t *lfs, - const lfsr_shrub_t *shrub) { +static lfs3_ssize_t lfs3_shrub_estimate(lfs3_t *lfs3, + const lfs3_shrub_t *shrub) { // only include the last reference - const lfsr_shrub_t *last = NULL; - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) - && lfsr_shrub_cmp( - &((lfsr_bshrub_t*)o)->shrub, + const lfs3_shrub_t *last = NULL; + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) + && lfs3_shrub_cmp( + &((lfs3_bshrub_t*)o)->shrub, shrub) == 0) { - last = &((lfsr_bshrub_t*)o)->shrub; + last = &((lfs3_bshrub_t*)o)->shrub; } } if (last && shrub != last) { return 0; } - return lfsr_rbyd_estimate(lfs, shrub, -1, -1, + return lfs3_rbyd_estimate(lfs3, shrub, -1, -1, NULL); } -static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, - lfsr_shrub_t *shrub_, const lfsr_shrub_t *shrub) { +static int lfs3_shrub_compact(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, + lfs3_shrub_t *shrub_, const lfs3_shrub_t *shrub) { // save our current trunk/weight - lfs_size_t trunk = rbyd_->trunk; - lfsr_srid_t weight = rbyd_->weight; + lfs3_size_t trunk = rbyd_->trunk; + lfs3_srid_t weight = rbyd_->weight; // compact our bshrub - int err = lfsr_rbyd_appendshrub(lfs, rbyd_, shrub); + int err = lfs3_rbyd_appendshrub(lfs3, rbyd_, shrub); if (err) { return err; } @@ -6222,14 +6224,14 @@ static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, // update these later if our commit is a success // // this should include our current bshrub - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) - && lfsr_shrub_cmp( - &((lfsr_bshrub_t*)o)->shrub, + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) + && lfs3_shrub_cmp( + &((lfs3_bshrub_t*)o)->shrub, shrub) == 0) { - ((lfsr_bshrub_t*)o)->shrub_.blocks[0] = rbyd_->blocks[0]; - ((lfsr_bshrub_t*)o)->shrub_.trunk = rbyd_->trunk; - ((lfsr_bshrub_t*)o)->shrub_.weight = rbyd_->weight; + ((lfs3_bshrub_t*)o)->shrub_.blocks[0] = rbyd_->blocks[0]; + ((lfs3_bshrub_t*)o)->shrub_.trunk = rbyd_->trunk; + ((lfs3_bshrub_t*)o)->shrub_.weight = rbyd_->weight; } } @@ -6243,28 +6245,28 @@ static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } // this is needed to sneak shrub commits into mdir commits -typedef struct lfsr_shrubcommit { - lfsr_bshrub_t *bshrub; - lfsr_srid_t rid; - const lfsr_rattr_t *rattrs; - lfs_size_t rattr_count; -} lfsr_shrubcommit_t; +typedef struct lfs3_shrubcommit { + lfs3_bshrub_t *bshrub; + lfs3_srid_t rid; + const lfs3_rattr_t *rattrs; + lfs3_size_t rattr_count; +} lfs3_shrubcommit_t; -static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_, - lfsr_shrub_t *shrub, lfsr_srid_t rid, - const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { +static int lfs3_shrub_commit(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, + lfs3_shrub_t *shrub, lfs3_srid_t rid, + const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // swap out our trunk/weight temporarily, note we're // operating on a copy so if this fails we shouldn't mess // things up too much // // it is important that these rbyds share eoff/cksum/etc - lfs_size_t trunk = rbyd_->trunk; - lfsr_srid_t weight = rbyd_->weight; + lfs3_size_t trunk = rbyd_->trunk; + lfs3_srid_t weight = rbyd_->weight; rbyd_->trunk = shrub->trunk; rbyd_->weight = shrub->weight; // append any bshrub attributes - int err = lfsr_rbyd_appendrattrs(lfs, rbyd_, rid, -1, -1, + int err = lfs3_rbyd_appendrattrs(lfs3, rbyd_, rid, -1, -1, rattrs, rattr_count); if (err) { return err; @@ -6282,7 +6284,7 @@ static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_, // ok, actual bshrub things // create a non-existant bshrub -static void lfsr_bshrub_init(lfsr_bshrub_t *bshrub) { +static void lfs3_bshrub_init(lfs3_bshrub_t *bshrub) { // set up a null bshrub bshrub->shrub.weight = 0; bshrub->shrub.blocks[0] = -1; @@ -6291,54 +6293,54 @@ static void lfsr_bshrub_init(lfsr_bshrub_t *bshrub) { bshrub->shrub.eoff = -1; } -static inline bool lfsr_bshrub_isbnull(const lfsr_bshrub_t *bshrub) { +static inline bool lfs3_bshrub_isbnull(const lfs3_bshrub_t *bshrub) { return !bshrub->shrub.trunk; } -static inline bool lfsr_bshrub_isbshrub(const lfsr_bshrub_t *bshrub) { - return lfsr_shrub_isshrub(&bshrub->shrub); +static inline bool lfs3_bshrub_isbshrub(const lfs3_bshrub_t *bshrub) { + return lfs3_shrub_isshrub(&bshrub->shrub); } -static inline bool lfsr_bshrub_isbtree(const lfsr_bshrub_t *bshrub) { - return !lfsr_shrub_isshrub(&bshrub->shrub); +static inline bool lfs3_bshrub_isbtree(const lfs3_bshrub_t *bshrub) { + return !lfs3_shrub_isshrub(&bshrub->shrub); } -static inline int lfsr_bshrub_cmp( - const lfsr_bshrub_t *a, - const lfsr_bshrub_t *b) { - return lfsr_rbyd_cmp(&a->shrub, &b->shrub); +static inline int lfs3_bshrub_cmp( + const lfs3_bshrub_t *a, + const lfs3_bshrub_t *b) { + return lfs3_rbyd_cmp(&a->shrub, &b->shrub); } -// needed in lfsr_bshrub_estimate -static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_tag_t tag, - lfsr_tag_t *tag_, lfsr_data_t *data_); +// needed in lfs3_bshrub_estimate +static int lfs3_mdir_lookup(lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_tag_t tag, + lfs3_tag_t *tag_, lfs3_data_t *data_); // find a tight upper bound on the _full_ bshrub size, this includes // any on-disk bshrubs, and all pending bshrubs -static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs, - const lfsr_bshrub_t *bshrub) { - lfs_size_t estimate = 0; +static lfs3_ssize_t lfs3_bshrub_estimate(lfs3_t *lfs3, + const lfs3_bshrub_t *bshrub) { + lfs3_size_t estimate = 0; // include all unique shrubs related to our file, including the // on-disk shrub - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, &bshrub->o.mdir, LFSR_TAG_BSHRUB, + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, &bshrub->o.mdir, LFS3_TAG_BSHRUB, &tag, &data); - if (err < 0 && err != LFS_ERR_NOENT) { + if (err < 0 && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - lfsr_shrub_t shrub; - err = lfsr_data_readshrub(lfs, &data, &bshrub->o.mdir, + if (err != LFS3_ERR_NOENT) { + lfs3_shrub_t shrub; + err = lfs3_data_readshrub(lfs3, &data, &bshrub->o.mdir, &shrub); if (err < 0) { return err; } - lfs_ssize_t dsize = lfsr_shrub_estimate(lfs, &shrub); + lfs3_ssize_t dsize = lfs3_shrub_estimate(lfs3, &shrub); if (dsize < 0) { return dsize; } @@ -6346,12 +6348,12 @@ static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs, } // this includes our current shrub - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) && o->mdir.mid == bshrub->o.mdir.mid - && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)) { - lfs_ssize_t dsize = lfsr_shrub_estimate(lfs, - &((lfsr_bshrub_t*)o)->shrub); + && lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o)) { + lfs3_ssize_t dsize = lfs3_shrub_estimate(lfs3, + &((lfs3_bshrub_t*)o)->shrub); if (dsize < 0) { return dsize; } @@ -6363,44 +6365,44 @@ static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs, } // 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, +static int lfs3_bshrub_lookupleaf(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, + lfs3_bid_t bid, + lfs3_bid_t *bid_, lfs3_rbyd_t *rbyd_, lfs3_srid_t *rid_, + lfs3_tag_t *tag_, lfs3_bid_t *weight_, lfs3_data_t *data_) { + return lfs3_btree_lookupleaf(lfs3, &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_, - lfsr_data_t *data_) { - return lfsr_btree_lookupnext(lfs, &bshrub->shrub, bid, +static int lfs3_bshrub_lookupnext(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, + lfs3_bid_t bid, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bid_t *weight_, + lfs3_data_t *data_) { + return lfs3_btree_lookupnext(lfs3, &bshrub->shrub, bid, bid_, tag_, weight_, data_); } -static int lfsr_bshrub_lookup(lfs_t *lfs, const lfsr_bshrub_t *bshrub, - lfsr_bid_t bid, lfsr_tag_t tag, - lfsr_tag_t *tag_, lfsr_data_t *data_) { - return lfsr_btree_lookup(lfs, &bshrub->shrub, bid, tag, +static int lfs3_bshrub_lookup(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, + lfs3_bid_t bid, lfs3_tag_t tag, + lfs3_tag_t *tag_, lfs3_data_t *data_) { + return lfs3_btree_lookup(lfs3, &bshrub->shrub, bid, tag, tag_, data_); } -static int lfsr_bshrub_traverse(lfs_t *lfs, const lfsr_bshrub_t *bshrub, - lfsr_btraversal_t *bt, - lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_data_t *data_) { - return lfsr_btree_traverse(lfs, &bshrub->shrub, bt, +static int lfs3_bshrub_traverse(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, + lfs3_btraversal_t *bt, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_data_t *data_) { + return lfs3_btree_traverse(lfs3, &bshrub->shrub, bt, bid_, tag_, data_); } -// needed in lfsr_bshrub_commitroot_ -static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, - const lfsr_rattr_t *rattrs, lfs_size_t rattr_count); +// needed in lfs3_bshrub_commitroot_ +static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir, + const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count); // commit to the bshrub root, i.e. the bshrub's shrub -static int lfsr_bshrub_commitroot_(lfs_t *lfs, lfsr_bshrub_t *bshrub, +static int lfs3_bshrub_commitroot_(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, bool split, - lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { + lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // we need to prevent our shrub from overflowing our mdir somehow // // maintaining an accurate estimate is tricky and error-prone, @@ -6412,19 +6414,19 @@ static int lfsr_bshrub_commitroot_(lfs_t *lfs, lfsr_bshrub_t *bshrub, // block_size and rbyds interact, and amortizes the estimate cost. // figure out how much data this commit progs - lfs_size_t commit_estimate = 0; - for (lfs_size_t i = 0; i < rattr_count; i++) { - commit_estimate += lfs->rattr_estimate - + lfsr_rattr_dsize(rattrs[i]); + lfs3_size_t commit_estimate = 0; + for (lfs3_size_t i = 0; i < rattr_count; i++) { + commit_estimate += lfs3->rattr_estimate + + lfs3_rattr_dsize(rattrs[i]); } // does our estimate exceed our inline_size? need to recalculate an // accurate estimate - lfs_ssize_t estimate = (split) ? (lfs_size_t)-1 : bshrub->shrub.eoff; + lfs3_ssize_t estimate = (split) ? (lfs3_size_t)-1 : bshrub->shrub.eoff; // this double condition avoids overflow issues - if ((lfs_size_t)estimate > lfs->cfg->inline_size - || estimate + commit_estimate > lfs->cfg->inline_size) { - estimate = lfsr_bshrub_estimate(lfs, bshrub); + if ((lfs3_size_t)estimate > lfs3->cfg->inline_size + || estimate + commit_estimate > lfs3->cfg->inline_size) { + estimate = lfs3_bshrub_estimate(lfs3, bshrub); if (estimate < 0) { return estimate; } @@ -6437,9 +6439,9 @@ static int lfsr_bshrub_commitroot_(lfs_t *lfs, lfsr_bshrub_t *bshrub, // near full, but it's a heuristic, so including the commit would // just be mean // - if ((lfs_size_t)estimate > lfs->cfg->inline_size/2 - || estimate + commit_estimate > lfs->cfg->inline_size) { - return LFS_ERR_RANGE; + if ((lfs3_size_t)estimate > lfs3->cfg->inline_size/2 + || estimate + commit_estimate > lfs3->cfg->inline_size) { + return LFS3_ERR_RANGE; } } @@ -6447,9 +6449,9 @@ static int lfsr_bshrub_commitroot_(lfs_t *lfs, lfsr_bshrub_t *bshrub, estimate += commit_estimate; // commit to shrub - int err = lfsr_mdir_commit(lfs, &bshrub->o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUBCOMMIT( - (&(lfsr_shrubcommit_t){ + int err = lfs3_mdir_commit(lfs3, &bshrub->o.mdir, LFS3_RATTRS( + LFS3_RATTR_SHRUBCOMMIT( + (&(lfs3_shrubcommit_t){ .bshrub=bshrub, .rid=bid, .rattrs=rattrs, @@ -6457,61 +6459,61 @@ static int lfsr_bshrub_commitroot_(lfs_t *lfs, lfsr_bshrub_t *bshrub, if (err) { return err; } - LFS_ASSERT(bshrub->shrub.blocks[0] == bshrub->o.mdir.rbyd.blocks[0]); + LFS3_ASSERT(bshrub->shrub.blocks[0] == bshrub->o.mdir.rbyd.blocks[0]); // update _all_ shrubs with the new estimate - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) && o->mdir.mid == bshrub->o.mdir.mid - && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)) { - ((lfsr_bshrub_t*)o)->shrub.eoff = estimate; + && lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o)) { + ((lfs3_bshrub_t*)o)->shrub.eoff = estimate; } } - LFS_ASSERT(bshrub->shrub.eoff == (lfs_size_t)estimate); + LFS3_ASSERT(bshrub->shrub.eoff == (lfs3_size_t)estimate); return 0; } // commit to 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) { +static int lfs3_bshrub_commit(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, + lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // before we touch anything, we need to mark all other btree references // as unerased - if (lfsr_bshrub_isbtree(bshrub)) { - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) + if (lfs3_bshrub_isbtree(bshrub)) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) && o != &bshrub->o - && ((lfsr_bshrub_t*)o)->shrub.blocks[0] + && ((lfs3_bshrub_t*)o)->shrub.blocks[0] == bshrub->shrub.blocks[0]) { // mark as unerased - lfsr_btree_claim(&((lfsr_bshrub_t*)o)->shrub); + lfs3_btree_claim(&((lfs3_bshrub_t*)o)->shrub); } } } // try to commit to the btree - lfsr_bctx_t bctx; - int err = lfsr_btree_commit_(lfs, &bshrub->shrub, &bctx, + lfs3_bctx_t bctx; + int err = lfs3_btree_commit_(lfs3, &bshrub->shrub, &bctx, &bid, &rattrs, &rattr_count); - if (err && err != LFS_ERR_RANGE) { + if (err && err != LFS3_ERR_RANGE) { return err; } - LFS_ASSERT(!err || rattr_count > 0); - bool split = (err == LFS_ERR_RANGE); + LFS3_ASSERT(!err || rattr_count > 0); + bool split = (err == LFS3_ERR_RANGE); - // when btree is shrubbed, lfsr_btree_commit_ stops at the root + // when btree is shrubbed, lfs3_btree_commit_ stops at the root // and returns with pending rattrs if (rattr_count > 0) { // try to commit to shrub root - err = lfsr_bshrub_commitroot_(lfs, bshrub, split, + err = lfs3_bshrub_commitroot_(lfs3, bshrub, split, bid, rattrs, rattr_count); - if (err && err != LFS_ERR_RANGE) { + if (err && err != LFS3_ERR_RANGE) { return err; } // if we don't fit, convert to btree - if (err == LFS_ERR_RANGE) { - err = lfsr_btree_commitroot_(lfs, &bshrub->shrub, split, + if (err == LFS3_ERR_RANGE) { + err = lfs3_btree_commitroot_(lfs3, &bshrub->shrub, split, bid, rattrs, rattr_count); if (err) { return err; @@ -6519,18 +6521,18 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub, } } - LFS_ASSERT(lfsr_shrub_trunk(&bshrub->shrub)); - #ifdef LFS_DBGBTREECOMMITS - if (lfsr_bshrub_isbshrub(bshrub)) { - LFS_DEBUG("Committed bshrub " + LFS3_ASSERT(lfs3_shrub_trunk(&bshrub->shrub)); + #ifdef LFS3_DBGBTREECOMMITS + if (lfs3_bshrub_isbshrub(bshrub)) { + LFS3_DEBUG("Committed bshrub " "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32, bshrub->o.mdir.rbyd.blocks[0], bshrub->o.mdir.rbyd.blocks[1], - lfsr_shrub_trunk(&bshrub->shrub), + lfs3_shrub_trunk(&bshrub->shrub), bshrub->shrub.weight); } else { - LFS_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", " + LFS3_DEBUG("Committed btree 0x%"PRIx32".%"PRIx32" w%"PRId32", " "cksum %"PRIx32, - bshrub->shrub.blocks[0], lfsr_shrub_trunk(&bshrub->shrub), + bshrub->shrub.blocks[0], lfs3_shrub_trunk(&bshrub->shrub), bshrub->shrub.weight, bshrub->shrub.cksum); } @@ -6543,79 +6545,79 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_bshrub_t *bshrub, /// metadata-id things /// -#define LFSR_MID(_lfs, _bid, _rid) \ +#define LFS3_MID(_lfs, _bid, _rid) \ (((_bid) & ~((1 << (_lfs)->mbits)-1)) + (_rid)) -static inline lfsr_sbid_t lfsr_mbid(const lfs_t *lfs, lfsr_smid_t mid) { - return mid | ((1 << lfs->mbits) - 1); +static inline lfs3_sbid_t lfs3_mbid(const lfs3_t *lfs3, lfs3_smid_t mid) { + return mid | ((1 << lfs3->mbits) - 1); } -static inline lfsr_srid_t lfsr_mrid(const lfs_t *lfs, lfsr_smid_t mid) { +static inline lfs3_srid_t lfs3_mrid(const lfs3_t *lfs3, lfs3_smid_t mid) { // bit of a strange mapping, but we want to preserve mid=-1 => rid=-1 - return (mid >> (8*sizeof(lfsr_smid_t)-1)) - | (mid & ((1 << lfs->mbits) - 1)); + return (mid >> (8*sizeof(lfs3_smid_t)-1)) + | (mid & ((1 << lfs3->mbits) - 1)); } // these should only be used for logging -static inline lfsr_sbid_t lfsr_dbgmbid(const lfs_t *lfs, lfsr_smid_t mid) { - if (lfs->mtree.weight == 0) { +static inline lfs3_sbid_t lfs3_dbgmbid(const lfs3_t *lfs3, lfs3_smid_t mid) { + if (lfs3->mtree.weight == 0) { return -1; } else { - return mid >> lfs->mbits; + return mid >> lfs3->mbits; } } -static inline lfsr_srid_t lfsr_dbgmrid(const lfs_t *lfs, lfsr_smid_t mid) { - return lfsr_mrid(lfs, mid); +static inline lfs3_srid_t lfs3_dbgmrid(const lfs3_t *lfs3, lfs3_smid_t mid) { + return lfs3_mrid(lfs3, mid); } /// metadata-pointer things /// // the mroot anchor, mdir 0x{0,1} is the entry point into the filesystem -#define LFSR_MPTR_MROOTANCHOR() ((const lfs_block_t[2]){0, 1}) +#define LFS3_MPTR_MROOTANCHOR() ((const lfs3_block_t[2]){0, 1}) -static inline int lfsr_mptr_cmp( - const lfs_block_t a[static 2], - const lfs_block_t b[static 2]) { +static inline int lfs3_mptr_cmp( + const lfs3_block_t a[static 2], + const lfs3_block_t b[static 2]) { // note these can be in either order - if (lfs_max(a[0], a[1]) != lfs_max(b[0], b[1])) { - return lfs_max(a[0], a[1]) - lfs_max(b[0], b[1]); + if (lfs3_max(a[0], a[1]) != lfs3_max(b[0], b[1])) { + return lfs3_max(a[0], a[1]) - lfs3_max(b[0], b[1]); } else { - return lfs_min(a[0], a[1]) - lfs_min(b[0], b[1]); + return lfs3_min(a[0], a[1]) - lfs3_min(b[0], b[1]); } } -static inline bool lfsr_mptr_ismrootanchor( - const lfs_block_t mptr[static 2]) { +static inline bool lfs3_mptr_ismrootanchor( + const lfs3_block_t mptr[static 2]) { // mrootanchor is always at 0x{0,1} // just check that the first block is in mroot anchor range return mptr[0] <= 1; } // mptr on-disk encoding -static lfsr_data_t lfsr_data_frommptr(const lfs_block_t mptr[static 2], - uint8_t buffer[static LFSR_MPTR_DSIZE]) { +static lfs3_data_t lfs3_data_frommptr(const lfs3_block_t mptr[static 2], + uint8_t buffer[static LFS3_MPTR_DSIZE]) { // blocks should not exceed 31-bits - LFS_ASSERT(mptr[0] <= 0x7fffffff); - LFS_ASSERT(mptr[1] <= 0x7fffffff); + LFS3_ASSERT(mptr[0] <= 0x7fffffff); + LFS3_ASSERT(mptr[1] <= 0x7fffffff); - lfs_ssize_t d = 0; + lfs3_ssize_t d = 0; for (int i = 0; i < 2; i++) { - lfs_ssize_t d_ = lfs_toleb128(mptr[i], &buffer[d], 5); + lfs3_ssize_t d_ = lfs3_toleb128(mptr[i], &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; } - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readmptr(lfs_t *lfs, lfsr_data_t *data, - lfs_block_t mptr[static 2]) { +static int lfs3_data_readmptr(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_block_t mptr[static 2]) { for (int i = 0; i < 2; i++) { - int err = lfsr_data_readleb128(lfs, data, &mptr[i]); + int err = lfs3_data_readleb128(lfs3, data, &mptr[i]); if (err) { return err; } @@ -6629,241 +6631,241 @@ static int lfsr_data_readmptr(lfs_t *lfs, lfsr_data_t *data, /// various flag things /// // open flags -static inline bool lfsr_o_isrdonly(uint32_t flags) { - return (flags & LFS_O_MODE) == LFS_O_RDONLY; +static inline bool lfs3_o_isrdonly(uint32_t flags) { + return (flags & LFS3_O_MODE) == LFS3_O_RDONLY; } -static inline bool lfsr_o_iswronly(uint32_t flags) { - return (flags & LFS_O_MODE) == LFS_O_WRONLY; +static inline bool lfs3_o_iswronly(uint32_t flags) { + return (flags & LFS3_O_MODE) == LFS3_O_WRONLY; } -static inline bool lfsr_o_iscreat(uint32_t flags) { - return flags & LFS_O_CREAT; +static inline bool lfs3_o_iscreat(uint32_t flags) { + return flags & LFS3_O_CREAT; } -static inline bool lfsr_o_isexcl(uint32_t flags) { - return flags & LFS_O_EXCL; +static inline bool lfs3_o_isexcl(uint32_t flags) { + return flags & LFS3_O_EXCL; } -static inline bool lfsr_o_istrunc(uint32_t flags) { - return flags & LFS_O_TRUNC; +static inline bool lfs3_o_istrunc(uint32_t flags) { + return flags & LFS3_O_TRUNC; } -static inline bool lfsr_o_isappend(uint32_t flags) { - return flags & LFS_O_APPEND; +static inline bool lfs3_o_isappend(uint32_t flags) { + return flags & LFS3_O_APPEND; } -static inline bool lfsr_o_isflush(uint32_t flags) { +static inline bool lfs3_o_isflush(uint32_t flags) { (void)flags; - #ifdef LFS_YES_FLUSH + #ifdef LFS3_YES_FLUSH return true; #else - return flags & LFS_O_FLUSH; + return flags & LFS3_O_FLUSH; #endif } -static inline bool lfsr_o_issync(uint32_t flags) { +static inline bool lfs3_o_issync(uint32_t flags) { (void)flags; - #ifdef LFS_YES_SYNC + #ifdef LFS3_YES_SYNC return true; #else - return flags & LFS_O_SYNC; + return flags & LFS3_O_SYNC; #endif } -static inline bool lfsr_o_isdesync(uint32_t flags) { - return flags & LFS_O_DESYNC; +static inline bool lfs3_o_isdesync(uint32_t flags) { + return flags & LFS3_O_DESYNC; } // internal open flags -static inline uint8_t lfsr_o_type(uint32_t flags) { +static inline uint8_t lfs3_o_type(uint32_t flags) { return flags >> 28; } -static inline uint32_t lfsr_o_typeflags(uint8_t type) { +static inline uint32_t lfs3_o_typeflags(uint8_t type) { return (uint32_t)type << 28; } -static inline void lfsr_o_settype(uint32_t *flags, uint8_t type) { - *flags = (*flags & ~LFS_o_TYPE) | lfsr_o_typeflags(type); +static inline void lfs3_o_settype(uint32_t *flags, uint8_t type) { + *flags = (*flags & ~LFS3_o_TYPE) | lfs3_o_typeflags(type); } -static inline bool lfsr_o_isbshrub(uint32_t flags) { - return lfsr_o_type(flags) == LFS_TYPE_REG - || lfsr_o_type(flags) == LFS_type_TRAVERSAL; +static inline bool lfs3_o_isbshrub(uint32_t flags) { + return lfs3_o_type(flags) == LFS3_TYPE_REG + || lfs3_o_type(flags) == LFS3_type_TRAVERSAL; } -static inline bool lfsr_o_iszombie(uint32_t flags) { - return flags & LFS_o_ZOMBIE; +static inline bool lfs3_o_iszombie(uint32_t flags) { + return flags & LFS3_o_ZOMBIE; } -static inline bool lfsr_o_isuncreat(uint32_t flags) { - return flags & LFS_o_UNCREAT; +static inline bool lfs3_o_isuncreat(uint32_t flags) { + return flags & LFS3_o_UNCREAT; } -static inline bool lfsr_o_isunsync(uint32_t flags) { - return flags & LFS_o_UNSYNC; +static inline bool lfs3_o_isunsync(uint32_t flags) { + return flags & LFS3_o_UNSYNC; } -static inline bool lfsr_o_isuncryst(uint32_t flags) { - return flags & LFS_o_UNCRYST; +static inline bool lfs3_o_isuncryst(uint32_t flags) { + return flags & LFS3_o_UNCRYST; } -static inline bool lfsr_o_isungraft(uint32_t flags) { - return flags & LFS_o_UNGRAFT; +static inline bool lfs3_o_isungraft(uint32_t flags) { + return flags & LFS3_o_UNGRAFT; } -static inline bool lfsr_o_isunflush(uint32_t flags) { - return flags & LFS_o_UNFLUSH; +static inline bool lfs3_o_isunflush(uint32_t flags) { + return flags & LFS3_o_UNFLUSH; } // custom attr flags -static inline bool lfsr_a_islazy(uint32_t flags) { - return flags & LFS_A_LAZY; +static inline bool lfs3_a_islazy(uint32_t flags) { + return flags & LFS3_A_LAZY; } // traversal flags -static inline bool lfsr_t_isrdonly(uint32_t flags) { - return flags & LFS_T_RDONLY; +static inline bool lfs3_t_isrdonly(uint32_t flags) { + return flags & LFS3_T_RDONLY; } -static inline bool lfsr_t_ismtreeonly(uint32_t flags) { - return flags & LFS_T_MTREEONLY; +static inline bool lfs3_t_ismtreeonly(uint32_t flags) { + return flags & LFS3_T_MTREEONLY; } -static inline bool lfsr_t_ismkconsistent(uint32_t flags) { - return flags & LFS_T_MKCONSISTENT; +static inline bool lfs3_t_ismkconsistent(uint32_t flags) { + return flags & LFS3_T_MKCONSISTENT; } -static inline bool lfsr_t_islookahead(uint32_t flags) { - return flags & LFS_T_LOOKAHEAD; +static inline bool lfs3_t_islookahead(uint32_t flags) { + return flags & LFS3_T_LOOKAHEAD; } -static inline bool lfsr_t_iscompact(uint32_t flags) { - return flags & LFS_T_COMPACT; +static inline bool lfs3_t_iscompact(uint32_t flags) { + return flags & LFS3_T_COMPACT; } -static inline bool lfsr_t_isckmeta(uint32_t flags) { - return flags & LFS_T_CKMETA; +static inline bool lfs3_t_isckmeta(uint32_t flags) { + return flags & LFS3_T_CKMETA; } -static inline bool lfsr_t_isckdata(uint32_t flags) { - return flags & LFS_T_CKDATA; +static inline bool lfs3_t_isckdata(uint32_t flags) { + return flags & LFS3_T_CKDATA; } // internal traversal flags -static inline uint8_t lfsr_t_tstate(uint32_t flags) { +static inline uint8_t lfs3_t_tstate(uint32_t flags) { return (flags >> 16) & 0xf; } -static inline uint32_t lfsr_t_tstateflags(uint8_t tstate) { +static inline uint32_t lfs3_t_tstateflags(uint8_t tstate) { return (uint32_t)tstate << 16; } -static inline void lfsr_t_settstate(uint32_t *flags, uint8_t tstate) { - *flags = (*flags & ~LFS_t_TSTATE) | lfsr_t_tstateflags(tstate); +static inline void lfs3_t_settstate(uint32_t *flags, uint8_t tstate) { + *flags = (*flags & ~LFS3_t_TSTATE) | lfs3_t_tstateflags(tstate); } -static inline uint8_t lfsr_t_btype(uint32_t flags) { +static inline uint8_t lfs3_t_btype(uint32_t flags) { return (flags >> 20) & 0x0f; } -static inline uint32_t lfsr_t_btypeflags(uint8_t btype) { +static inline uint32_t lfs3_t_btypeflags(uint8_t btype) { return (uint32_t)btype << 20; } -static inline void lfsr_t_setbtype(uint32_t *flags, uint8_t btype) { - *flags = (*flags & ~LFS_t_BTYPE) | lfsr_t_btypeflags(btype); +static inline void lfs3_t_setbtype(uint32_t *flags, uint8_t btype) { + *flags = (*flags & ~LFS3_t_BTYPE) | lfs3_t_btypeflags(btype); } -static inline bool lfsr_t_isdirty(uint32_t flags) { - return flags & LFS_t_DIRTY; +static inline bool lfs3_t_isdirty(uint32_t flags) { + return flags & LFS3_t_DIRTY; } -static inline bool lfsr_t_ismutated(uint32_t flags) { - return flags & LFS_t_MUTATED; +static inline bool lfs3_t_ismutated(uint32_t flags) { + return flags & LFS3_t_MUTATED; } -static inline uint32_t lfsr_t_swapdirty(uint32_t flags) { +static inline uint32_t lfs3_t_swapdirty(uint32_t flags) { uint32_t x = ((flags >> 24) ^ (flags >> 25)) & 0x1; return flags ^ (x << 24) ^ (x << 25); } // mount flags -static inline bool lfsr_m_isrdonly(uint32_t flags) { - return flags & LFS_M_RDONLY; +static inline bool lfs3_m_isrdonly(uint32_t flags) { + return flags & LFS3_M_RDONLY; } -#ifdef LFS_REVDBG -static inline bool lfsr_m_isrevdbg(uint32_t flags) { +#ifdef LFS3_REVDBG +static inline bool lfs3_m_isrevdbg(uint32_t flags) { (void)flags; - #ifdef LFS_YES_REVDBG + #ifdef LFS3_YES_REVDBG return true; #else - return flags & LFS_M_REVDBG; + return flags & LFS3_M_REVDBG; #endif } #endif -#ifdef LFS_REVNOISE -static inline bool lfsr_m_isrevnoise(uint32_t flags) { +#ifdef LFS3_REVNOISE +static inline bool lfs3_m_isrevnoise(uint32_t flags) { (void)flags; - #ifdef LFS_YES_REVNOISE + #ifdef LFS3_YES_REVNOISE return true; #else - return flags & LFS_M_REVNOISE; + return flags & LFS3_M_REVNOISE; #endif } #endif -#ifdef LFS_CKPROGS -static inline bool lfsr_m_isckprogs(uint32_t flags) { +#ifdef LFS3_CKPROGS +static inline bool lfs3_m_isckprogs(uint32_t flags) { (void)flags; - #ifdef LFS_YES_CKPROGS + #ifdef LFS3_YES_CKPROGS return true; #else - return flags & LFS_M_CKPROGS; + return flags & LFS3_M_CKPROGS; #endif } #endif -#ifdef LFS_CKFETCHES -static inline bool lfsr_m_isckfetches(uint32_t flags) { +#ifdef LFS3_CKFETCHES +static inline bool lfs3_m_isckfetches(uint32_t flags) { (void)flags; - #ifdef LFS_YES_CKFETCHES + #ifdef LFS3_YES_CKFETCHES return true; #else - return flags & LFS_M_CKFETCHES; + return flags & LFS3_M_CKFETCHES; #endif } #endif -#ifdef LFS_CKMETAPARITY -static inline bool lfsr_m_isckparity(uint32_t flags) { +#ifdef LFS3_CKMETAPARITY +static inline bool lfs3_m_isckparity(uint32_t flags) { (void)flags; - #ifdef LFS_YES_CKMETAPARITY + #ifdef LFS3_YES_CKMETAPARITY return true; #else - return flags & LFS_M_CKMETAPARITY; + return flags & LFS3_M_CKMETAPARITY; #endif } #endif -#ifdef LFS_CKDATACKSUMREADS -static inline bool lfsr_m_isckdatacksums(uint32_t flags) { +#ifdef LFS3_CKDATACKSUMREADS +static inline bool lfs3_m_isckdatacksums(uint32_t flags) { (void)flags; - #ifdef LFS_YES_CKDATACKSUMREADS + #ifdef LFS3_YES_CKDATACKSUMREADS return true; #else - return flags & LFS_M_CKDATACKSUMREADS; + return flags & LFS3_M_CKDATACKSUMREADS; #endif } #endif // other internal flags -#ifdef LFS_REVDBG -static inline bool lfsr_i_isinmtree(uint32_t flags) { - return flags & LFS_i_INMTREE; +#ifdef LFS3_REVDBG +static inline bool lfs3_i_isinmtree(uint32_t flags) { + return flags & LFS3_i_INMTREE; } #endif @@ -6874,8 +6876,8 @@ static inline bool lfsr_i_isinmtree(uint32_t flags) { // we maintain a linked-list of all opened mdirs, in order to keep // metadata state in-sync, these may be casted to specific file types -static bool lfsr_omdir_isopen(const lfs_t *lfs, const lfsr_omdir_t *o) { - for (lfsr_omdir_t *o_ = lfs->omdirs; o_; o_ = o_->next) { +static bool lfs3_omdir_isopen(const lfs3_t *lfs3, const lfs3_omdir_t *o) { + for (lfs3_omdir_t *o_ = lfs3->omdirs; o_; o_ = o_->next) { if (o_ == o) { return true; } @@ -6884,24 +6886,24 @@ static bool lfsr_omdir_isopen(const lfs_t *lfs, const lfsr_omdir_t *o) { return false; } -static void lfsr_omdir_open(lfs_t *lfs, lfsr_omdir_t *o) { - LFS_ASSERT(!lfsr_omdir_isopen(lfs, o)); +static void lfs3_omdir_open(lfs3_t *lfs3, lfs3_omdir_t *o) { + LFS3_ASSERT(!lfs3_omdir_isopen(lfs3, o)); // add to opened list - o->next = lfs->omdirs; - lfs->omdirs = o; + o->next = lfs3->omdirs; + lfs3->omdirs = o; } -// needed in lfsr_omdir_close -static void lfsr_omdir_clobber(lfs_t *lfs, const lfsr_omdir_t *o, +// needed in lfs3_omdir_close +static void lfs3_omdir_clobber(lfs3_t *lfs3, const lfs3_omdir_t *o, uint32_t flags); -static void lfsr_omdir_close(lfs_t *lfs, lfsr_omdir_t *o) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, o)); +static void lfs3_omdir_close(lfs3_t *lfs3, lfs3_omdir_t *o) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, o)); // make sure we're not entangled in any traversals, note we don't // set the dirty bit here - lfsr_omdir_clobber(lfs, o, 0); + lfs3_omdir_clobber(lfs3, o, 0); // remove from opened list - for (lfsr_omdir_t **o_ = &lfs->omdirs; *o_; o_ = &(*o_)->next) { + for (lfs3_omdir_t **o_ = &lfs3->omdirs; *o_; o_ = &(*o_)->next) { if (*o_ == o) { *o_ = (*o_)->next; break; @@ -6910,12 +6912,12 @@ static void lfsr_omdir_close(lfs_t *lfs, lfsr_omdir_t *o) { } // check if a given mid is open -static bool lfsr_omdir_ismidopen(const lfs_t *lfs, - lfsr_smid_t mid, uint32_t mask) { - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { +static bool lfs3_omdir_ismidopen(const lfs3_t *lfs3, + lfs3_smid_t mid, uint32_t mask) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // we really only care about regular open files here, all // others are either transient (dirs) or fake (orphans) - if (lfsr_o_type(o->flags) == LFS_TYPE_REG + if (lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == mid // allow caller to ignore files with specific flags && !(o->flags & ~mask)) { @@ -6928,26 +6930,26 @@ static bool lfsr_omdir_ismidopen(const lfs_t *lfs, // traversal invalidation things -// needed in lfsr_omdir_clobber -static void lfsr_traversal_clobber(lfs_t *lfs, lfsr_traversal_t *t); +// needed in lfs3_omdir_clobber +static void lfs3_traversal_clobber(lfs3_t *lfs3, lfs3_traversal_t *t); // clobber any traversals referencing our mdir -static void lfsr_omdir_clobber(lfs_t *lfs, const lfsr_omdir_t *o, +static void lfs3_omdir_clobber(lfs3_t *lfs3, const lfs3_omdir_t *o, uint32_t flags) { - for (lfsr_omdir_t *o_ = lfs->omdirs; o_; o_ = o_->next) { - if (lfsr_o_type(o_->flags) == LFS_type_TRAVERSAL) { + for (lfs3_omdir_t *o_ = lfs3->omdirs; o_; o_ = o_->next) { + if (lfs3_o_type(o_->flags) == LFS3_type_TRAVERSAL) { o_->flags |= flags; - if (o && ((lfsr_traversal_t*)o_)->ot == o) { - lfsr_traversal_clobber(lfs, (lfsr_traversal_t*)o_); + if (o && ((lfs3_traversal_t*)o_)->ot == o) { + lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)o_); } } } } // clobber all traversals -static void lfsr_fs_clobber(lfs_t *lfs, uint32_t flags) { - lfsr_omdir_clobber(lfs, NULL, flags); +static void lfs3_fs_clobber(lfs3_t *lfs3, uint32_t flags) { + lfs3_omdir_clobber(lfs3, NULL, flags); } @@ -6955,67 +6957,67 @@ static void lfsr_fs_clobber(lfs_t *lfs, uint32_t flags) { /// Global-state things /// // grm (global remove) things -static inline lfs_size_t lfsr_grm_count(const lfs_t *lfs) { - return (lfs->grm.queue[0] != 0) + (lfs->grm.queue[1] != 0); +static inline lfs3_size_t lfs3_grm_count(const lfs3_t *lfs3) { + return (lfs3->grm.queue[0] != 0) + (lfs3->grm.queue[1] != 0); } -static inline void lfsr_grm_push(lfs_t *lfs, lfsr_smid_t mid) { +static inline void lfs3_grm_push(lfs3_t *lfs3, lfs3_smid_t mid) { // note mid=0.0 always maps to the root bookmark and should never // be grmed - LFS_ASSERT(mid != 0); - LFS_ASSERT(lfs->grm.queue[1] == 0); - lfs->grm.queue[1] = lfs->grm.queue[0]; - lfs->grm.queue[0] = mid; + LFS3_ASSERT(mid != 0); + LFS3_ASSERT(lfs3->grm.queue[1] == 0); + lfs3->grm.queue[1] = lfs3->grm.queue[0]; + lfs3->grm.queue[0] = mid; } -static inline lfsr_smid_t lfsr_grm_pop(lfs_t *lfs) { - lfsr_smid_t mid = lfs->grm.queue[0]; - lfs->grm.queue[0] = lfs->grm.queue[1]; - lfs->grm.queue[1] = 0; +static inline lfs3_smid_t lfs3_grm_pop(lfs3_t *lfs3) { + lfs3_smid_t mid = lfs3->grm.queue[0]; + lfs3->grm.queue[0] = lfs3->grm.queue[1]; + lfs3->grm.queue[1] = 0; return mid; } -static inline bool lfsr_grm_ismidrm(const lfs_t *lfs, lfsr_smid_t mid) { +static inline bool lfs3_grm_ismidrm(const lfs3_t *lfs3, lfs3_smid_t mid) { return mid != 0 - && (lfs->grm.queue[0] == mid - || lfs->grm.queue[1] == mid); + && (lfs3->grm.queue[0] == mid + || lfs3->grm.queue[1] == mid); } -#define LFSR_DATA_GRM(_grm, _buffer) \ - ((struct {lfsr_data_t d;}){lfsr_data_fromgrm(_grm, _buffer)}.d) +#define LFS3_DATA_GRM(_grm, _buffer) \ + ((struct {lfs3_data_t d;}){lfs3_data_fromgrm(_grm, _buffer)}.d) -static lfsr_data_t lfsr_data_fromgrm(const lfs_t *lfs, - uint8_t buffer[static LFSR_GRM_DSIZE]) { +static lfs3_data_t lfs3_data_fromgrm(const lfs3_t *lfs3, + uint8_t buffer[static LFS3_GRM_DSIZE]) { // make sure to zero so we don't leak any info - lfs_memset(buffer, 0, LFSR_GRM_DSIZE); + lfs3_memset(buffer, 0, LFS3_GRM_DSIZE); // encode grms - lfs_size_t count = lfsr_grm_count(lfs); - lfs_ssize_t d = 0; - for (lfs_size_t i = 0; i < count; i++) { - lfs_ssize_t d_ = lfs_toleb128(lfs->grm.queue[i], &buffer[d], 5); + lfs3_size_t count = lfs3_grm_count(lfs3); + lfs3_ssize_t d = 0; + for (lfs3_size_t i = 0; i < count; i++) { + lfs3_ssize_t d_ = lfs3_toleb128(lfs3->grm.queue[i], &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; } - return LFSR_DATA_BUF(buffer, lfs_memlen(buffer, LFSR_GRM_DSIZE)); + return LFS3_DATA_BUF(buffer, lfs3_memlen(buffer, LFS3_GRM_DSIZE)); } -// required by lfsr_data_readgrm -static inline lfsr_mid_t lfsr_mtree_weight(lfs_t *lfs); +// required by lfs3_data_readgrm +static inline lfs3_mid_t lfs3_mtree_weight(lfs3_t *lfs3); -static int lfsr_data_readgrm(lfs_t *lfs, lfsr_data_t *data) { +static int lfs3_data_readgrm(lfs3_t *lfs3, lfs3_data_t *data) { // clear first - lfs->grm.queue[0] = 0; - lfs->grm.queue[1] = 0; + lfs3->grm.queue[0] = 0; + lfs3->grm.queue[1] = 0; // decode grms, these are terminated by either a null (mid=0) or the // size of the grm buffer - for (lfs_size_t i = 0; i < 2; i++) { - lfsr_mid_t mid; - int err = lfsr_data_readleb128(lfs, data, &mid); + for (lfs3_size_t i = 0; i < 2; i++) { + lfs3_mid_t mid; + int err = lfs3_data_readleb128(lfs3, data, &mid); if (err) { return err; } @@ -7026,8 +7028,8 @@ static int lfsr_data_readgrm(lfs_t *lfs, lfsr_data_t *data) { } // grm inside mtree? - LFS_ASSERT(mid < lfsr_mtree_weight(lfs)); - lfs->grm.queue[i] = mid; + LFS3_ASSERT(mid < lfs3_mtree_weight(lfs3)); + lfs3->grm.queue[i] = mid; } return 0; @@ -7037,75 +7039,75 @@ static int lfsr_data_readgrm(lfs_t *lfs, lfsr_data_t *data) { // some mdir-related gstate things we need // zero any pending gdeltas -static void lfsr_fs_flushgdelta(lfs_t *lfs) { +static void lfs3_fs_flushgdelta(lfs3_t *lfs3) { // zero the gcksumdelta - lfs->gcksum_d = 0; + lfs3->gcksum_d = 0; // zero the grmdelta - lfs_memset(lfs->grm_d, 0, LFSR_GRM_DSIZE); + lfs3_memset(lfs3->grm_d, 0, LFS3_GRM_DSIZE); } // commit any pending gdeltas -static void lfsr_fs_commitgdelta(lfs_t *lfs) { +static void lfs3_fs_commitgdelta(lfs3_t *lfs3) { // keep track of the on-disk gcksum - lfs->gcksum_p = lfs->gcksum; + lfs3->gcksum_p = lfs3->gcksum; // keep track of the on-disk grm - lfsr_data_fromgrm(lfs, lfs->grm_p); + lfs3_data_fromgrm(lfs3, lfs3->grm_p); } // revert gstate to on-disk state -static void lfsr_fs_revertgdelta(lfs_t *lfs) { +static void lfs3_fs_revertgdelta(lfs3_t *lfs3) { // revert to the on-disk gcksum - lfs->gcksum = lfs->gcksum_p; + lfs3->gcksum = lfs3->gcksum_p; // revert to the on-disk grm - int err = lfsr_data_readgrm(lfs, - &LFSR_DATA_BUF(lfs->grm_p, LFSR_GRM_DSIZE)); + int err = lfs3_data_readgrm(lfs3, + &LFS3_DATA_BUF(lfs3->grm_p, LFS3_GRM_DSIZE)); if (err) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } // append and consume any pending gstate -static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) { +static int lfs3_rbyd_appendgdelta(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { // note gcksums are a special case and handled directly in - // lfsr_mdir_commit__/lfsr_rbyd_appendcksum_ + // lfs3_mdir_commit__/lfs3_rbyd_appendcksum_ // pending grm state? - uint8_t grmdelta_[LFSR_GRM_DSIZE]; - lfsr_data_fromgrm(lfs, grmdelta_); - lfs_memxor(grmdelta_, lfs->grm_p, LFSR_GRM_DSIZE); - lfs_memxor(grmdelta_, lfs->grm_d, LFSR_GRM_DSIZE); + uint8_t grmdelta_[LFS3_GRM_DSIZE]; + lfs3_data_fromgrm(lfs3, grmdelta_); + lfs3_memxor(grmdelta_, lfs3->grm_p, LFS3_GRM_DSIZE); + lfs3_memxor(grmdelta_, lfs3->grm_d, LFS3_GRM_DSIZE); - if (lfs_memlen(grmdelta_, LFSR_GRM_DSIZE) != 0) { + if (lfs3_memlen(grmdelta_, LFS3_GRM_DSIZE) != 0) { // make sure to xor any existing delta - lfsr_data_t data; - int err = lfsr_rbyd_lookup(lfs, rbyd, -1, LFSR_TAG_GRMDELTA, + lfs3_data_t data; + int err = lfs3_rbyd_lookup(lfs3, rbyd, -1, LFS3_TAG_GRMDELTA, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - uint8_t grmdelta[LFSR_GRM_DSIZE]; - lfs_memset(grmdelta, 0, LFSR_GRM_DSIZE); - if (err != LFS_ERR_NOENT) { - lfs_ssize_t d = lfsr_data_read(lfs, &data, - grmdelta, LFSR_GRM_DSIZE); + uint8_t grmdelta[LFS3_GRM_DSIZE]; + lfs3_memset(grmdelta, 0, LFS3_GRM_DSIZE); + if (err != LFS3_ERR_NOENT) { + lfs3_ssize_t d = lfs3_data_read(lfs3, &data, + grmdelta, LFS3_GRM_DSIZE); if (d < 0) { return d; } } - lfs_memxor(grmdelta_, grmdelta, LFSR_GRM_DSIZE); + lfs3_memxor(grmdelta_, grmdelta, LFS3_GRM_DSIZE); // append to our rbyd, replacing any existing delta - lfs_size_t size = lfs_memlen(grmdelta_, LFSR_GRM_DSIZE); - err = lfsr_rbyd_appendrattr(lfs, rbyd, -1, LFSR_RATTR_BUF( + lfs3_size_t size = lfs3_memlen(grmdelta_, LFS3_GRM_DSIZE); + err = lfs3_rbyd_appendrattr(lfs3, rbyd, -1, LFS3_RATTR_BUF( // opportunistically remove this tag if delta is all zero (size == 0) - ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA - : LFSR_TAG_GRMDELTA, 0, + ? LFS3_TAG_RM | LFS3_TAG_GRMDELTA + : LFS3_TAG_GRMDELTA, 0, grmdelta_, size)); if (err) { return err; @@ -7115,26 +7117,26 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) { return 0; } -static int lfsr_fs_consumegdelta(lfs_t *lfs, const lfsr_mdir_t *mdir) { +static int lfs3_fs_consumegdelta(lfs3_t *lfs3, const lfs3_mdir_t *mdir) { // consume any gcksum deltas - lfs->gcksum_d ^= mdir->gcksumdelta; + lfs3->gcksum_d ^= mdir->gcksumdelta; // consume any grm deltas - lfsr_data_t data; - int err = lfsr_rbyd_lookup(lfs, &mdir->rbyd, -1, LFSR_TAG_GRMDELTA, + lfs3_data_t data; + int err = lfs3_rbyd_lookup(lfs3, &mdir->rbyd, -1, LFS3_TAG_GRMDELTA, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - uint8_t grmdelta[LFSR_GRM_DSIZE]; - lfs_ssize_t d = lfsr_data_read(lfs, &data, grmdelta, LFSR_GRM_DSIZE); + if (err != LFS3_ERR_NOENT) { + uint8_t grmdelta[LFS3_GRM_DSIZE]; + lfs3_ssize_t d = lfs3_data_read(lfs3, &data, grmdelta, LFS3_GRM_DSIZE); if (d < 0) { return d; } - lfs_memxor(lfs->grm_d, grmdelta, d); + lfs3_memxor(lfs3->grm_d, grmdelta, d); } return 0; @@ -7163,23 +7165,23 @@ static int lfsr_fs_consumegdelta(lfs_t *lfs, const lfsr_mdir_t *mdir) { // vvvv---- -111111- -11-11-1 -11---1- (62 6d 7e v0 bm~.) mtree node // -// needed in lfsr_rev_init -static inline bool lfsr_mdir_ismrootanchor(const lfsr_mdir_t *mdir); -static inline int lfsr_mdir_cmp(const lfsr_mdir_t *a, const lfsr_mdir_t *b); +// needed in lfs3_rev_init +static inline bool lfs3_mdir_ismrootanchor(const lfs3_mdir_t *mdir); +static inline int lfs3_mdir_cmp(const lfs3_mdir_t *a, const lfs3_mdir_t *b); -static inline uint32_t lfsr_rev_init(lfs_t *lfs, const lfsr_mdir_t *mdir, +static inline uint32_t lfs3_rev_init(lfs3_t *lfs3, const lfs3_mdir_t *mdir, uint32_t rev) { - (void)lfs; + (void)lfs3; (void)mdir; // we really only care about the top revision bits here rev &= ~((1 << 28)-1); // increment revision rev += 1 << 28; - #ifdef LFS_REVDBG + #ifdef LFS3_REVDBG // include debug bits? - if (lfsr_m_isrevdbg(lfs->flags)) { + if (lfs3_m_isrevdbg(lfs3->flags)) { // mroot? - if (mdir->mid == -1 || lfsr_mdir_cmp(mdir, &lfs->mroot) == 0) { + if (mdir->mid == -1 || lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0) { rev |= 0x007e726d; // mdir? } else { @@ -7187,10 +7189,10 @@ static inline uint32_t lfsr_rev_init(lfs_t *lfs, const lfsr_mdir_t *mdir, } } #endif - #ifdef LFS_REVNOISE + #ifdef LFS3_REVNOISE // xor in pseudorandom noise - if (lfsr_m_isrevnoise(lfs->flags)) { - rev ^= ((1 << (28-lfs_smax(lfs->recycle_bits, 0)))-1) & lfs->gcksum; + if (lfs3_m_isrevnoise(lfs3->flags)) { + rev ^= ((1 << (28-lfs3_smax(lfs3->recycle_bits, 0)))-1) & lfs3->gcksum; } #endif return rev; @@ -7198,14 +7200,14 @@ static inline uint32_t lfsr_rev_init(lfs_t *lfs, const lfsr_mdir_t *mdir, // btrees don't normally need revision counts, but we make use of them // if revdbg or revnoise is enabled -static inline uint32_t lfsr_rev_btree(lfs_t *lfs) { - (void)lfs; +static inline uint32_t lfs3_rev_btree(lfs3_t *lfs3) { + (void)lfs3; uint32_t rev = 0; - #ifdef LFS_REVDBG + #ifdef LFS3_REVDBG // include debug bits? - if (lfsr_m_isrevdbg(lfs->flags)) { + if (lfs3_m_isrevdbg(lfs3->flags)) { // mtree? - if (lfsr_i_isinmtree(lfs->flags)) { + if (lfs3_i_isinmtree(lfs3->flags)) { rev |= 0x007e6d62; // file btree? } else { @@ -7213,33 +7215,33 @@ static inline uint32_t lfsr_rev_btree(lfs_t *lfs) { } } #endif - #ifdef LFS_REVNOISE + #ifdef LFS3_REVNOISE // xor in pseudorandom noise - if (lfsr_m_isrevnoise(lfs->flags)) { + if (lfs3_m_isrevnoise(lfs3->flags)) { // keep the top nibble zero - rev ^= 0x0fffffff & lfs->gcksum; + rev ^= 0x0fffffff & lfs3->gcksum; } #endif return rev; } -static inline bool lfsr_rev_needsrelocation(lfs_t *lfs, uint32_t rev) { - if (lfs->recycle_bits == -1) { +static inline bool lfs3_rev_needsrelocation(lfs3_t *lfs3, uint32_t rev) { + if (lfs3->recycle_bits == -1) { return false; } // does out recycle counter overflow? - uint32_t rev_ = rev + (1 << (28-lfs_smax(lfs->recycle_bits, 0))); + uint32_t rev_ = rev + (1 << (28-lfs3_smax(lfs3->recycle_bits, 0))); return (rev_ >> 28) != (rev >> 28); } -static inline uint32_t lfsr_rev_inc(lfs_t *lfs, uint32_t rev) { +static inline uint32_t lfs3_rev_inc(lfs3_t *lfs3, uint32_t rev) { // increment recycle counter/revision - rev += 1 << (28-lfs_smax(lfs->recycle_bits, 0)); - #ifdef LFS_REVNOISE + rev += 1 << (28-lfs3_smax(lfs3->recycle_bits, 0)); + #ifdef LFS3_REVNOISE // xor in pseudorandom noise - if (lfsr_m_isrevnoise(lfs->flags)) { - rev ^= ((1 << (28-lfs_smax(lfs->recycle_bits, 0)))-1) & lfs->gcksum; + if (lfs3_m_isrevnoise(lfs3->flags)) { + rev ^= ((1 << (28-lfs3_smax(lfs3->recycle_bits, 0)))-1) & lfs3->gcksum; } #endif return rev; @@ -7250,99 +7252,99 @@ static inline uint32_t lfsr_rev_inc(lfs_t *lfs, uint32_t rev) { /// Metadata pair stuff /// // mdir convenience functions -static inline void lfsr_mdir_claim(lfsr_mdir_t *mdir) { - lfsr_rbyd_claim(&mdir->rbyd); +static inline void lfs3_mdir_claim(lfs3_mdir_t *mdir) { + lfs3_rbyd_claim(&mdir->rbyd); } -static inline int lfsr_mdir_cmp(const lfsr_mdir_t *a, const lfsr_mdir_t *b) { - return lfsr_mptr_cmp(a->rbyd.blocks, b->rbyd.blocks); +static inline int lfs3_mdir_cmp(const lfs3_mdir_t *a, const lfs3_mdir_t *b) { + return lfs3_mptr_cmp(a->rbyd.blocks, b->rbyd.blocks); } -static inline bool lfsr_mdir_ismrootanchor(const lfsr_mdir_t *mdir) { - return lfsr_mptr_ismrootanchor(mdir->rbyd.blocks); +static inline bool lfs3_mdir_ismrootanchor(const lfs3_mdir_t *mdir) { + return lfs3_mptr_ismrootanchor(mdir->rbyd.blocks); } -static inline void lfsr_mdir_sync(lfsr_mdir_t *a, const lfsr_mdir_t *b) { +static inline void lfs3_mdir_sync(lfs3_mdir_t *a, const lfs3_mdir_t *b) { // copy over everything but the mid a->rbyd = b->rbyd; a->gcksumdelta = b->gcksumdelta; } // mdir operations -static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, - lfsr_smid_t mid, const lfs_block_t mptr[static 2]) { +static int lfs3_mdir_fetch(lfs3_t *lfs3, lfs3_mdir_t *mdir, + lfs3_smid_t mid, const lfs3_block_t mptr[static 2]) { // create a copy of the mptr, both so we can swap the blocks to keep // track of the current revision, and to prevents issues if mptr // references the blocks in the mdir - lfs_block_t blocks[2] = {mptr[0], mptr[1]}; + lfs3_block_t blocks[2] = {mptr[0], mptr[1]}; // read both revision counts, try to figure out which block // has the most recent revision uint32_t revs[2] = {0, 0}; for (int i = 0; i < 2; i++) { - int err = lfsr_bd_read(lfs, blocks[0], 0, 0, + int err = lfs3_bd_read(lfs3, blocks[0], 0, 0, &revs[0], sizeof(uint32_t)); - if (err && err != LFS_ERR_CORRUPT) { + if (err && err != LFS3_ERR_CORRUPT) { return err; } - revs[i] = lfs_fromle32(&revs[i]); + revs[i] = lfs3_fromle32(&revs[i]); if (i == 0 - || err == LFS_ERR_CORRUPT - || lfs_scmp(revs[1], revs[0]) > 0) { - LFS_SWAP(lfs_block_t, &blocks[0], &blocks[1]); - LFS_SWAP(uint32_t, &revs[0], &revs[1]); + || err == LFS3_ERR_CORRUPT + || lfs3_scmp(revs[1], revs[0]) > 0) { + LFS3_SWAP(lfs3_block_t, &blocks[0], &blocks[1]); + LFS3_SWAP(uint32_t, &revs[0], &revs[1]); } } // try to fetch rbyds in the order of most recent to least recent for (int i = 0; i < 2; i++) { - int err = lfsr_rbyd_fetch_(lfs, + int err = lfs3_rbyd_fetch_(lfs3, &mdir->rbyd, &mdir->gcksumdelta, blocks[0], 0); - if (err && err != LFS_ERR_CORRUPT) { + if (err && err != LFS3_ERR_CORRUPT) { return err; } - if (err != LFS_ERR_CORRUPT) { + if (err != LFS3_ERR_CORRUPT) { mdir->mid = mid; // keep track of other block for compactions mdir->rbyd.blocks[1] = blocks[1]; - #ifdef LFS_DBGMDIRFETCHES - LFS_DEBUG("Fetched mdir %"PRId32" " + #ifdef LFS3_DBGMDIRFETCHES + LFS3_DEBUG("Fetched mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32", " "cksum %"PRIx32, - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], - lfsr_rbyd_trunk(&mdir->rbyd), + lfs3_rbyd_trunk(&mdir->rbyd), mdir->rbyd.weight, mdir->rbyd.cksum); #endif return 0; } - LFS_SWAP(lfs_block_t, &blocks[0], &blocks[1]); - LFS_SWAP(uint32_t, &revs[0], &revs[1]); + LFS3_SWAP(lfs3_block_t, &blocks[0], &blocks[1]); + LFS3_SWAP(uint32_t, &revs[0], &revs[1]); } // could not find a non-corrupt rbyd - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } -static int lfsr_data_fetchmdir(lfs_t *lfs, - lfsr_data_t *data, lfsr_smid_t mid, - lfsr_mdir_t *mdir) { +static int lfs3_data_fetchmdir(lfs3_t *lfs3, + lfs3_data_t *data, lfs3_smid_t mid, + lfs3_mdir_t *mdir) { // decode mptr and fetch - int err = lfsr_data_readmptr(lfs, data, + int err = lfs3_data_readmptr(lfs3, data, mdir->rbyd.blocks); if (err) { return err; } - return lfsr_mdir_fetch(lfs, mdir, mid, mdir->rbyd.blocks); + return lfs3_mdir_fetch(lfs3, mdir, mid, mdir->rbyd.blocks); } -static lfsr_tag_t lfsr_mdir_nametag(const lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_smid_t mid, lfsr_tag_t tag) { +static lfs3_tag_t lfs3_mdir_nametag(const lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_smid_t mid, lfs3_tag_t tag) { (void)mdir; // intercept pending grms here and pretend they're orphaned // stickynotes @@ -7350,49 +7352,49 @@ static lfsr_tag_t lfsr_mdir_nametag(const lfs_t *lfs, const lfsr_mdir_t *mdir, // fortunately pending grms/orphaned stickynotes have roughly the // same semantics, and this makes it easier to manage the implied // mid gap in higher-levels - if (lfsr_grm_ismidrm(lfs, mid)) { - return LFSR_TAG_ORPHAN; + if (lfs3_grm_ismidrm(lfs3, mid)) { + return LFS3_TAG_ORPHAN; // if we find a stickynote, check to see if there are any open // in-sync file handles to decide if it really exists - } else if (tag == LFSR_TAG_STICKYNOTE - && !lfsr_omdir_ismidopen(lfs, mid, - ~LFS_o_ZOMBIE & ~LFS_O_DESYNC)) { - return LFSR_TAG_ORPHAN; + } else if (tag == LFS3_TAG_STICKYNOTE + && !lfs3_omdir_ismidopen(lfs3, mid, + ~LFS3_o_ZOMBIE & ~LFS3_O_DESYNC)) { + return LFS3_TAG_ORPHAN; - // map unknown types -> LFSR_TAG_UNKNOWN, this simplifies higher + // map unknown types -> LFS3_TAG_UNKNOWN, this simplifies higher // levels and prevents collisions with internal types // // Note future types should probably come with WCOMPAT flags, and be // at least reported on non-supporting filesystems - } else if (tag < LFSR_TAG_REG || tag > LFSR_TAG_BOOKMARK) { - return LFSR_TAG_UNKNOWN; + } else if (tag < LFS3_TAG_REG || tag > LFS3_TAG_BOOKMARK) { + return LFS3_TAG_UNKNOWN; } return tag; } -static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_tag_t tag, - lfsr_tag_t *tag_, lfsr_data_t *data_) { - lfsr_srid_t rid__; - lfsr_tag_t tag__; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, - lfsr_mrid(lfs, mdir->mid), tag, +static int lfs3_mdir_lookupnext(lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_tag_t tag, + lfs3_tag_t *tag_, lfs3_data_t *data_) { + lfs3_srid_t rid__; + lfs3_tag_t tag__; + int err = lfs3_rbyd_lookupnext(lfs3, &mdir->rbyd, + lfs3_mrid(lfs3, mdir->mid), tag, &rid__, &tag__, NULL, data_); if (err) { return err; } - // this is very similar to lfsr_rbyd_lookupnext, but we error if + // this is very similar to lfs3_rbyd_lookupnext, but we error if // lookupnext would change mids - if (rid__ != lfsr_mrid(lfs, mdir->mid)) { - return LFS_ERR_NOENT; + if (rid__ != lfs3_mrid(lfs3, mdir->mid)) { + return LFS3_ERR_NOENT; } // map name tags to understood types - if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { - tag__ = lfsr_mdir_nametag(lfs, mdir, mdir->mid, tag__); + if (lfs3_tag_suptype(tag__) == LFS3_TAG_NAME) { + tag__ = lfs3_mdir_nametag(lfs3, mdir, mdir->mid, tag__); } if (tag_) { @@ -7401,11 +7403,11 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, return 0; } -static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_tag_t tag, - lfsr_tag_t *tag_, lfsr_data_t *data_) { - lfsr_tag_t tag__; - int err = lfsr_mdir_lookupnext(lfs, mdir, lfsr_tag_key(tag), +static int lfs3_mdir_lookup(lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_tag_t tag, + lfs3_tag_t *tag_, lfs3_data_t *data_) { + lfs3_tag_t tag__; + int err = lfs3_mdir_lookupnext(lfs3, mdir, lfs3_tag_key(tag), &tag__, data_); if (err) { return err; @@ -7413,8 +7415,8 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, // lookup finds the next-smallest tag, all we need to do is fail if it // picks up the wrong tag - if ((tag__ & lfsr_tag_mask(tag)) != (tag & lfsr_tag_mask(tag))) { - return LFS_ERR_NOENT; + if ((tag__ & lfs3_tag_mask(tag)) != (tag & lfs3_tag_mask(tag))) { + return LFS3_ERR_NOENT; } if (tag_) { @@ -7427,74 +7429,74 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, /// Metadata-tree things /// -static inline lfsr_mid_t lfsr_mtree_weight(lfs_t *lfs) { - return lfs_max( - lfs->mtree.weight, - 1 << lfs->mbits); +static inline lfs3_mid_t lfs3_mtree_weight(lfs3_t *lfs3) { + return lfs3_max( + lfs3->mtree.weight, + 1 << lfs3->mbits); } // lookup mdir containing a given mid -static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, - lfsr_mdir_t *mdir_) { +static int lfs3_mtree_lookup(lfs3_t *lfs3, lfs3_smid_t mid, + lfs3_mdir_t *mdir_) { // looking up mid=-1 is probably a mistake - LFS_ASSERT(mid >= 0); + LFS3_ASSERT(mid >= 0); // out of bounds? - if ((lfsr_mid_t)mid >= lfsr_mtree_weight(lfs)) { - return LFS_ERR_NOENT; + if ((lfs3_mid_t)mid >= lfs3_mtree_weight(lfs3)) { + return LFS3_ERR_NOENT; } // looking up mroot? - if (lfs->mtree.weight == 0) { + if (lfs3->mtree.weight == 0) { // treat inlined mdir as mid=0 mdir_->mid = mid; - lfsr_mdir_sync(mdir_, &lfs->mroot); + lfs3_mdir_sync(mdir_, &lfs3->mroot); return 0; // look up mdir in actual mtree } else { - lfsr_bid_t bid; - lfsr_srid_t rid; - lfsr_tag_t tag; - lfsr_bid_t weight; - lfsr_data_t data; - int err = lfsr_btree_lookupleaf(lfs, &lfs->mtree, mid, + lfs3_bid_t bid; + lfs3_srid_t rid; + lfs3_tag_t tag; + lfs3_bid_t weight; + lfs3_data_t data; + int err = lfs3_btree_lookupleaf(lfs3, &lfs3->mtree, mid, &bid, &mdir_->rbyd, &rid, &tag, &weight, &data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - LFS_ASSERT((lfsr_sbid_t)bid == lfsr_mbid(lfs, mid)); - LFS_ASSERT(weight == (lfsr_bid_t)(1 << lfs->mbits)); - LFS_ASSERT(tag == LFSR_TAG_MNAME - || tag == LFSR_TAG_MDIR); + LFS3_ASSERT((lfs3_sbid_t)bid == lfs3_mbid(lfs3, mid)); + LFS3_ASSERT(weight == (lfs3_bid_t)(1 << lfs3->mbits)); + LFS3_ASSERT(tag == LFS3_TAG_MNAME + || tag == LFS3_TAG_MDIR); // if we found an mname, lookup the mdir - if (tag == LFSR_TAG_MNAME) { - err = lfsr_rbyd_lookup(lfs, &mdir_->rbyd, rid, LFSR_TAG_MDIR, + if (tag == LFS3_TAG_MNAME) { + err = lfs3_rbyd_lookup(lfs3, &mdir_->rbyd, rid, LFS3_TAG_MDIR, NULL, &data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } // fetch mdir - return lfsr_data_fetchmdir(lfs, &data, mid, + return lfs3_data_fetchmdir(lfs3, &data, mid, mdir_); } } -// this is the same as lfsr_btree_commit, but we set the inmtree flag +// this is the same as lfs3_btree_commit, but we set the inmtree flag // for debugging reasons -static int lfsr_mtree_commit(lfs_t *lfs, lfsr_btree_t *mtree, - lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { - #ifdef LFS_REVDBG - lfs->flags |= LFS_i_INMTREE; +static int lfs3_mtree_commit(lfs3_t *lfs3, lfs3_btree_t *mtree, + lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + #ifdef LFS3_REVDBG + lfs3->flags |= LFS3_i_INMTREE; #endif - int err = lfsr_btree_commit(lfs, mtree, bid, rattrs, rattr_count); - #ifdef LFS_REVDBG - lfs->flags &= ~LFS_i_INMTREE; + int err = lfs3_btree_commit(lfs3, mtree, bid, rattrs, rattr_count); + #ifdef LFS3_REVDBG + lfs3->flags &= ~LFS3_i_INMTREE; #endif return err; } @@ -7505,15 +7507,15 @@ static int lfsr_mtree_commit(lfs_t *lfs, lfsr_btree_t *mtree, // this is the gooey atomic center of littlefs // -// any mutation must go through lfsr_mdir_commit to persist on disk +// any mutation must go through lfs3_mdir_commit to persist on disk // -// this makes lfsr_mdir_commit also responsible for propagating changes +// this makes lfs3_mdir_commit also responsible for propagating changes // up through the mtree/mroot chain, and through any internal structures, -// making lfsr_mdir_commit quite involved and a bit of a mess. +// making lfs3_mdir_commit quite involved and a bit of a mess. -// low-level mdir operations needed by lfsr_mdir_commit -static int lfsr_mdir_alloc__(lfs_t *lfs, lfsr_mdir_t *mdir, - lfsr_smid_t mid, bool partial) { +// low-level mdir operations needed by lfs3_mdir_commit +static int lfs3_mdir_alloc__(lfs3_t *lfs3, lfs3_mdir_t *mdir, + lfs3_smid_t mid, bool partial) { // assign the mid mdir->mid = mid; // default to zero gcksumdelta @@ -7521,7 +7523,7 @@ static int lfsr_mdir_alloc__(lfs_t *lfs, lfsr_mdir_t *mdir, if (!partial) { // allocate one block without an erase - lfs_sblock_t block = lfs_alloc(lfs, false); + lfs3_sblock_t block = lfs3_alloc(lfs3, false); if (block < 0) { return block; } @@ -7533,19 +7535,19 @@ static int lfsr_mdir_alloc__(lfs_t *lfs, lfsr_mdir_t *mdir, // we use whatever is on-disk to avoid needing to rewrite the // redund block uint32_t rev; - int err = lfsr_bd_read(lfs, mdir->rbyd.blocks[1], 0, 0, + int err = lfs3_bd_read(lfs3, mdir->rbyd.blocks[1], 0, 0, &rev, sizeof(uint32_t)); - if (err && err != LFS_ERR_CORRUPT) { + if (err && err != LFS3_ERR_CORRUPT) { return err; } // note we allow corrupt errors here, as long as they are consistent - rev = (err != LFS_ERR_CORRUPT) ? lfs_fromle32(&rev) : 0; + rev = (err != LFS3_ERR_CORRUPT) ? lfs3_fromle32(&rev) : 0; // reset recycle bits in revision count and increment - rev = lfsr_rev_init(lfs, mdir, rev); + rev = lfs3_rev_init(lfs3, mdir, rev); relocate:; // allocate another block with an erase - lfs_sblock_t block = lfs_alloc(lfs, true); + lfs3_sblock_t block = lfs3_alloc(lfs3, true); if (block < 0) { return block; } @@ -7556,10 +7558,10 @@ relocate:; mdir->rbyd.cksum = 0; // write our revision count - err = lfsr_rbyd_appendrev(lfs, &mdir->rbyd, rev); + err = lfs3_rbyd_appendrev(lfs3, &mdir->rbyd, rev); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -7568,8 +7570,8 @@ relocate:; return 0; } -static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_, - const lfsr_mdir_t *mdir, bool force) { +static int lfs3_mdir_swap__(lfs3_t *lfs3, lfs3_mdir_t *mdir_, + const lfs3_mdir_t *mdir, bool force) { // assign the mid mdir_->mid = mdir->mid; // reset to zero gcksumdelta, upper layers should handle this @@ -7577,19 +7579,19 @@ static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_, // first thing we need to do is read our current revision count uint32_t rev; - int err = lfsr_bd_read(lfs, mdir->rbyd.blocks[0], 0, 0, + int err = lfs3_bd_read(lfs3, mdir->rbyd.blocks[0], 0, 0, &rev, sizeof(uint32_t)); - if (err && err != LFS_ERR_CORRUPT) { + if (err && err != LFS3_ERR_CORRUPT) { return err; } // note we allow corrupt errors here, as long as they are consistent - rev = (err != LFS_ERR_CORRUPT) ? lfs_fromle32(&rev) : 0; + rev = (err != LFS3_ERR_CORRUPT) ? lfs3_fromle32(&rev) : 0; // increment our revision count - rev = lfsr_rev_inc(lfs, rev); + rev = lfs3_rev_inc(lfs3, rev); // decide if we need to relocate - if (!force && lfsr_rev_needsrelocation(lfs, rev)) { - return LFS_ERR_NOSPC; + if (!force && lfs3_rev_needsrelocation(lfs3, rev)) { + return LFS3_ERR_NOSPC; } // swap our blocks @@ -7601,13 +7603,13 @@ static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_, mdir_->rbyd.cksum = 0; // erase, preparing for compact - err = lfsr_bd_erase(lfs, mdir_->rbyd.blocks[0]); + err = lfs3_bd_erase(lfs3, mdir_->rbyd.blocks[0]); if (err) { return err; } // increment our revision count and write it to our rbyd - err = lfsr_rbyd_appendrev(lfs, &mdir_->rbyd, rev); + err = lfs3_rbyd_appendrev(lfs3, &mdir_->rbyd, rev); if (err) { return err; } @@ -7616,28 +7618,28 @@ static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_, } // low-level mdir commit, does not handle mtree/mlist/compaction/etc -static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, - lfsr_srid_t start_rid, lfsr_srid_t end_rid, - lfsr_smid_t mid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { +static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir, + lfs3_srid_t start_rid, lfs3_srid_t end_rid, + lfs3_smid_t mid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // since we only ever commit to one mid or split, we can ignore the // entire rattr-list if our mid is out of range - lfsr_srid_t rid = lfsr_mrid(lfs, mid); + lfs3_srid_t rid = lfs3_mrid(lfs3, mid); if (rid >= start_rid // note the use of rid+1 and unsigned comparison here to // treat end_rid=-1 as "unbounded" in such a way that rid=-1 // is still included - && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) { + && (lfs3_size_t)(rid + 1) <= (lfs3_size_t)end_rid) { - for (lfs_size_t i = 0; i < rattr_count; i++) { + for (lfs3_size_t i = 0; i < rattr_count; i++) { // we just happen to never split in an mdir commit - LFS_ASSERT(!(i > 0 && lfsr_rattr_isinsert(rattrs[i]))); + LFS3_ASSERT(!(i > 0 && lfs3_rattr_isinsert(rattrs[i]))); // rattr lists can be chained, but only tail-recursively - if (rattrs[i].tag == LFSR_TAG_RATTRS) { + if (rattrs[i].tag == LFS3_TAG_RATTRS) { // must be the last tag - LFS_ASSERT(i == rattr_count-1); - const lfsr_rattr_t *rattrs_ = rattrs[i].u.etc; - lfs_size_t rattr_count_ = rattrs[i].count; + LFS3_ASSERT(i == rattr_count-1); + const lfs3_rattr_t *rattrs_ = rattrs[i].u.etc; + lfs3_size_t rattr_count_ = rattrs[i].count; // switch to chained rattr-list rattrs = rattrs_; @@ -7647,23 +7649,23 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // shrub tags append a set of attributes to an unrelated trunk // in our rbyd - } else if (rattrs[i].tag == LFSR_TAG_SHRUBCOMMIT) { - const lfsr_shrubcommit_t *shrubcommit = rattrs[i].u.etc; - lfsr_bshrub_t *bshrub_ = shrubcommit->bshrub; - lfsr_srid_t rid_ = shrubcommit->rid; - const lfsr_rattr_t *rattrs_ = shrubcommit->rattrs; - lfs_size_t rattr_count_ = shrubcommit->rattr_count; + } else if (rattrs[i].tag == LFS3_TAG_SHRUBCOMMIT) { + const lfs3_shrubcommit_t *shrubcommit = rattrs[i].u.etc; + lfs3_bshrub_t *bshrub_ = shrubcommit->bshrub; + lfs3_srid_t rid_ = shrubcommit->rid; + const lfs3_rattr_t *rattrs_ = shrubcommit->rattrs; + lfs3_size_t rattr_count_ = shrubcommit->rattr_count; // reset shrub if it doesn't live in our block, this happens // when converting from a btree - if (!lfsr_bshrub_isbshrub(bshrub_)) { + if (!lfs3_bshrub_isbshrub(bshrub_)) { bshrub_->shrub_.blocks[0] = mdir->rbyd.blocks[0]; - bshrub_->shrub_.trunk = LFSR_RBYD_ISSHRUB | 0; + bshrub_->shrub_.trunk = LFS3_RBYD_ISSHRUB | 0; bshrub_->shrub_.weight = 0; } // commit to shrub - int err = lfsr_shrub_commit(lfs, + int err = lfs3_shrub_commit(lfs3, &mdir->rbyd, &bshrub_->shrub_, rid_, rattrs_, rattr_count_); if (err) { @@ -7672,23 +7674,23 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // push a new grm, this tag lets us push grms atomically when // creating new mids - } else if (rattrs[i].tag == LFSR_TAG_GRMPUSH) { - // do nothing here, this is handled up in lfsr_mdir_commit + } else if (rattrs[i].tag == LFS3_TAG_GRMPUSH) { + // do nothing here, this is handled up in lfs3_mdir_commit // move tags copy over any tags associated with the source's rid - // TODO can this be deduplicated with lfsr_mdir_compact__ more? + // TODO can this be deduplicated with lfs3_mdir_compact__ more? // it _really_ wants to be deduplicated - } else if (rattrs[i].tag == LFSR_TAG_MOVE) { - const lfsr_mdir_t *mdir__ = rattrs[i].u.etc; + } else if (rattrs[i].tag == LFS3_TAG_MOVE) { + const lfs3_mdir_t *mdir__ = rattrs[i].u.etc; // skip the name tag, this is always replaced by upper layers - lfsr_tag_t tag = LFSR_TAG_STRUCT-1; + lfs3_tag_t tag = LFS3_TAG_STRUCT-1; while (true) { - lfsr_data_t data; - int err = lfsr_mdir_lookupnext(lfs, mdir__, tag+1, + lfs3_data_t data; + int err = lfs3_mdir_lookupnext(lfs3, mdir__, tag+1, &tag, &data); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -7696,34 +7698,34 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // found an inlined shrub? we need to compact the shrub // as well to bring it along with us - if (tag == LFSR_TAG_BSHRUB) { - lfsr_shrub_t shrub; - err = lfsr_data_readshrub(lfs, &data, mdir__, + if (tag == LFS3_TAG_BSHRUB) { + lfs3_shrub_t shrub; + err = lfs3_data_readshrub(lfs3, &data, mdir__, &shrub); if (err) { return err; } // compact our shrub - err = lfsr_shrub_compact(lfs, &mdir->rbyd, &shrub, + err = lfs3_shrub_compact(lfs3, &mdir->rbyd, &shrub, &shrub); if (err) { return err; } // write our new shrub tag - err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, - rid - lfs_smax(start_rid, 0), - LFSR_RATTR_SHRUB(LFSR_TAG_BSHRUB, 0, &shrub)); + err = lfs3_rbyd_appendrattr(lfs3, &mdir->rbyd, + rid - lfs3_smax(start_rid, 0), + LFS3_RATTR_SHRUB(LFS3_TAG_BSHRUB, 0, &shrub)); if (err) { return err; } // append the rattr } else { - err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, - rid - lfs_smax(start_rid, 0), - LFSR_RATTR_DATA(tag, 0, &data)); + err = lfs3_rbyd_appendrattr(lfs3, &mdir->rbyd, + rid - lfs3_smax(start_rid, 0), + LFS3_RATTR_DATA(tag, 0, &data)); if (err) { return err; } @@ -7732,19 +7734,19 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // we're not quite done! we also need to bring over any // unsynced files - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) // belongs to our mid? && o->mdir.mid == mdir__->mid // is a bshrub? - && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o) + && lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o) // only compact once, first compact should // stage the new block - && ((lfsr_bshrub_t*)o)->shrub_.blocks[0] + && ((lfs3_bshrub_t*)o)->shrub_.blocks[0] != mdir->rbyd.blocks[0]) { - int err = lfsr_shrub_compact(lfs, &mdir->rbyd, - &((lfsr_bshrub_t*)o)->shrub_, - &((lfsr_bshrub_t*)o)->shrub); + int err = lfs3_shrub_compact(lfs3, &mdir->rbyd, + &((lfs3_bshrub_t*)o)->shrub_, + &((lfs3_bshrub_t*)o)->shrub); if (err) { return err; } @@ -7752,49 +7754,49 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // custom attributes need to be reencoded into our tag format - } else if (rattrs[i].tag == LFSR_TAG_ATTRS) { - const struct lfs_attr *attrs_ = rattrs[i].u.etc; - lfs_size_t attr_count_ = rattrs[i].count; + } else if (rattrs[i].tag == LFS3_TAG_ATTRS) { + const struct lfs3_attr *attrs_ = rattrs[i].u.etc; + lfs3_size_t attr_count_ = rattrs[i].count; - for (lfs_size_t j = 0; j < attr_count_; j++) { + for (lfs3_size_t j = 0; j < attr_count_; j++) { // skip readonly attrs and lazy attrs - if (lfsr_o_isrdonly(attrs_[j].flags)) { + if (lfs3_o_isrdonly(attrs_[j].flags)) { continue; } // first lets check if the attr changed, we don't want // to append attrs unless we have to - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, mdir, - LFSR_TAG_ATTR(attrs_[j].type), + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, mdir, + LFS3_TAG_ATTR(attrs_[j].type), NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } // does disk match our attr? - lfs_scmp_t cmp = lfsr_attr_cmp(lfs, &attrs_[j], - (err != LFS_ERR_NOENT) ? &data : NULL); + lfs3_scmp_t cmp = lfs3_attr_cmp(lfs3, &attrs_[j], + (err != LFS3_ERR_NOENT) ? &data : NULL); if (cmp < 0) { return cmp; } - if (cmp == LFS_CMP_EQ) { + if (cmp == LFS3_CMP_EQ) { continue; } // append the custom attr - err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, - rid - lfs_smax(start_rid, 0), + err = lfs3_rbyd_appendrattr(lfs3, &mdir->rbyd, + rid - lfs3_smax(start_rid, 0), // removing or updating? - (lfsr_attr_isnoattr(&attrs_[j])) - ? LFSR_RATTR( - LFSR_TAG_RM - | LFSR_TAG_ATTR(attrs_[j].type), 0) - : LFSR_RATTR_BUF( - LFSR_TAG_ATTR(attrs_[j].type), 0, + (lfs3_attr_isnoattr(&attrs_[j])) + ? LFS3_RATTR( + LFS3_TAG_RM + | LFS3_TAG_ATTR(attrs_[j].type), 0) + : LFS3_RATTR_BUF( + LFS3_TAG_ATTR(attrs_[j].type), 0, attrs_[j].buffer, - lfsr_attr_size(&attrs_[j]))); + lfs3_attr_size(&attrs_[j]))); if (err) { return err; } @@ -7802,10 +7804,10 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // write out normal tags normally } else { - LFS_ASSERT(!lfsr_tag_isinternal(rattrs[i].tag)); + LFS3_ASSERT(!lfs3_tag_isinternal(rattrs[i].tag)); - int err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, - rid - lfs_smax(start_rid, 0), + int err = lfs3_rbyd_appendrattr(lfs3, &mdir->rbyd, + rid - lfs3_smax(start_rid, 0), rattrs[i]); if (err) { return err; @@ -7813,7 +7815,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // adjust rid - rid = lfsr_rattr_nextrid(rattrs[i], rid); + rid = lfs3_rattr_nextrid(rattrs[i], rid); } } @@ -7824,15 +7826,15 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // remove up to upper layers. if (mdir->rbyd.weight == 0 // unless we are an mroot - && !(mdir->mid == -1 || lfsr_mdir_cmp(mdir, &lfs->mroot) == 0)) { + && !(mdir->mid == -1 || lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0)) { // note! we can no longer read from this mdir as our pcache may // be clobbered - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // append any gstate? if (start_rid <= -2) { - int err = lfsr_rbyd_appendgdelta(lfs, &mdir->rbyd); + int err = lfs3_rbyd_appendgdelta(lfs3, &mdir->rbyd); if (err) { return err; } @@ -7847,19 +7849,19 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // append gkcsumdelta? if (start_rid <= -2) { // figure out changes to our gcksumdelta - mdir->gcksumdelta ^= lfs_crc32c_cube(lfs->gcksum_p) - ^ lfs_crc32c_cube(lfs->gcksum ^ cksum) - ^ lfs->gcksum_d; + mdir->gcksumdelta ^= lfs3_crc32c_cube(lfs3->gcksum_p) + ^ lfs3_crc32c_cube(lfs3->gcksum ^ cksum) + ^ lfs3->gcksum_d; - int err = lfsr_rbyd_appendrattr_(lfs, &mdir->rbyd, LFSR_RATTR_LE32( - LFSR_TAG_GCKSUMDELTA, 0, mdir->gcksumdelta)); + int err = lfs3_rbyd_appendrattr_(lfs3, &mdir->rbyd, LFS3_RATTR_LE32( + LFS3_TAG_GCKSUMDELTA, 0, mdir->gcksumdelta)); if (err) { return err; } } // finalize commit - int err = lfsr_rbyd_appendcksum_(lfs, &mdir->rbyd, cksum); + int err = lfs3_rbyd_appendcksum_(lfs3, &mdir->rbyd, cksum); if (err) { return err; } @@ -7867,51 +7869,51 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // success? // xor our new cksum - lfs->gcksum ^= mdir->rbyd.cksum; + lfs3->gcksum ^= mdir->rbyd.cksum; return 0; } // TODO do we need to include commit overhead here? -static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_srid_t start_rid, lfsr_srid_t end_rid, - lfsr_srid_t *split_rid_) { +static lfs3_ssize_t lfs3_mdir_estimate__(lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_srid_t start_rid, lfs3_srid_t end_rid, + lfs3_srid_t *split_rid_) { // yet another function that is just begging to be deduplicated, but we // can't because it would be recursive // - // this is basically the same as lfsr_rbyd_estimate, except we assume all + // this is basically the same as lfs3_rbyd_estimate, except we assume all // rids have weight 1 and have extra handling for opened files, shrubs, etc // calculate dsize by starting from the outside ids and working inwards, // this naturally gives us a split rid - lfsr_srid_t a_rid = lfs_smax(start_rid, -1); - lfsr_srid_t b_rid = lfs_min(mdir->rbyd.weight, end_rid); - lfs_size_t a_dsize = 0; - lfs_size_t b_dsize = 0; - lfs_size_t mdir_dsize = 0; + lfs3_srid_t a_rid = lfs3_smax(start_rid, -1); + lfs3_srid_t b_rid = lfs3_min(mdir->rbyd.weight, end_rid); + lfs3_size_t a_dsize = 0; + lfs3_size_t b_dsize = 0; + lfs3_size_t mdir_dsize = 0; while (a_rid != b_rid) { if (a_dsize > b_dsize // bias so lower dsize >= upper dsize || (a_dsize == b_dsize && a_rid > b_rid)) { - LFS_SWAP(lfsr_srid_t, &a_rid, &b_rid); - LFS_SWAP(lfs_size_t, &a_dsize, &b_dsize); + LFS3_SWAP(lfs3_srid_t, &a_rid, &b_rid); + LFS3_SWAP(lfs3_size_t, &a_dsize, &b_dsize); } if (a_rid > b_rid) { a_rid -= 1; } - lfsr_tag_t tag = 0; - lfs_size_t dsize_ = 0; + lfs3_tag_t tag = 0; + lfs3_size_t dsize_ = 0; while (true) { - lfsr_srid_t rid_; - lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, + lfs3_srid_t rid_; + lfs3_data_t data; + int err = lfs3_rbyd_lookupnext(lfs3, &mdir->rbyd, a_rid, tag+1, &rid_, &tag, NULL, &data); if (err < 0) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -7923,28 +7925,28 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir, // special handling for shrub trunks, we need to include the // compacted cost of the shrub in our estimate // - // this is what would make lfsr_rbyd_estimate recursive, and + // this is what would make lfs3_rbyd_estimate recursive, and // why we need a second function... // - if (tag == LFSR_TAG_BSHRUB) { + if (tag == LFS3_TAG_BSHRUB) { // include the cost of this trunk - dsize_ += LFSR_SHRUB_DSIZE; + dsize_ += LFS3_SHRUB_DSIZE; - lfsr_shrub_t shrub; - err = lfsr_data_readshrub(lfs, &data, mdir, &shrub); + lfs3_shrub_t shrub; + err = lfs3_data_readshrub(lfs3, &data, mdir, &shrub); if (err < 0) { return err; } - lfs_ssize_t dsize__ = lfsr_shrub_estimate(lfs, &shrub); + lfs3_ssize_t dsize__ = lfs3_shrub_estimate(lfs3, &shrub); if (dsize__ < 0) { return dsize__; } - dsize_ += lfs->rattr_estimate + dsize__; + dsize_ += lfs3->rattr_estimate + dsize__; } else { // include the cost of this tag - dsize_ += lfs->mattr_estimate + lfsr_data_size(data); + dsize_ += lfs3->mattr_estimate + lfs3_data_size(data); } } @@ -7953,15 +7955,15 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir, // this is O(n^2), but littlefs is unlikely to have many open // files, I suppose if this becomes a problem we could sort // opened files by mid - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) // belongs to our mdir + rid? - && lfsr_mdir_cmp(&o->mdir, mdir) == 0 - && lfsr_mrid(lfs, o->mdir.mid) == a_rid + && lfs3_mdir_cmp(&o->mdir, mdir) == 0 + && lfs3_mrid(lfs3, o->mdir.mid) == a_rid // is a bshrub? - && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o)) { - lfs_ssize_t dsize__ = lfsr_shrub_estimate(lfs, - &((lfsr_bshrub_t*)o)->shrub); + && lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o)) { + lfs3_ssize_t dsize__ = lfs3_shrub_estimate(lfs3, + &((lfs3_bshrub_t*)o)->shrub); if (dsize__ < 0) { return dsize__; } @@ -7987,9 +7989,9 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir, return mdir_dsize + a_dsize + b_dsize; } -static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, - const lfsr_mdir_t *mdir, lfsr_srid_t start_rid, lfsr_srid_t end_rid) { - // this is basically the same as lfsr_rbyd_compact, but with special +static int lfs3_mdir_compact__(lfs3_t *lfs3, lfs3_mdir_t *mdir_, + const lfs3_mdir_t *mdir, lfs3_srid_t start_rid, lfs3_srid_t end_rid) { + // this is basically the same as lfs3_rbyd_compact, but with special // handling for inlined trees. // // it's really tempting to deduplicate this via recursion! but we @@ -8007,16 +8009,16 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } // copy over tags in the rbyd in order - lfsr_srid_t rid = lfs_smax(start_rid, -1); - lfsr_tag_t tag = 0; + lfs3_srid_t rid = lfs3_smax(start_rid, -1); + lfs3_tag_t tag = 0; while (true) { - lfsr_rid_t weight; - lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, + lfs3_rid_t weight; + lfs3_data_t data; + int err = lfs3_rbyd_lookupnext(lfs3, &mdir->rbyd, rid, tag+1, &rid, &tag, &weight, &data); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -8024,72 +8026,72 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // end of range? note the use of rid+1 and unsigned comparison here to // treat end_rid=-1 as "unbounded" in such a way that rid=-1 is still // included - if ((lfs_size_t)(rid + 1) > (lfs_size_t)end_rid) { + if ((lfs3_size_t)(rid + 1) > (lfs3_size_t)end_rid) { break; } // found an inlined shrub? we need to compact the shrub as well to // bring it along with us - if (tag == LFSR_TAG_BSHRUB) { - lfsr_shrub_t shrub; - err = lfsr_data_readshrub(lfs, &data, mdir, + if (tag == LFS3_TAG_BSHRUB) { + lfs3_shrub_t shrub; + err = lfs3_data_readshrub(lfs3, &data, mdir, &shrub); if (err) { return err; } // compact our shrub - err = lfsr_shrub_compact(lfs, &mdir_->rbyd, &shrub, + err = lfs3_shrub_compact(lfs3, &mdir_->rbyd, &shrub, &shrub); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; } // write the new shrub tag - err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, - LFSR_RATTR_SHRUB(tag, weight, &shrub)); + err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->rbyd, + LFS3_RATTR_SHRUB(tag, weight, &shrub)); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; } } else { // write the tag - err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, - LFSR_RATTR_DATA(tag, weight, &data)); + err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->rbyd, + LFS3_RATTR_DATA(tag, weight, &data)); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; } } } - int err = lfsr_rbyd_appendcompaction(lfs, &mdir_->rbyd, 0); + int err = lfs3_rbyd_appendcompaction(lfs3, &mdir_->rbyd, 0); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; } // we're not quite done! we also need to bring over any unsynced files - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags) + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags) // belongs to our mdir? - && lfsr_mdir_cmp(&o->mdir, mdir) == 0 - && lfsr_mrid(lfs, o->mdir.mid) >= start_rid - && (lfsr_rid_t)lfsr_mrid(lfs, o->mdir.mid) - < (lfsr_rid_t)end_rid + && lfs3_mdir_cmp(&o->mdir, mdir) == 0 + && lfs3_mrid(lfs3, o->mdir.mid) >= start_rid + && (lfs3_rid_t)lfs3_mrid(lfs3, o->mdir.mid) + < (lfs3_rid_t)end_rid // is a bshrub? - && lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o) + && lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o) // only compact once, first compact should // stage the new block - && ((lfsr_bshrub_t*)o)->shrub_.blocks[0] + && ((lfs3_bshrub_t*)o)->shrub_.blocks[0] != mdir_->rbyd.blocks[0]) { - int err = lfsr_shrub_compact(lfs, &mdir_->rbyd, - &((lfsr_bshrub_t*)o)->shrub_, - &((lfsr_bshrub_t*)o)->shrub); + int err = lfs3_shrub_compact(lfs3, &mdir_->rbyd, + &((lfs3_bshrub_t*)o)->shrub_, + &((lfs3_bshrub_t*)o)->shrub); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; } } @@ -8099,20 +8101,20 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } // mid-level mdir commit, this one will at least compact on overflow -static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir, - lfsr_srid_t start_rid, lfsr_srid_t end_rid, - lfsr_srid_t *split_rid_, - lfsr_smid_t mid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { +static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, + lfs3_srid_t start_rid, lfs3_srid_t end_rid, + lfs3_srid_t *split_rid_, + lfs3_smid_t mid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // make a copy - lfsr_mdir_t mdir_ = *mdir; + lfs3_mdir_t mdir_ = *mdir; // mark as erased in case of failure - lfsr_mdir_claim(mdir); + lfs3_mdir_claim(mdir); // try to commit - int err = lfsr_mdir_commit__(lfs, &mdir_, start_rid, end_rid, + int err = lfs3_mdir_commit__(lfs3, &mdir_, start_rid, end_rid, mid, rattrs, rattr_count); if (err) { - if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_RANGE || err == LFS3_ERR_CORRUPT) { goto compact; } return err; @@ -8128,22 +8130,22 @@ compact:; bool overrecyclable = true; // check if we're within our compaction threshold - lfs_ssize_t estimate = lfsr_mdir_estimate__(lfs, mdir, start_rid, end_rid, + lfs3_ssize_t estimate = lfs3_mdir_estimate__(lfs3, mdir, start_rid, end_rid, split_rid_); if (estimate < 0) { return estimate; } // TODO do we need to include mdir commit overhead here? in rbyd_estimate? - if ((lfs_size_t)estimate > lfs->cfg->block_size/2) { - return LFS_ERR_RANGE; + if ((lfs3_size_t)estimate > lfs3->cfg->block_size/2) { + return LFS3_ERR_RANGE; } // swap blocks, increment revision count - err = lfsr_mdir_swap__(lfs, &mdir_, mdir, false); + err = lfs3_mdir_swap__(lfs3, &mdir_, mdir, false); if (err) { - if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { - overrecyclable &= (err != LFS_ERR_CORRUPT); + if (err == LFS3_ERR_NOSPC || err == LFS3_ERR_CORRUPT) { + overrecyclable &= (err != LFS3_ERR_CORRUPT); goto relocate; } return err; @@ -8151,26 +8153,26 @@ compact:; while (true) { // try to compact - #ifdef LFS_DBGMDIRCOMMITS - LFS_DEBUG("Compacting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " + #ifdef LFS3_DBGMDIRCOMMITS + LFS3_DEBUG("Compacting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]); #endif // don't copy over gcksum if relocating - lfsr_srid_t start_rid_ = start_rid; + lfs3_srid_t start_rid_ = start_rid; if (relocated) { - start_rid_ = lfs_smax(start_rid_, -1); + start_rid_ = lfs3_smax(start_rid_, -1); } // compact our mdir - err = lfsr_mdir_compact__(lfs, &mdir_, mdir, start_rid_, end_rid); + err = lfs3_mdir_compact__(lfs3, &mdir_, mdir, start_rid_, end_rid); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { overrecyclable &= relocated; goto relocate; } @@ -8181,12 +8183,12 @@ compact:; // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_mdir_commit__(lfs, &mdir_, start_rid_, end_rid, + err = lfs3_mdir_commit__(lfs3, &mdir_, start_rid_, end_rid, mid, rattrs, rattr_count); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { overrecyclable &= relocated; goto relocate; } @@ -8195,7 +8197,7 @@ compact:; // consume gcksumdelta if relocated if (relocated) { - lfs->gcksum_d ^= mdir->gcksumdelta; + lfs3->gcksum_d ^= mdir->gcksumdelta; } // update mdir *mdir = mdir_; @@ -8203,29 +8205,29 @@ compact:; relocate:; // needs relocation? bad prog? ok, try allocating a new mdir - err = lfsr_mdir_alloc__(lfs, &mdir_, mdir->mid, relocated); - if (err && !(err == LFS_ERR_NOSPC && overrecyclable)) { + err = lfs3_mdir_alloc__(lfs3, &mdir_, mdir->mid, relocated); + if (err && !(err == LFS3_ERR_NOSPC && overrecyclable)) { return err; } relocated = true; // no more blocks? wear-leveling falls apart here, but we can try // without relocating - if (err == LFS_ERR_NOSPC) { - LFS_WARN("Overrecycling mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir->mid), + if (err == LFS3_ERR_NOSPC) { + LFS3_WARN("Overrecycling mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]); relocated = false; overrecyclable = false; - err = lfsr_mdir_swap__(lfs, &mdir_, mdir, true); + err = lfs3_mdir_swap__(lfs3, &mdir_, mdir, true); if (err) { // bad prog? can't do much here, mdir stuck - if (err == LFS_ERR_CORRUPT) { - LFS_ERROR("Stuck mdir 0x{%"PRIx32",%"PRIx32"}", + if (err == LFS3_ERR_CORRUPT) { + LFS3_ERROR("Stuck mdir 0x{%"PRIx32",%"PRIx32"}", mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]); - return LFS_ERR_NOSPC; + return LFS3_ERR_NOSPC; } return err; } @@ -8233,160 +8235,160 @@ compact:; } } -static int lfsr_mroot_parent(lfs_t *lfs, const lfs_block_t mptr[static 2], - lfsr_mdir_t *mparent_) { +static int lfs3_mroot_parent(lfs3_t *lfs3, const lfs3_block_t mptr[static 2], + lfs3_mdir_t *mparent_) { // we only call this when we actually have parents - LFS_ASSERT(!lfsr_mptr_ismrootanchor(mptr)); + LFS3_ASSERT(!lfs3_mptr_ismrootanchor(mptr)); // scan list of mroots for our requested pair - lfs_block_t mptr_[2] = { - LFSR_MPTR_MROOTANCHOR()[0], - LFSR_MPTR_MROOTANCHOR()[1]}; + lfs3_block_t mptr_[2] = { + LFS3_MPTR_MROOTANCHOR()[0], + LFS3_MPTR_MROOTANCHOR()[1]}; while (true) { // fetch next possible superblock - lfsr_mdir_t mdir; - int err = lfsr_mdir_fetch(lfs, &mdir, -1, mptr_); + lfs3_mdir_t mdir; + int err = lfs3_mdir_fetch(lfs3, &mdir, -1, mptr_); if (err) { return err; } // lookup next mroot - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_MROOT, + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, &mdir, LFS3_TAG_MROOT, NULL, &data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // decode mdir - err = lfsr_data_readmptr(lfs, &data, mptr_); + err = lfs3_data_readmptr(lfs3, &data, mptr_); if (err) { return err; } // found our child? - if (lfsr_mptr_cmp(mptr_, mptr) == 0) { + if (lfs3_mptr_cmp(mptr_, mptr) == 0) { *mparent_ = mdir; return 0; } } } -// needed in lfsr_mdir_commit -static inline void lfsr_file_discardleaf(lfsr_file_t *file); +// needed in lfs3_mdir_commit +static inline void lfs3_file_discardleaf(lfs3_file_t *file); // high-level mdir commit // -// this is atomic and updates any opened mdirs, lfs_t, etc +// this is atomic and updates any opened mdirs, lfs3_t, etc // // note that if an error occurs, any gstate is reverted to the on-disk // state // -static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, - const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { +static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir, + const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { // non-mroot mdirs must have weight - LFS_ASSERT(mdir->mid == -1 + LFS3_ASSERT(mdir->mid == -1 // note inlined mdirs are mroots with mid != -1 - || lfsr_mdir_cmp(mdir, &lfs->mroot) == 0 + || lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0 || mdir->rbyd.weight > 0); // rid in-bounds? - LFS_ASSERT(lfsr_mrid(lfs, mdir->mid) - <= (lfsr_srid_t)mdir->rbyd.weight); - // lfs->mroot must have mid=-1 - LFS_ASSERT(lfs->mroot.mid == -1); + LFS3_ASSERT(lfs3_mrid(lfs3, mdir->mid) + <= (lfs3_srid_t)mdir->rbyd.weight); + // lfs3->mroot must have mid=-1 + LFS3_ASSERT(lfs3->mroot.mid == -1); // play out any rattrs that affect our grm _before_ committing to disk, // keep in mind we revert to on-disk gstate if we run into an error - lfsr_smid_t mid_ = mdir->mid; - for (lfs_size_t i = 0; i < rattr_count; i++) { + lfs3_smid_t mid_ = mdir->mid; + for (lfs3_size_t i = 0; i < rattr_count; i++) { // push a new grm, this tag lets us push grms atomically when // creating new mids - if (rattrs[i].tag == LFSR_TAG_GRMPUSH) { - lfsr_grm_push(lfs, mid_); + if (rattrs[i].tag == LFS3_TAG_GRMPUSH) { + lfs3_grm_push(lfs3, mid_); // adjust pending grms? } else { for (int j = 0; j < 2; j++) { - if (lfsr_mbid(lfs, lfs->grm.queue[j]) == lfsr_mbid(lfs, mid_) - && lfs->grm.queue[j] >= mid_) { + if (lfs3_mbid(lfs3, lfs3->grm.queue[j]) == lfs3_mbid(lfs3, mid_) + && lfs3->grm.queue[j] >= mid_) { // deleting a pending grm doesn't really make sense - LFS_ASSERT(lfs->grm.queue[j] >= mid_ - rattrs[i].weight); + LFS3_ASSERT(lfs3->grm.queue[j] >= mid_ - rattrs[i].weight); // adjust the grm - lfs->grm.queue[j] += rattrs[i].weight; + lfs3->grm.queue[j] += rattrs[i].weight; } } } // adjust mid - mid_ = lfsr_rattr_nextrid(rattrs[i], mid_); + mid_ = lfs3_rattr_nextrid(rattrs[i], mid_); } // flush gdeltas - lfsr_fs_flushgdelta(lfs); + lfs3_fs_flushgdelta(lfs3); // xor our old cksum - lfs->gcksum ^= mdir->rbyd.cksum; + lfs3->gcksum ^= mdir->rbyd.cksum; // stage any bshrubs - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_isbshrub(o->flags)) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_isbshrub(o->flags)) { // a bshrub outside of its mdir means something has gone // horribly wrong - LFS_ASSERT(!lfsr_bshrub_isbshrub((lfsr_bshrub_t*)o) - || ((lfsr_bshrub_t*)o)->shrub.blocks[0] + LFS3_ASSERT(!lfs3_bshrub_isbshrub((lfs3_bshrub_t*)o) + || ((lfs3_bshrub_t*)o)->shrub.blocks[0] == o->mdir.rbyd.blocks[0]); - ((lfsr_bshrub_t*)o)->shrub_ = ((lfsr_bshrub_t*)o)->shrub; + ((lfs3_bshrub_t*)o)->shrub_ = ((lfs3_bshrub_t*)o)->shrub; } } // create a copy - lfsr_mdir_t mdir_[2]; + lfs3_mdir_t mdir_[2]; mdir_[0] = *mdir; // mark our mdir as unerased in case we fail - lfsr_mdir_claim(mdir); + lfs3_mdir_claim(mdir); // mark any copies of our mdir as unerased in case we fail - if (lfsr_mdir_cmp(mdir, &lfs->mroot) == 0) { - lfsr_mdir_claim(&lfs->mroot); + if (lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0) { + lfs3_mdir_claim(&lfs3->mroot); } - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_mdir_cmp(&o->mdir, mdir) == 0) { - lfsr_mdir_claim(&o->mdir); + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_mdir_cmp(&o->mdir, mdir) == 0) { + lfs3_mdir_claim(&o->mdir); } } // attempt to commit/compact the mdir normally - lfsr_srid_t split_rid; - int err = lfsr_mdir_commit_(lfs, &mdir_[0], -2, -1, &split_rid, + lfs3_srid_t split_rid; + int err = lfs3_mdir_commit_(lfs3, &mdir_[0], -2, -1, &split_rid, mdir->mid, rattrs, rattr_count); - if (err && err != LFS_ERR_RANGE - && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_RANGE + && err != LFS3_ERR_NOENT) { goto failed; } // keep track of any mroot changes - lfsr_mdir_t mroot_ = lfs->mroot; - if (!err && lfsr_mdir_cmp(mdir, &lfs->mroot) == 0) { - lfsr_mdir_sync(&mroot_, &mdir_[0]); + lfs3_mdir_t mroot_ = lfs3->mroot; + if (!err && lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0) { + lfs3_mdir_sync(&mroot_, &mdir_[0]); } // handle possible mtree updates, this gets a bit messy - lfsr_btree_t mtree_ = lfs->mtree; - lfsr_smid_t mdelta = 0; + lfs3_btree_t mtree_ = lfs3->mtree; + lfs3_smid_t mdelta = 0; // need to split? - if (err == LFS_ERR_RANGE) { + if (err == LFS3_ERR_RANGE) { // this should not happen unless we can't fit our mroot's metadata - LFS_ASSERT(lfsr_mdir_cmp(mdir, &lfs->mroot) != 0 - || lfs->mtree.weight == 0); + LFS3_ASSERT(lfs3_mdir_cmp(mdir, &lfs3->mroot) != 0 + || lfs3->mtree.weight == 0); // if we're not the mroot, we need to consume the gstate so // we don't lose any info during the split // // we do this here so we don't have to worry about corner cases // with dropping mdirs during a split - if (lfsr_mdir_cmp(mdir, &lfs->mroot) != 0) { - err = lfsr_fs_consumegdelta(lfs, mdir); + if (lfs3_mdir_cmp(mdir, &lfs3->mroot) != 0) { + err = lfs3_fs_consumegdelta(lfs3, mdir); if (err) { goto failed; } @@ -8396,55 +8398,55 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // order the split compacts so that that mdir containing our mid // is committed last, this is a bit of a hack but necessary so // shrubs are staged correctly - bool l = (lfsr_mrid(lfs, mdir->mid) < split_rid); + bool l = (lfs3_mrid(lfs3, mdir->mid) < split_rid); bool relocated = false; split_relocate:; // alloc and compact into new mdirs - err = lfsr_mdir_alloc__(lfs, &mdir_[i^l], - lfs_smax(mdir->mid, 0), relocated); + err = lfs3_mdir_alloc__(lfs3, &mdir_[i^l], + lfs3_smax(mdir->mid, 0), relocated); if (err) { goto failed; } relocated = true; - err = lfsr_mdir_compact__(lfs, &mdir_[i^l], + err = lfs3_mdir_compact__(lfs3, &mdir_[i^l], mdir, ((i^l) == 0) ? 0 : split_rid, ((i^l) == 0) ? split_rid : -1); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate; } goto failed; } - err = lfsr_mdir_commit__(lfs, &mdir_[i^l], + err = lfs3_mdir_commit__(lfs3, &mdir_[i^l], ((i^l) == 0) ? 0 : split_rid, ((i^l) == 0) ? split_rid : -1, mdir->mid, rattrs, rattr_count); - if (err && err != LFS_ERR_NOENT) { - LFS_ASSERT(err != LFS_ERR_RANGE); + if (err && err != LFS3_ERR_NOENT) { + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto split_relocate; } goto failed; } // empty? set weight to zero - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { mdir_[i^l].rbyd.weight = 0; } } // adjust our sibling's mid after committing rattrs - mdir_[1].mid += (1 << lfs->mbits); + mdir_[1].mid += (1 << lfs3->mbits); - LFS_INFO("Splitting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " + LFS3_INFO("Splitting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}, 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1], mdir_[1].rbyd.blocks[0], mdir_[1].rbyd.blocks[1]); @@ -8454,60 +8456,60 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // both siblings reduced to zero if (mdir_[0].rbyd.weight == 0 && mdir_[1].rbyd.weight == 0) { - LFS_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir_[0].mid), + LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", + lfs3_dbgmbid(lfs3, mdir_[0].mid), mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1]); - LFS_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir_[1].mid), + LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", + lfs3_dbgmbid(lfs3, mdir_[1].mid), mdir_[1].rbyd.blocks[0], mdir_[1].rbyd.blocks[1]); goto dropped; // one sibling reduced to zero } else if (mdir_[0].rbyd.weight == 0) { - LFS_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir_[0].mid), + LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", + lfs3_dbgmbid(lfs3, mdir_[0].mid), mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1]); - lfsr_mdir_sync(&mdir_[0], &mdir_[1]); + lfs3_mdir_sync(&mdir_[0], &mdir_[1]); goto relocated; // other sibling reduced to zero } else if (mdir_[1].rbyd.weight == 0) { - LFS_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir_[1].mid), + LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", + lfs3_dbgmbid(lfs3, mdir_[1].mid), mdir_[1].rbyd.blocks[0], mdir_[1].rbyd.blocks[1]); goto relocated; } // no siblings reduced to zero, update our mtree - mdelta = +(1 << lfs->mbits); + mdelta = +(1 << lfs3->mbits); // lookup first name in sibling to use as the split name // // note we need to do this after playing out pending rattrs in // case they introduce a new name! - lfsr_data_t split_name; - err = lfsr_rbyd_lookup(lfs, &mdir_[1].rbyd, 0, - LFSR_TAG_MASK8 | LFSR_TAG_NAME, + lfs3_data_t split_name; + err = lfs3_rbyd_lookup(lfs3, &mdir_[1].rbyd, 0, + LFS3_TAG_MASK8 | LFS3_TAG_NAME, NULL, &split_name); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); goto failed; } // new mtree? - if (lfs->mtree.weight == 0) { - lfsr_btree_init(&mtree_); + if (lfs3->mtree.weight == 0) { + lfs3_btree_init(&mtree_); - err = lfsr_mtree_commit(lfs, &mtree_, - 0, LFSR_RATTRS( - LFSR_RATTR_MPTR( - LFSR_TAG_MDIR, +(1 << lfs->mbits), + err = lfs3_mtree_commit(lfs3, &mtree_, + 0, LFS3_RATTRS( + LFS3_RATTR_MPTR( + LFS3_TAG_MDIR, +(1 << lfs3->mbits), mdir_[0].rbyd.blocks), - LFSR_RATTR_DATA( - LFSR_TAG_MNAME, +(1 << lfs->mbits), + LFS3_RATTR_DATA( + LFS3_TAG_MNAME, +(1 << lfs3->mbits), &split_name), - LFSR_RATTR_MPTR( - LFSR_TAG_MDIR, 0, + LFS3_RATTR_MPTR( + LFS3_TAG_MDIR, 0, mdir_[1].rbyd.blocks))); if (err) { goto failed; @@ -8516,18 +8518,18 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree } else { // mark as unerased in case of failure - lfsr_btree_claim(&lfs->mtree); + lfs3_btree_claim(&lfs3->mtree); - err = lfsr_mtree_commit(lfs, &mtree_, - lfsr_mbid(lfs, mdir->mid), LFSR_RATTRS( - LFSR_RATTR_MPTR( - LFSR_TAG_MDIR, 0, + err = lfs3_mtree_commit(lfs3, &mtree_, + lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS( + LFS3_RATTR_MPTR( + LFS3_TAG_MDIR, 0, mdir_[0].rbyd.blocks), - LFSR_RATTR_DATA( - LFSR_TAG_MNAME, +(1 << lfs->mbits), + LFS3_RATTR_DATA( + LFS3_TAG_MNAME, +(1 << lfs3->mbits), &split_name), - LFSR_RATTR_MPTR( - LFSR_TAG_MDIR, 0, + LFS3_RATTR_MPTR( + LFS3_TAG_MDIR, 0, mdir_[1].rbyd.blocks))); if (err) { goto failed; @@ -8535,55 +8537,55 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // need to drop? - } else if (err == LFS_ERR_NOENT) { - LFS_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir->mid), + } else if (err == LFS3_ERR_NOENT) { + LFS3_INFO("Dropping mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"}", + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]); // set weight to zero mdir_[0].rbyd.weight = 0; // consume gstate so we don't lose any info - err = lfsr_fs_consumegdelta(lfs, mdir); + err = lfs3_fs_consumegdelta(lfs3, mdir); if (err) { goto failed; } dropped:; - mdelta = -(1 << lfs->mbits); + mdelta = -(1 << lfs3->mbits); // how can we drop if we have no mtree? - LFS_ASSERT(lfs->mtree.weight != 0); + LFS3_ASSERT(lfs3->mtree.weight != 0); // mark as unerased in case of failure - lfsr_btree_claim(&lfs->mtree); + lfs3_btree_claim(&lfs3->mtree); // update our mtree - err = lfsr_mtree_commit(lfs, &mtree_, - lfsr_mbid(lfs, mdir->mid), LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM, -(1 << lfs->mbits)))); + err = lfs3_mtree_commit(lfs3, &mtree_, + lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM, -(1 << lfs3->mbits)))); if (err) { goto failed; } // need to relocate? - } else if (lfsr_mdir_cmp(&mdir_[0], mdir) != 0 - && lfsr_mdir_cmp(mdir, &lfs->mroot) != 0) { - LFS_INFO("Relocating mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " + } else if (lfs3_mdir_cmp(&mdir_[0], mdir) != 0 + && lfs3_mdir_cmp(mdir, &lfs3->mroot) != 0) { + LFS3_INFO("Relocating mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}", - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], mdir_[0].rbyd.blocks[0], mdir_[0].rbyd.blocks[1]); relocated:; // new mtree? - if (lfs->mtree.weight == 0) { - lfsr_btree_init(&mtree_); + if (lfs3->mtree.weight == 0) { + lfs3_btree_init(&mtree_); - err = lfsr_mtree_commit(lfs, &mtree_, - 0, LFSR_RATTRS( - LFSR_RATTR_MPTR( - LFSR_TAG_MDIR, +(1 << lfs->mbits), + err = lfs3_mtree_commit(lfs3, &mtree_, + 0, LFS3_RATTRS( + LFS3_RATTR_MPTR( + LFS3_TAG_MDIR, +(1 << lfs3->mbits), mdir_[0].rbyd.blocks))); if (err) { goto failed; @@ -8592,12 +8594,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree } else { // mark as unerased in case of failure - lfsr_btree_claim(&lfs->mtree); + lfs3_btree_claim(&lfs3->mtree); - err = lfsr_mtree_commit(lfs, &mtree_, - lfsr_mbid(lfs, mdir->mid), LFSR_RATTRS( - LFSR_RATTR_MPTR( - LFSR_TAG_MDIR, 0, + err = lfs3_mtree_commit(lfs3, &mtree_, + lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS( + LFS3_RATTR_MPTR( + LFS3_TAG_MDIR, 0, mdir_[0].rbyd.blocks))); if (err) { goto failed; @@ -8607,41 +8609,41 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // patch any pending grms for (int j = 0; j < 2; j++) { - if (lfsr_mbid(lfs, lfs->grm.queue[j]) - == lfsr_mbid(lfs, lfs_smax(mdir->mid, 0))) { + if (lfs3_mbid(lfs3, lfs3->grm.queue[j]) + == lfs3_mbid(lfs3, lfs3_smax(mdir->mid, 0))) { if (mdelta > 0 - && lfsr_mrid(lfs, lfs->grm.queue[j]) - >= (lfsr_srid_t)mdir_[0].rbyd.weight) { - lfs->grm.queue[j] - += (1 << lfs->mbits) - mdir_[0].rbyd.weight; + && lfs3_mrid(lfs3, lfs3->grm.queue[j]) + >= (lfs3_srid_t)mdir_[0].rbyd.weight) { + lfs3->grm.queue[j] + += (1 << lfs3->mbits) - mdir_[0].rbyd.weight; } - } else if (lfs->grm.queue[j] > mdir->mid) { - lfs->grm.queue[j] += mdelta; + } else if (lfs3->grm.queue[j] > mdir->mid) { + lfs3->grm.queue[j] += mdelta; } } // need to update mtree? - if (lfsr_btree_cmp(&mtree_, &lfs->mtree) != 0) { + if (lfs3_btree_cmp(&mtree_, &lfs3->mtree) != 0) { // mtree should never go to zero since we always have a root bookmark - LFS_ASSERT(mtree_.weight > 0); + LFS3_ASSERT(mtree_.weight > 0); // make sure mtree/mroot changes are on-disk before committing // metadata - err = lfsr_bd_sync(lfs); + err = lfs3_bd_sync(lfs3); if (err) { goto failed; } // xor mroot's cksum if we haven't already - if (lfsr_mdir_cmp(mdir, &lfs->mroot) != 0) { - lfs->gcksum ^= lfs->mroot.rbyd.cksum; + if (lfs3_mdir_cmp(mdir, &lfs3->mroot) != 0) { + lfs3->gcksum ^= lfs3->mroot.rbyd.cksum; } // mark any copies of our mroot as unerased - lfsr_mdir_claim(&lfs->mroot); - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_mdir_cmp(&o->mdir, &lfs->mroot) == 0) { - lfsr_mdir_claim(&o->mdir); + lfs3_mdir_claim(&lfs3->mroot); + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_mdir_cmp(&o->mdir, &lfs3->mroot) == 0) { + lfs3_mdir_claim(&o->mdir); } } @@ -8649,38 +8651,38 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // // note end_rid=0 here will delete any files leftover from a split // in our mroot - err = lfsr_mdir_commit_(lfs, &mroot_, -2, 0, NULL, - -1, LFSR_RATTRS( - LFSR_RATTR_BTREE( - LFSR_TAG_MASK8 | LFSR_TAG_MTREE, 0, + err = lfs3_mdir_commit_(lfs3, &mroot_, -2, 0, NULL, + -1, LFS3_RATTRS( + LFS3_RATTR_BTREE( + LFS3_TAG_MASK8 | LFS3_TAG_MTREE, 0, &mtree_), // were we committing to the mroot? include any -1 rattrs (mdir->mid == -1) - ? LFSR_RATTR_RATTRS(rattrs, rattr_count) - : LFSR_RATTR_NOOP())); + ? LFS3_RATTR_RATTRS(rattrs, rattr_count) + : LFS3_RATTR_NOOP())); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); goto failed; } } // need to update mroot chain? - if (lfsr_mdir_cmp(&mroot_, &lfs->mroot) != 0) { + if (lfs3_mdir_cmp(&mroot_, &lfs3->mroot) != 0) { // tail recurse, updating mroots until a commit sticks - lfsr_mdir_t mrootchild = lfs->mroot; - lfsr_mdir_t mrootchild_ = mroot_; - while (lfsr_mdir_cmp(&mrootchild_, &mrootchild) != 0 - && !lfsr_mdir_ismrootanchor(&mrootchild)) { + lfs3_mdir_t mrootchild = lfs3->mroot; + lfs3_mdir_t mrootchild_ = mroot_; + while (lfs3_mdir_cmp(&mrootchild_, &mrootchild) != 0 + && !lfs3_mdir_ismrootanchor(&mrootchild)) { // find the mroot's parent - lfsr_mdir_t mrootparent_; - err = lfsr_mroot_parent(lfs, mrootchild.rbyd.blocks, + lfs3_mdir_t mrootparent_; + err = lfs3_mroot_parent(lfs3, mrootchild.rbyd.blocks, &mrootparent_); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); goto failed; } - LFS_INFO("Relocating mroot 0x{%"PRIx32",%"PRIx32"} " + LFS3_INFO("Relocating mroot 0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}", mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1], mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]); @@ -8689,23 +8691,23 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // make sure mtree/mroot changes are on-disk before committing // metadata - err = lfsr_bd_sync(lfs); + err = lfs3_bd_sync(lfs3); if (err) { goto failed; } // xor mrootchild's cksum - lfs->gcksum ^= mrootparent_.rbyd.cksum; + lfs3->gcksum ^= mrootparent_.rbyd.cksum; // commit mrootchild - err = lfsr_mdir_commit_(lfs, &mrootparent_, -2, -1, NULL, - -1, LFSR_RATTRS( - LFSR_RATTR_MPTR( - LFSR_TAG_MROOT, 0, + err = lfs3_mdir_commit_(lfs3, &mrootparent_, -2, -1, NULL, + -1, LFS3_RATTRS( + LFS3_RATTR_MPTR( + LFS3_TAG_MROOT, 0, mrootchild_.rbyd.blocks))); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_NOENT); goto failed; } @@ -8713,10 +8715,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // no more mroot parents? uh oh, need to extend mroot chain - if (lfsr_mdir_cmp(&mrootchild_, &mrootchild) != 0) { + if (lfs3_mdir_cmp(&mrootchild_, &mrootchild) != 0) { // mrootchild should be our previous mroot anchor at this point - LFS_ASSERT(lfsr_mdir_ismrootanchor(&mrootchild)); - LFS_INFO("Extending mroot 0x{%"PRIx32",%"PRIx32"}" + LFS3_ASSERT(lfs3_mdir_ismrootanchor(&mrootchild)); + LFS3_INFO("Extending mroot 0x{%"PRIx32",%"PRIx32"}" " -> 0x{%"PRIx32",%"PRIx32"}, 0x{%"PRIx32",%"PRIx32"}", mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1], mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1], @@ -8724,42 +8726,42 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // make sure mtree/mroot changes are on-disk before committing // metadata - err = lfsr_bd_sync(lfs); + err = lfs3_bd_sync(lfs3); if (err) { goto failed; } // commit the new mroot anchor - lfsr_mdir_t mrootanchor_; - err = lfsr_mdir_swap__(lfs, &mrootanchor_, &mrootchild, true); + lfs3_mdir_t mrootanchor_; + err = lfs3_mdir_swap__(lfs3, &mrootanchor_, &mrootchild, true); if (err) { // bad prog? can't do much here, mroot stuck - if (err == LFS_ERR_CORRUPT) { - LFS_ERROR("Stuck mroot 0x{%"PRIx32",%"PRIx32"}", + if (err == LFS3_ERR_CORRUPT) { + LFS3_ERROR("Stuck mroot 0x{%"PRIx32",%"PRIx32"}", mrootanchor_.rbyd.blocks[0], mrootanchor_.rbyd.blocks[1]); - return LFS_ERR_NOSPC; + return LFS3_ERR_NOSPC; } goto failed; } - err = lfsr_mdir_commit__(lfs, &mrootanchor_, -2, -1, - -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MAGIC, 0, + err = lfs3_mdir_commit__(lfs3, &mrootanchor_, -2, -1, + -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MAGIC, 0, "littlefs", 8), - LFSR_RATTR_MPTR( - LFSR_TAG_MROOT, 0, + LFS3_RATTR_MPTR( + LFS3_TAG_MROOT, 0, mrootchild_.rbyd.blocks))); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_NOENT); // bad prog? can't do much here, mroot stuck - if (err == LFS_ERR_CORRUPT) { - LFS_ERROR("Stuck mroot 0x{%"PRIx32",%"PRIx32"}", + if (err == LFS3_ERR_CORRUPT) { + LFS3_ERROR("Stuck mroot 0x{%"PRIx32",%"PRIx32"}", mrootanchor_.rbyd.blocks[0], mrootanchor_.rbyd.blocks[1]); - return LFS_ERR_NOSPC; + return LFS3_ERR_NOSPC; } goto failed; } @@ -8767,7 +8769,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // sync on-disk state - err = lfsr_bd_sync(lfs); + err = lfs3_bd_sync(lfs3); if (err) { return err; } @@ -8778,17 +8780,17 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // play out any rattrs that affect internal state mid_ = mdir->mid; - for (lfs_size_t i = 0; i < rattr_count; i++) { + for (lfs3_size_t i = 0; i < rattr_count; i++) { // adjust any opened mdirs - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // adjust opened mdirs? - if (lfsr_mdir_cmp(&o->mdir, mdir) == 0 + if (lfs3_mdir_cmp(&o->mdir, mdir) == 0 && o->mdir.mid >= mid_) { // removed? if (o->mdir.mid < mid_ - rattrs[i].weight) { // we should not be removing opened regular files - LFS_ASSERT(lfsr_o_type(o->flags) != LFS_TYPE_REG); - o->flags |= LFS_o_ZOMBIE; + LFS3_ASSERT(lfs3_o_type(o->flags) != LFS3_TYPE_REG); + o->flags |= LFS3_o_ZOMBIE; o->mdir.mid = mid_; } else { o->mdir.mid += rattrs[i].weight; @@ -8797,39 +8799,39 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // adjust mid - mid_ = lfsr_rattr_nextrid(rattrs[i], mid_); + mid_ = lfs3_rattr_nextrid(rattrs[i], mid_); } // if mroot/mtree changed, clobber any mroot/mtree traversals - if (lfsr_mdir_cmp(&mroot_, &lfs->mroot) != 0 - || lfsr_btree_cmp(&mtree_, &lfs->mtree) != 0) { - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_type(o->flags) == LFS_type_TRAVERSAL + if (lfs3_mdir_cmp(&mroot_, &lfs3->mroot) != 0 + || lfs3_btree_cmp(&mtree_, &lfs3->mtree) != 0) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_type(o->flags) == LFS3_type_TRAVERSAL && o->mdir.mid == -1 // don't clobber the current mdir, assume upper layers // know what they're doing && &o->mdir != mdir) { - lfsr_traversal_clobber(lfs, (lfsr_traversal_t*)o); + lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)o); } } } // update internal mdir state - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // avoid double updating the current mdir if (&o->mdir == mdir) { continue; } // update any splits/drops - if (lfsr_mdir_cmp(&o->mdir, mdir) == 0) { + if (lfs3_mdir_cmp(&o->mdir, mdir) == 0) { if (mdelta > 0 - && lfsr_mrid(lfs, o->mdir.mid) - >= (lfsr_srid_t)mdir_[0].rbyd.weight) { - o->mdir.mid += (1 << lfs->mbits) - mdir_[0].rbyd.weight; - lfsr_mdir_sync(&o->mdir, &mdir_[1]); + && lfs3_mrid(lfs3, o->mdir.mid) + >= (lfs3_srid_t)mdir_[0].rbyd.weight) { + o->mdir.mid += (1 << lfs3->mbits) - mdir_[0].rbyd.weight; + lfs3_mdir_sync(&o->mdir, &mdir_[1]); } else { - lfsr_mdir_sync(&o->mdir, &mdir_[0]); + lfs3_mdir_sync(&o->mdir, &mdir_[0]); } } else if (o->mdir.mid > mdir->mid) { o->mdir.mid += mdelta; @@ -8839,55 +8841,55 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update mdir to follow requested rid if (mdelta > 0 && mdir->mid == -1) { - lfsr_mdir_sync(mdir, &mroot_); + lfs3_mdir_sync(mdir, &mroot_); } else if (mdelta > 0 - && lfsr_mrid(lfs, mdir->mid) - >= (lfsr_srid_t)mdir_[0].rbyd.weight) { - mdir->mid += (1 << lfs->mbits) - mdir_[0].rbyd.weight; - lfsr_mdir_sync(mdir, &mdir_[1]); + && lfs3_mrid(lfs3, mdir->mid) + >= (lfs3_srid_t)mdir_[0].rbyd.weight) { + mdir->mid += (1 << lfs3->mbits) - mdir_[0].rbyd.weight; + lfs3_mdir_sync(mdir, &mdir_[1]); } else { - lfsr_mdir_sync(mdir, &mdir_[0]); + lfs3_mdir_sync(mdir, &mdir_[0]); } // update mroot and mtree - lfsr_mdir_sync(&lfs->mroot, &mroot_); - lfs->mtree = mtree_; + lfs3_mdir_sync(&lfs3->mroot, &mroot_); + lfs3->mtree = mtree_; // update any staged bshrubs - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // if we moved a shrub, we also need to discard any related // leaves that moved - if (lfsr_o_type(o->flags) == LFS_TYPE_REG - && lfsr_bptr_block(&((lfsr_file_t*)o)->leaf.bptr) - == ((lfsr_bshrub_t*)o)->shrub.blocks[0] - && ((lfsr_bshrub_t*)o)->shrub_.blocks[0] - != ((lfsr_bshrub_t*)o)->shrub.blocks[0]) { - lfsr_file_discardleaf((lfsr_file_t*)o); + if (lfs3_o_type(o->flags) == LFS3_TYPE_REG + && lfs3_bptr_block(&((lfs3_file_t*)o)->leaf.bptr) + == ((lfs3_bshrub_t*)o)->shrub.blocks[0] + && ((lfs3_bshrub_t*)o)->shrub_.blocks[0] + != ((lfs3_bshrub_t*)o)->shrub.blocks[0]) { + lfs3_file_discardleaf((lfs3_file_t*)o); } // update the shrub - if (lfsr_o_isbshrub(o->flags)) { - ((lfsr_bshrub_t*)o)->shrub = ((lfsr_bshrub_t*)o)->shrub_; + if (lfs3_o_isbshrub(o->flags)) { + ((lfs3_bshrub_t*)o)->shrub = ((lfs3_bshrub_t*)o)->shrub_; } } // update any gstate changes - lfsr_fs_commitgdelta(lfs); + lfs3_fs_commitgdelta(lfs3); // mark all traversals as dirty - lfsr_fs_clobber(lfs, LFS_t_DIRTY); + lfs3_fs_clobber(lfs3, LFS3_t_DIRTY); // we may have touched any number of mdirs, so assume uncompacted - // until lfsr_fs_gc can prove otherwise - lfs->flags |= LFS_I_COMPACT; + // until lfs3_fs_gc can prove otherwise + lfs3->flags |= LFS3_I_COMPACT; - #ifdef LFS_DBGMDIRCOMMITS - LFS_DEBUG("Committed mdir %"PRId32" " + #ifdef LFS3_DBGMDIRCOMMITS + LFS3_DEBUG("Committed mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32", " "cksum %"PRIx32, - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], - lfsr_rbyd_trunk(&mdir->rbyd), + lfs3_rbyd_trunk(&mdir->rbyd), mdir->rbyd.weight, mdir->rbyd.cksum); #endif @@ -8895,15 +8897,15 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, failed:; // revert gstate to on-disk state - lfsr_fs_revertgdelta(lfs); + lfs3_fs_revertgdelta(lfs3); return err; } -static int lfsr_mdir_compact(lfs_t *lfs, lfsr_mdir_t *mdir) { +static int lfs3_mdir_compact(lfs3_t *lfs3, lfs3_mdir_t *mdir) { // the easiest way to do this is to just mark mdir as unerased - // and call lfsr_mdir_commit - lfsr_mdir_claim(mdir); - return lfsr_mdir_commit(lfs, mdir, NULL, 0); + // and call lfs3_mdir_commit + lfs3_mdir_claim(mdir); + return lfs3_mdir_commit(lfs3, mdir, NULL, 0); } @@ -8913,9 +8915,9 @@ static int lfsr_mdir_compact(lfs_t *lfs, lfsr_mdir_t *mdir) { // lookup names in an mdir // // if not found, rid will be the best place to insert -static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_did_t did, const char *name, lfs_size_t name_len, - lfsr_smid_t *mid_, lfsr_tag_t *tag_, lfsr_data_t *data_) { +static int lfs3_mdir_namelookup(lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_did_t did, const char *name, lfs3_size_t name_len, + lfs3_smid_t *mid_, lfs3_tag_t *tag_, lfs3_data_t *data_) { // default to mid_ = 0, this blanket assignment is the only way to // keep GCC happy if (mid_) { @@ -8924,28 +8926,28 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, // empty mdir? if (mdir->rbyd.weight == 0) { - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } - lfsr_srid_t rid; - lfsr_tag_t tag; - lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd, + lfs3_srid_t rid; + lfs3_tag_t tag; + lfs3_scmp_t cmp = lfs3_rbyd_namelookup(lfs3, &mdir->rbyd, did, name, name_len, &rid, &tag, NULL, data_); if (cmp < 0) { - LFS_ASSERT(cmp != LFS_ERR_NOENT); + LFS3_ASSERT(cmp != LFS3_ERR_NOENT); return cmp; } // adjust mid if necessary // // note missing mids end up pointing to the next mid - lfsr_smid_t mid = LFSR_MID(lfs, + lfs3_smid_t mid = LFS3_MID(lfs3, mdir->mid, - (cmp < LFS_CMP_EQ) ? rid+1 : rid); + (cmp < LFS3_CMP_EQ) ? rid+1 : rid); // map name tags to understood types - tag = lfsr_mdir_nametag(lfs, mdir, mid, tag); + tag = lfs3_mdir_nametag(lfs3, mdir, mid, tag); if (mid_) { *mid_ = mid; @@ -8953,51 +8955,51 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, if (tag_) { *tag_ = tag; } - return (cmp == LFS_CMP_EQ) ? 0 : LFS_ERR_NOENT; + return (cmp == LFS3_CMP_EQ) ? 0 : LFS3_ERR_NOENT; } // lookup names in our mtree // // if not found, rid will be the best place to insert -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_) { +static int lfs3_mtree_namelookup(lfs3_t *lfs3, + lfs3_did_t did, const char *name, lfs3_size_t name_len, + lfs3_mdir_t *mdir_, lfs3_tag_t *tag_, lfs3_data_t *data_) { // do we only have mroot? - if (lfs->mtree.weight == 0) { + if (lfs3->mtree.weight == 0) { // treat inlined mdir as mid=0 mdir_->mid = 0; - lfsr_mdir_sync(mdir_, &lfs->mroot); + lfs3_mdir_sync(mdir_, &lfs3->mroot); // lookup name in actual mtree } else { - lfsr_bid_t bid; - lfsr_srid_t rid; - lfsr_tag_t tag; - lfsr_bid_t weight; - lfsr_data_t data; - lfs_scmp_t cmp = lfsr_btree_namelookupleaf(lfs, &lfs->mtree, + lfs3_bid_t bid; + lfs3_srid_t rid; + lfs3_tag_t tag; + lfs3_bid_t weight; + lfs3_data_t data; + lfs3_scmp_t cmp = lfs3_btree_namelookupleaf(lfs3, &lfs3->mtree, did, name, name_len, &bid, &mdir_->rbyd, &rid, &tag, &weight, &data); if (cmp < 0) { - LFS_ASSERT(cmp != LFS_ERR_NOENT); + LFS3_ASSERT(cmp != LFS3_ERR_NOENT); return cmp; } - LFS_ASSERT(weight == (lfsr_bid_t)(1 << lfs->mbits)); - LFS_ASSERT(tag == LFSR_TAG_MNAME - || tag == LFSR_TAG_MDIR); + LFS3_ASSERT(weight == (lfs3_bid_t)(1 << lfs3->mbits)); + LFS3_ASSERT(tag == LFS3_TAG_MNAME + || tag == LFS3_TAG_MDIR); // if we found an mname, lookup the mdir - if (tag == LFSR_TAG_MNAME) { - int err = lfsr_rbyd_lookup(lfs, &mdir_->rbyd, rid, LFSR_TAG_MDIR, + if (tag == LFS3_TAG_MNAME) { + int err = lfs3_rbyd_lookup(lfs3, &mdir_->rbyd, rid, LFS3_TAG_MDIR, NULL, &data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } } // fetch mdir - int err = lfsr_data_fetchmdir(lfs, &data, bid-((1 << lfs->mbits)-1), + int err = lfs3_data_fetchmdir(lfs3, &data, bid-((1 << lfs3->mbits)-1), mdir_); if (err) { return err; @@ -9005,10 +9007,10 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, } // and lookup name in our mdir - lfsr_smid_t mid; - int err = lfsr_mdir_namelookup(lfs, mdir_, did, name, name_len, + lfs3_smid_t mid; + int err = lfs3_mdir_namelookup(lfs3, mdir_, did, name, name_len, &mid, tag_, data_); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } @@ -9020,21 +9022,21 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, // special directory-ids enum { - LFSR_DID_ROOT = 0, + LFS3_DID_ROOT = 0, }; // some operations on paths -static inline lfs_size_t lfsr_path_namelen(const char *path) { - return lfs_strcspn(path, "/"); +static inline lfs3_size_t lfs3_path_namelen(const char *path) { + return lfs3_strcspn(path, "/"); } -static inline bool lfsr_path_islast(const char *path) { - lfs_size_t name_len = lfsr_path_namelen(path); - return path[name_len + lfs_strspn(path + name_len, "/")] == '\0'; +static inline bool lfs3_path_islast(const char *path) { + lfs3_size_t name_len = lfs3_path_namelen(path); + return path[name_len + lfs3_strspn(path + name_len, "/")] == '\0'; } -static inline bool lfsr_path_isdir(const char *path) { - return path[lfsr_path_namelen(path)] != '\0'; +static inline bool lfs3_path_isdir(const char *path) { + return path[lfs3_path_namelen(path)] != '\0'; } // lookup a full path in our mtree, updating the path as we descend @@ -9042,62 +9044,62 @@ static inline bool lfsr_path_isdir(const char *path) { // the errors get a bit subtle here, and rely on what ends up in the // path/mdir: // - 0 => file found -// - 0, lfsr_path_isdir(path) => dir found +// - 0, lfs3_path_isdir(path) => dir found // - 0, mdir.mid=-1 => root found -// - LFS_ERR_NOENT, lfsr_path_islast(path) => file not found -// - LFS_ERR_NOENT, !lfsr_path_islast(path) => parent not found -// - LFS_ERR_NOTDIR => parent not a dir +// - LFS3_ERR_NOENT, lfs3_path_islast(path) => file not found +// - LFS3_ERR_NOENT, !lfs3_path_islast(path) => parent not found +// - LFS3_ERR_NOTDIR => parent not a dir // // if not found, mdir/did_ will at least be set up with what should be // the parent // -static int lfsr_mtree_pathlookup(lfs_t *lfs, const char **path, - lfsr_mdir_t *mdir_, lfsr_tag_t *tag_, lfsr_did_t *did_) { +static int lfs3_mtree_pathlookup(lfs3_t *lfs3, const char **path, + lfs3_mdir_t *mdir_, lfs3_tag_t *tag_, lfs3_did_t *did_) { // setup root - *mdir_ = lfs->mroot; - lfsr_tag_t tag = LFSR_TAG_DIR; - lfsr_did_t did = LFSR_DID_ROOT; + *mdir_ = lfs3->mroot; + lfs3_tag_t tag = LFS3_TAG_DIR; + lfs3_did_t did = LFS3_DID_ROOT; // we reduce path to a single name if we can find it const char *path_ = *path; // empty paths are not allowed if (path_[0] == '\0') { - return LFS_ERR_INVAL; + return LFS3_ERR_INVAL; } while (true) { // skip slashes if we're a directory - if (tag == LFSR_TAG_DIR) { - path_ += lfs_strspn(path_, "/"); + if (tag == LFS3_TAG_DIR) { + path_ += lfs3_strspn(path_, "/"); } - lfs_size_t name_len = lfs_strcspn(path_, "/"); + lfs3_size_t name_len = lfs3_strcspn(path_, "/"); // skip '.' - if (name_len == 1 && lfs_memcmp(path_, ".", 1) == 0) { + if (name_len == 1 && lfs3_memcmp(path_, ".", 1) == 0) { path_ += name_len; goto next; } // error on unmatched '..', trying to go above root, eh? - if (name_len == 2 && lfs_memcmp(path_, "..", 2) == 0) { - return LFS_ERR_INVAL; + if (name_len == 2 && lfs3_memcmp(path_, "..", 2) == 0) { + return LFS3_ERR_INVAL; } // skip if matched by '..' in name const char *suffix = path_ + name_len; - lfs_size_t suffix_len; + lfs3_size_t suffix_len; int depth = 1; while (true) { - suffix += lfs_strspn(suffix, "/"); - suffix_len = lfs_strcspn(suffix, "/"); + suffix += lfs3_strspn(suffix, "/"); + suffix_len = lfs3_strcspn(suffix, "/"); if (suffix_len == 0) { break; } - if (suffix_len == 1 && lfs_memcmp(suffix, ".", 1) == 0) { + if (suffix_len == 1 && lfs3_memcmp(suffix, ".", 1) == 0) { // noop - } else if (suffix_len == 2 && lfs_memcmp(suffix, "..", 2) == 0) { + } else if (suffix_len == 2 && lfs3_memcmp(suffix, "..", 2) == 0) { depth -= 1; if (depth == 0) { path_ = suffix + suffix_len; @@ -9122,22 +9124,22 @@ static int lfsr_mtree_pathlookup(lfs_t *lfs, const char **path, } // only continue if we hit a directory - if (tag != LFSR_TAG_DIR) { - return (tag == LFSR_TAG_ORPHAN) - ? LFS_ERR_NOENT - : LFS_ERR_NOTDIR; + if (tag != LFS3_TAG_DIR) { + return (tag == LFS3_TAG_ORPHAN) + ? LFS3_ERR_NOENT + : LFS3_ERR_NOTDIR; } // read the next did from the mdir if this is not the root if (mdir_->mid != -1) { - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, mdir_, LFSR_TAG_DID, + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, mdir_, LFS3_TAG_DID, NULL, &data); if (err) { return err; } - err = lfsr_data_readleb128(lfs, &data, &did); + err = lfs3_data_readleb128(lfs3, &data, &did); if (err) { return err; } @@ -9147,21 +9149,21 @@ static int lfsr_mtree_pathlookup(lfs_t *lfs, const char **path, *path = path_; // lookup up this name in the mtree - int err = lfsr_mtree_namelookup(lfs, did, path_, name_len, + int err = lfs3_mtree_namelookup(lfs3, did, path_, name_len, mdir_, &tag, NULL); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } // keep track of where to insert if we can't find path - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { if (tag_) { *tag_ = tag; } if (did_) { *did_ = did; } - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // go on to next name @@ -9177,26 +9179,26 @@ static int lfsr_mtree_pathlookup(lfs_t *lfs, const char **path, // traversing littlefs is a bit complex, so we use a state machine to keep // track of where we are enum { - LFSR_TSTATE_MROOTANCHOR = 0, - LFSR_TSTATE_MROOTCHAIN = 1, - LFSR_TSTATE_MTREE = 2, - LFSR_TSTATE_MDIRS = 3, - LFSR_TSTATE_MDIR = 4, - LFSR_TSTATE_BTREE = 5, - LFSR_TSTATE_OMDIRS = 6, - LFSR_TSTATE_OBTREE = 7, - LFSR_TSTATE_DONE = 8, + LFS3_TSTATE_MROOTANCHOR = 0, + LFS3_TSTATE_MROOTCHAIN = 1, + LFS3_TSTATE_MTREE = 2, + LFS3_TSTATE_MDIRS = 3, + LFS3_TSTATE_MDIR = 4, + LFS3_TSTATE_BTREE = 5, + LFS3_TSTATE_OMDIRS = 6, + LFS3_TSTATE_OBTREE = 7, + LFS3_TSTATE_DONE = 8, }; -static void lfsr_traversal_init(lfsr_traversal_t *t, uint32_t flags) { - t->b.o.flags = lfsr_o_typeflags(LFS_type_TRAVERSAL) - | lfsr_t_tstateflags(LFSR_TSTATE_MROOTANCHOR) +static void lfs3_traversal_init(lfs3_traversal_t *t, uint32_t flags) { + t->b.o.flags = lfs3_o_typeflags(LFS3_type_TRAVERSAL) + | lfs3_t_tstateflags(LFS3_TSTATE_MROOTANCHOR) | flags; t->b.o.mdir.mid = -1; t->b.o.mdir.rbyd.weight = 0; t->b.o.mdir.rbyd.blocks[0] = -1; t->b.o.mdir.rbyd.blocks[1] = -1; - lfsr_bshrub_init(&t->b); + lfs3_bshrub_init(&t->b); t->ot = NULL; t->u.mtortoise.blocks[0] = -1; t->u.mtortoise.blocks[1] = -1; @@ -9205,60 +9207,60 @@ static void lfsr_traversal_init(lfsr_traversal_t *t, uint32_t flags) { t->gcksum = 0; } -// needed in lfsr_mtree_traverse_ -static int lfsr_file_traverse_(lfs_t *lfs, const lfsr_bshrub_t *bshrub, - lfsr_btraversal_t *bt, - lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bptr_t *bptr); +// needed in lfs3_mtree_traverse_ +static int lfs3_file_traverse_(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, + lfs3_btraversal_t *bt, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bptr_t *bptr); // low-level traversal _only_ finds blocks -static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, - lfsr_tag_t *tag_, lfsr_bptr_t *bptr) { +static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, + lfs3_tag_t *tag_, lfs3_bptr_t *bptr) { while (true) { - switch (lfsr_t_tstate(t->b.o.flags)) { + switch (lfs3_t_tstate(t->b.o.flags)) { // start with the mrootanchor 0x{0,1} // // note we make sure to include all mroots in our mroot chain! // - case LFSR_TSTATE_MROOTANCHOR:; + case LFS3_TSTATE_MROOTANCHOR:; // fetch the first mroot 0x{0,1} - int err = lfsr_mdir_fetch(lfs, &t->b.o.mdir, - -1, LFSR_MPTR_MROOTANCHOR()); + int err = lfs3_mdir_fetch(lfs3, &t->b.o.mdir, + -1, LFS3_MPTR_MROOTANCHOR()); if (err) { return err; } // transition to traversing the mroot chain - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MROOTCHAIN); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MROOTCHAIN); if (tag_) { - *tag_ = LFSR_TAG_MDIR; + *tag_ = LFS3_TAG_MDIR; } bptr->data.u.buffer = (const uint8_t*)&t->b.o.mdir; return 0; // traverse the mroot chain, checking for mroots/mtrees - case LFSR_TSTATE_MROOTCHAIN:; + case LFS3_TSTATE_MROOTCHAIN:; // lookup mroot, if we find one this is not the active mroot - lfsr_tag_t tag; - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, &t->b.o.mdir, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_tag_t tag; + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, &t->b.o.mdir, + LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag, &data); if (err) { // if we have no mtree (inlined mdir), we need to // traverse any files in our mroot next - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { t->b.o.mdir.mid = 0; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIR); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIR); continue; } return err; } // found a new mroot - if (tag == LFSR_TAG_MROOT) { + if (tag == LFS3_TAG_MROOT) { // fetch this mroot - err = lfsr_data_fetchmdir(lfs, &data, -1, + err = lfs3_data_fetchmdir(lfs3, &data, -1, &t->b.o.mdir); if (err) { return err; @@ -9270,14 +9272,14 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, // btree inner nodes require checksums of their pointers, // so creating a valid cycle is actually quite difficult // - if (lfsr_mptr_cmp( + if (lfs3_mptr_cmp( t->b.o.mdir.rbyd.blocks, t->u.mtortoise.blocks) == 0) { - LFS_ERROR("Cycle detected during mtree traversal " + LFS3_ERROR("Cycle detected during mtree traversal " "0x{%"PRIx32",%"PRIx32"}", t->b.o.mdir.rbyd.blocks[0], t->b.o.mdir.rbyd.blocks[1]); - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } if (t->u.mtortoise.step == (1U << t->u.mtortoise.power)) { t->u.mtortoise.blocks[0] = t->b.o.mdir.rbyd.blocks[0]; @@ -9288,118 +9290,118 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, t->u.mtortoise.step += 1; if (tag_) { - *tag_ = LFSR_TAG_MDIR; + *tag_ = LFS3_TAG_MDIR; } bptr->data.u.buffer = (const uint8_t*)&t->b.o.mdir; return 0; // found an mtree? - } else if (tag == LFSR_TAG_MTREE) { + } else if (tag == LFS3_TAG_MTREE) { // fetch the root of the mtree - err = lfsr_data_fetchbtree(lfs, &data, + err = lfs3_data_fetchbtree(lfs3, &data, &t->b.shrub); if (err) { return err; } // transition to traversing the mtree - lfsr_btraversal_init(&t->u.bt); - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MTREE); + lfs3_btraversal_init(&t->u.bt); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MTREE); continue; } else { - LFS_ERROR("Weird mroot entry? 0x%"PRIx32, tag); - return LFS_ERR_CORRUPT; + LFS3_ERROR("Weird mroot entry? 0x%"PRIx32, tag); + return LFS3_ERR_CORRUPT; } - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); // iterate over mdirs in the mtree - case LFSR_TSTATE_MDIRS:; + case LFS3_TSTATE_MDIRS:; // find the next mdir - err = lfsr_mtree_lookup(lfs, t->b.o.mdir.mid, + err = lfs3_mtree_lookup(lfs3, t->b.o.mdir.mid, &t->b.o.mdir); if (err) { // end of mtree? guess we're done - if (err == LFS_ERR_NOENT) { - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_DONE); + if (err == LFS3_ERR_NOENT) { + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_DONE); continue; } return err; } // transition to traversing the mdir - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIR); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIR); if (tag_) { - *tag_ = LFSR_TAG_MDIR; + *tag_ = LFS3_TAG_MDIR; } bptr->data.u.buffer = (const uint8_t*)&t->b.o.mdir; return 0; // scan for blocks/btrees in the current mdir - case LFSR_TSTATE_MDIR:; + case LFS3_TSTATE_MDIR:; // not traversing all blocks? have we exceeded our mdir's weight? // return to mtree iteration - if (lfsr_t_ismtreeonly(t->b.o.flags) - || lfsr_mrid(lfs, t->b.o.mdir.mid) - >= (lfsr_srid_t)t->b.o.mdir.rbyd.weight) { - t->b.o.mdir.mid = lfsr_mbid(lfs, t->b.o.mdir.mid) + 1; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIRS); + if (lfs3_t_ismtreeonly(t->b.o.flags) + || lfs3_mrid(lfs3, t->b.o.mdir.mid) + >= (lfs3_srid_t)t->b.o.mdir.rbyd.weight) { + t->b.o.mdir.mid = lfs3_mbid(lfs3, t->b.o.mdir.mid) + 1; + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIRS); continue; } // do we have a bshrub/btree? - err = lfsr_mdir_lookup(lfs, &t->b.o.mdir, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + err = lfs3_mdir_lookup(lfs3, &t->b.o.mdir, + LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } // found a bshrub/btree? note we may also run into // dirs/dids here - if (err != LFS_ERR_NOENT - && (tag == LFSR_TAG_BSHRUB - || tag == LFSR_TAG_BTREE)) { + if (err != LFS3_ERR_NOENT + && (tag == LFS3_TAG_BSHRUB + || tag == LFS3_TAG_BTREE)) { // found a bshrub (inlined btree)? - if (tag == LFSR_TAG_BSHRUB) { - err = lfsr_data_readshrub(lfs, &data, &t->b.o.mdir, + if (tag == LFS3_TAG_BSHRUB) { + err = lfs3_data_readshrub(lfs3, &data, &t->b.o.mdir, &t->b.shrub); if (err) { return err; } // found a btree? - } else if (tag == LFSR_TAG_BTREE) { - err = lfsr_data_fetchbtree(lfs, &data, + } else if (tag == LFS3_TAG_BTREE) { + err = lfs3_data_fetchbtree(lfs3, &data, &t->b.shrub); if (err) { return err; } } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } // start traversing - lfsr_btraversal_init(&t->u.bt); - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_BTREE); + lfs3_btraversal_init(&t->u.bt); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_BTREE); continue; // no? next we need to check any opened files } else { - t->ot = lfs->omdirs; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_OMDIRS); + t->ot = lfs3->omdirs; + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_OMDIRS); continue; } - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); // scan for blocks/btrees in our opened file list - case LFSR_TSTATE_OMDIRS:; + case LFS3_TSTATE_OMDIRS:; // reached end of opened files? return to mdir traversal if (!t->ot) { t->b.o.mdir.mid += 1; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIR); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIR); continue; } @@ -9412,22 +9414,22 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, // this list anyways // if (t->ot->mdir.mid != t->b.o.mdir.mid - || lfsr_o_type(t->ot->flags) != LFS_TYPE_REG - || !lfsr_o_isunsync(t->ot->flags)) { + || lfs3_o_type(t->ot->flags) != LFS3_TYPE_REG + || !lfs3_o_isunsync(t->ot->flags)) { t->ot = t->ot->next; continue; } // transition to traversing the file - const lfsr_file_t *file = (const lfsr_file_t*)t->ot; + const lfs3_file_t *file = (const lfs3_file_t*)t->ot; t->b.shrub = file->b.shrub; - lfsr_btraversal_init(&t->u.bt); - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_OBTREE); + lfs3_btraversal_init(&t->u.bt); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_OBTREE); // wait, do we have an ungrafted leaf? - if (lfsr_o_isungraft(file->b.o.flags)) { + if (lfs3_o_isungraft(file->b.o.flags)) { if (tag_) { - *tag_ = LFSR_TAG_BLOCK; + *tag_ = LFS3_TAG_BLOCK; } *bptr = file->leaf.bptr; return 0; @@ -9437,54 +9439,54 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, // traverse any bshrubs/btrees we see, this includes the mtree // and any file btrees/bshrubs - case LFSR_TSTATE_MTREE:; - case LFSR_TSTATE_BTREE:; - case LFSR_TSTATE_OBTREE:; + case LFS3_TSTATE_MTREE:; + case LFS3_TSTATE_BTREE:; + case LFS3_TSTATE_OBTREE:; // traverse through our bshrub/btree // // it probably looks a bit weird to go through - // lfsr_file_traverse_, but this gets us bptr decoding + // lfs3_file_traverse_, but this gets us bptr decoding // for free - err = lfsr_file_traverse_(lfs, &t->b, &t->u.bt, + err = lfs3_file_traverse_(lfs3, &t->b, &t->u.bt, NULL, &tag, bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { // clear the bshrub state - lfsr_bshrub_init(&t->b); + lfs3_bshrub_init(&t->b); // end of mtree? start iterating over mdirs - if (lfsr_t_tstate(t->b.o.flags) - == LFSR_TSTATE_MTREE) { + if (lfs3_t_tstate(t->b.o.flags) + == LFS3_TSTATE_MTREE) { t->b.o.mdir.mid = 0; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIRS); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIRS); continue; // end of mdir btree? start iterating over opened files - } else if (lfsr_t_tstate(t->b.o.flags) - == LFSR_TSTATE_BTREE) { - t->ot = lfs->omdirs; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_OMDIRS); + } else if (lfs3_t_tstate(t->b.o.flags) + == LFS3_TSTATE_BTREE) { + t->ot = lfs3->omdirs; + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_OMDIRS); continue; // end of opened btree? go to next opened file - } else if (lfsr_t_tstate(t->b.o.flags) - == LFSR_TSTATE_OBTREE) { + } else if (lfs3_t_tstate(t->b.o.flags) + == LFS3_TSTATE_OBTREE) { t->ot = t->ot->next; - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_OMDIRS); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_OMDIRS); continue; } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } return err; } // found an inner btree node? - if (tag == LFSR_TAG_BRANCH) { + if (tag == LFS3_TAG_BRANCH) { if (tag_) { *tag_ = tag; } return 0; // found an indirect block? - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { if (tag_) { *tag_ = tag; } @@ -9493,37 +9495,37 @@ static int lfsr_mtree_traverse_(lfs_t *lfs, lfsr_traversal_t *t, continue; - case LFSR_TSTATE_DONE:; - return LFS_ERR_NOENT; + case LFS3_TSTATE_DONE:; + return LFS3_ERR_NOENT; default:; - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } } -// needed in lfsr_mtree_traverse -static void lfs_alloc_markinuse(lfs_t *lfs, - lfsr_tag_t tag, const lfsr_bptr_t *bptr); +// needed in lfs3_mtree_traverse +static void lfs3_alloc_markinuse(lfs3_t *lfs3, + lfs3_tag_t tag, const lfs3_bptr_t *bptr); // high-level immutable traversal, handle extra features here, -// but no mutation! (we're called in lfs_alloc, so things would end up +// but no mutation! (we're called in lfs3_alloc, so things would end up // recursive, which would be a bit bad!) -static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_traversal_t *t, - lfsr_tag_t *tag_, lfsr_bptr_t *bptr) { - lfsr_tag_t tag; - int err = lfsr_mtree_traverse_(lfs, t, +static int lfs3_mtree_traverse(lfs3_t *lfs3, lfs3_traversal_t *t, + lfs3_tag_t *tag_, lfs3_bptr_t *bptr) { + lfs3_tag_t tag; + int err = lfs3_mtree_traverse_(lfs3, t, &tag, bptr); if (err) { // end of traversal? - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { goto eot; } return err; } // validate mdirs? mdir checksums are already validated in - // lfsr_mdir_fetch, but this doesn't prevent rollback issues, where + // lfs3_mdir_fetch, but this doesn't prevent rollback issues, where // the most recent commit is corrupted but a previous outdated // commit appears valid // @@ -9532,37 +9534,37 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_traversal_t *t, // // we also compare mdir checksums with any open mdirs to try to // avoid traversing any outdated bshrubs/btrees - if ((lfsr_t_isckmeta(t->b.o.flags) - || lfsr_t_isckdata(t->b.o.flags)) - && tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr->data.u.buffer; + if ((lfs3_t_isckmeta(t->b.o.flags) + || lfs3_t_isckdata(t->b.o.flags)) + && tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer; // check cksum matches our mroot - if (lfsr_mdir_cmp(mdir, &lfs->mroot) == 0 - && mdir->rbyd.cksum != lfs->mroot.rbyd.cksum) { - LFS_ERROR("Found mroot cksum mismatch " + if (lfs3_mdir_cmp(mdir, &lfs3->mroot) == 0 + && mdir->rbyd.cksum != lfs3->mroot.rbyd.cksum) { + LFS3_ERROR("Found mroot cksum mismatch " "0x{%"PRIx32",%"PRIx32"}, " "cksum %08"PRIx32" (!= %08"PRIx32")", mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], mdir->rbyd.cksum, - lfs->mroot.rbyd.cksum); - return LFS_ERR_CORRUPT; + lfs3->mroot.rbyd.cksum); + return LFS3_ERR_CORRUPT; } // check cksum matches any open mdirs - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_mdir_cmp(&o->mdir, mdir) == 0 + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_mdir_cmp(&o->mdir, mdir) == 0 && o->mdir.rbyd.cksum != mdir->rbyd.cksum) { - LFS_ERROR("Found mdir cksum mismatch %"PRId32" " + LFS3_ERROR("Found mdir cksum mismatch %"PRId32" " "0x{%"PRIx32",%"PRIx32"}, " "cksum %08"PRIx32" (!= %08"PRIx32")", - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], mdir->rbyd.cksum, o->mdir.rbyd.cksum); - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } } @@ -9575,11 +9577,11 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_traversal_t *t, // this may end up revalidating some btree nodes when ckfetches // is enabled, but we need to revalidate cached btree nodes or // we risk missing errors in ckmeta scans - if ((lfsr_t_isckmeta(t->b.o.flags) - || lfsr_t_isckdata(t->b.o.flags)) - && tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr->data.u.buffer; - err = lfsr_rbyd_fetchck(lfs, rbyd, + if ((lfs3_t_isckmeta(t->b.o.flags) + || lfs3_t_isckdata(t->b.o.flags)) + && tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr->data.u.buffer; + err = lfs3_rbyd_fetchck(lfs3, rbyd, rbyd->blocks[0], rbyd->trunk, rbyd->cksum); if (err) { @@ -9588,9 +9590,9 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_traversal_t *t, } // validate data blocks? - if (lfsr_t_isckdata(t->b.o.flags) - && tag == LFSR_TAG_BLOCK) { - err = lfsr_bptr_ck(lfs, bptr); + if (lfs3_t_isckdata(t->b.o.flags) + && tag == LFS3_TAG_BLOCK) { + err = lfs3_bptr_ck(lfs3, bptr); if (err) { return err; } @@ -9603,119 +9605,119 @@ static int lfsr_mtree_traverse(lfs_t *lfs, lfsr_traversal_t *t, eot:; // compare gcksum with in-RAM gcksum - if ((lfsr_t_isckmeta(t->b.o.flags) - || lfsr_t_isckdata(t->b.o.flags)) - && !lfsr_t_isdirty(t->b.o.flags) - && !lfsr_t_ismutated(t->b.o.flags) - && t->gcksum != lfs->gcksum) { - LFS_ERROR("Found gcksum mismatch, cksum %08"PRIx32" (!= %08"PRIx32")", + if ((lfs3_t_isckmeta(t->b.o.flags) + || lfs3_t_isckdata(t->b.o.flags)) + && !lfs3_t_isdirty(t->b.o.flags) + && !lfs3_t_ismutated(t->b.o.flags) + && t->gcksum != lfs3->gcksum) { + LFS3_ERROR("Found gcksum mismatch, cksum %08"PRIx32" (!= %08"PRIx32")", t->gcksum, - lfs->gcksum); - return LFS_ERR_CORRUPT; + lfs3->gcksum); + return LFS3_ERR_CORRUPT; } // was ckmeta/ckdata successful? we only consider our filesystem // checked if we weren't mutated - if ((lfsr_t_isckmeta(t->b.o.flags) - || lfsr_t_isckdata(t->b.o.flags)) - && !lfsr_t_ismtreeonly(t->b.o.flags) - && !lfsr_t_isdirty(t->b.o.flags) - && !lfsr_t_ismutated(t->b.o.flags)) { - lfs->flags &= ~LFS_I_CKMETA; + if ((lfs3_t_isckmeta(t->b.o.flags) + || lfs3_t_isckdata(t->b.o.flags)) + && !lfs3_t_ismtreeonly(t->b.o.flags) + && !lfs3_t_isdirty(t->b.o.flags) + && !lfs3_t_ismutated(t->b.o.flags)) { + lfs3->flags &= ~LFS3_I_CKMETA; } - if (lfsr_t_isckdata(t->b.o.flags) - && !lfsr_t_ismtreeonly(t->b.o.flags) - && !lfsr_t_isdirty(t->b.o.flags) - && !lfsr_t_ismutated(t->b.o.flags)) { - lfs->flags &= ~LFS_I_CKDATA; + if (lfs3_t_isckdata(t->b.o.flags) + && !lfs3_t_ismtreeonly(t->b.o.flags) + && !lfs3_t_isdirty(t->b.o.flags) + && !lfs3_t_ismutated(t->b.o.flags)) { + lfs3->flags &= ~LFS3_I_CKDATA; } - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } -// needed in lfsr_mtree_gc -static int lfsr_mdir_mkconsistent(lfs_t *lfs, lfsr_mdir_t *mdir); -static void lfs_alloc_ckpoint(lfs_t *lfs); -static void lfs_alloc_markfree(lfs_t *lfs); +// needed in lfs3_mtree_gc +static int lfs3_mdir_mkconsistent(lfs3_t *lfs3, lfs3_mdir_t *mdir); +static void lfs3_alloc_ckpoint(lfs3_t *lfs3); +static void lfs3_alloc_markfree(lfs3_t *lfs3); // high-level mutating traversal, handle extra features that require -// mutation here, upper layers should call lfs_alloc_ckpoint as needed -static int lfsr_mtree_gc(lfs_t *lfs, lfsr_traversal_t *t, - lfsr_tag_t *tag_, lfsr_bptr_t *bptr) { +// mutation here, upper layers should call lfs3_alloc_ckpoint as needed +static int lfs3_mtree_gc(lfs3_t *lfs3, lfs3_traversal_t *t, + lfs3_tag_t *tag_, lfs3_bptr_t *bptr) { dropped:; - lfsr_tag_t tag; - int err = lfsr_mtree_traverse(lfs, t, + lfs3_tag_t tag; + int err = lfs3_mtree_traverse(lfs3, t, &tag, bptr); if (err) { // end of traversal? - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { goto eot; } goto failed; } - // swap dirty/mutated flags while in lfsr_mtree_gc - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + // swap dirty/mutated flags while in lfs3_mtree_gc + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); // track in-use blocks? - if (lfsr_t_islookahead(t->b.o.flags)) { - lfs_alloc_markinuse(lfs, tag, bptr); + if (lfs3_t_islookahead(t->b.o.flags)) { + lfs3_alloc_markinuse(lfs3, tag, bptr); } // mkconsistencing mdirs? - if (lfsr_t_ismkconsistent(t->b.o.flags) - && lfsr_t_ismkconsistent(lfs->flags) - && tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr->data.u.buffer; - err = lfsr_mdir_mkconsistent(lfs, mdir); + if (lfs3_t_ismkconsistent(t->b.o.flags) + && lfs3_t_ismkconsistent(lfs3->flags) + && tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer; + err = lfs3_mdir_mkconsistent(lfs3, mdir); if (err) { goto failed; } // make sure we clear any zombie flags - t->b.o.flags &= ~LFS_o_ZOMBIE; + t->b.o.flags &= ~LFS3_o_ZOMBIE; // did this drop our mdir? if (mdir->mid != -1 && mdir->rbyd.weight == 0) { // swap back dirty/mutated flags - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); // continue traversal - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIRS); + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIRS); goto dropped; } } // compacting mdirs? - if (lfsr_t_iscompact(t->b.o.flags) - && tag == LFSR_TAG_MDIR + if (lfs3_t_iscompact(t->b.o.flags) + && tag == LFS3_TAG_MDIR // exceed compaction threshold? - && lfsr_rbyd_eoff(&((lfsr_mdir_t*)bptr->data.u.buffer)->rbyd) - > ((lfs->cfg->gc_compact_thresh) - ? lfs->cfg->gc_compact_thresh - : lfs->cfg->block_size - lfs->cfg->block_size/8)) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr->data.u.buffer; - LFS_INFO("Compacting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " + && lfs3_rbyd_eoff(&((lfs3_mdir_t*)bptr->data.u.buffer)->rbyd) + > ((lfs3->cfg->gc_compact_thresh) + ? lfs3->cfg->gc_compact_thresh + : lfs3->cfg->block_size - lfs3->cfg->block_size/8)) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer; + LFS3_INFO("Compacting mdir %"PRId32" 0x{%"PRIx32",%"PRIx32"} " "(%"PRId32" > %"PRId32")", - lfsr_dbgmbid(lfs, mdir->mid), + lfs3_dbgmbid(lfs3, mdir->mid), mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], - lfsr_rbyd_eoff(&mdir->rbyd), - (lfs->cfg->gc_compact_thresh) - ? lfs->cfg->gc_compact_thresh - : lfs->cfg->block_size - lfs->cfg->block_size/8); + lfs3_rbyd_eoff(&mdir->rbyd), + (lfs3->cfg->gc_compact_thresh) + ? lfs3->cfg->gc_compact_thresh + : lfs3->cfg->block_size - lfs3->cfg->block_size/8); // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // compact the mdir - err = lfsr_mdir_compact(lfs, mdir); + err = lfs3_mdir_compact(lfs3, mdir); if (err) { goto failed; } } // swap back dirty/mutated flags - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); if (tag_) { *tag_ = tag; } @@ -9723,32 +9725,32 @@ dropped:; eot:; // was lookahead scan successful? - if (lfsr_t_islookahead(t->b.o.flags) - && !lfsr_t_ismtreeonly(t->b.o.flags) - && !lfsr_t_isdirty(t->b.o.flags) - && !lfsr_t_ismutated(t->b.o.flags)) { - lfs_alloc_markfree(lfs); + if (lfs3_t_islookahead(t->b.o.flags) + && !lfs3_t_ismtreeonly(t->b.o.flags) + && !lfs3_t_isdirty(t->b.o.flags) + && !lfs3_t_ismutated(t->b.o.flags)) { + lfs3_alloc_markfree(lfs3); } // was mkconsistent successful? - if (lfsr_t_ismkconsistent(t->b.o.flags) - && !lfsr_t_isdirty(t->b.o.flags)) { - lfs->flags &= ~LFS_I_MKCONSISTENT; + if (lfs3_t_ismkconsistent(t->b.o.flags) + && !lfs3_t_isdirty(t->b.o.flags)) { + lfs3->flags &= ~LFS3_I_MKCONSISTENT; } // was compaction successful? note we may need multiple passes if // we want to be sure everything is compacted - if (lfsr_t_iscompact(t->b.o.flags) - && !lfsr_t_isdirty(t->b.o.flags) - && !lfsr_t_ismutated(t->b.o.flags)) { - lfs->flags &= ~LFS_I_COMPACT; + if (lfs3_t_iscompact(t->b.o.flags) + && !lfs3_t_isdirty(t->b.o.flags) + && !lfs3_t_ismutated(t->b.o.flags)) { + lfs3->flags &= ~LFS3_I_COMPACT; } - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; failed:; // swap back dirty/mutated flags - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); return err; } @@ -9761,136 +9763,136 @@ failed:; // operations that need to alloc should call this to indicate all in-use // blocks are either committed into the filesystem or tracked by an opened // mdir -static void lfs_alloc_ckpoint(lfs_t *lfs) { - lfs->lookahead.ckpoint = lfs->block_count; +static void lfs3_alloc_ckpoint(lfs3_t *lfs3) { + lfs3->lookahead.ckpoint = lfs3->block_count; } // discard any lookahead state, this is necessary if block_count changes -static void lfs_alloc_discard(lfs_t *lfs) { - lfs->lookahead.size = 0; - lfs_memset(lfs->lookahead.buffer, 0, lfs->cfg->lookahead_size); +static void lfs3_alloc_discard(lfs3_t *lfs3) { + lfs3->lookahead.size = 0; + lfs3_memset(lfs3->lookahead.buffer, 0, lfs3->cfg->lookahead_size); } // mark a block as in-use -static void lfs_alloc_markinuse_(lfs_t *lfs, lfs_block_t block) { +static void lfs3_alloc_markinuse_(lfs3_t *lfs3, lfs3_block_t block) { // translate to lookahead-relative - lfs_block_t block_ = (( - (lfs_sblock_t)(block - - (lfs->lookahead.window + lfs->lookahead.off)) + lfs3_block_t block_ = (( + (lfs3_sblock_t)(block + - (lfs3->lookahead.window + lfs3->lookahead.off)) // we only need this mess because C's mod is actually rem, and // we want real mod in case block_ goes negative - % (lfs_sblock_t)lfs->block_count) - + (lfs_sblock_t)lfs->block_count) - % (lfs_sblock_t)lfs->block_count; + % (lfs3_sblock_t)lfs3->block_count) + + (lfs3_sblock_t)lfs3->block_count) + % (lfs3_sblock_t)lfs3->block_count; - if (block_ < 8*lfs->cfg->lookahead_size) { + if (block_ < 8*lfs3->cfg->lookahead_size) { // mark as in-use - lfs->lookahead.buffer[ - ((lfs->lookahead.off + block_) / 8) - % lfs->cfg->lookahead_size] - |= 1 << ((lfs->lookahead.off + block_) % 8); + lfs3->lookahead.buffer[ + ((lfs3->lookahead.off + block_) / 8) + % lfs3->cfg->lookahead_size] + |= 1 << ((lfs3->lookahead.off + block_) % 8); } } // mark some filesystem object as in-use -static void lfs_alloc_markinuse(lfs_t *lfs, - lfsr_tag_t tag, const lfsr_bptr_t *bptr) { - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr->data.u.buffer; - lfs_alloc_markinuse_(lfs, mdir->rbyd.blocks[0]); - lfs_alloc_markinuse_(lfs, mdir->rbyd.blocks[1]); +static void lfs3_alloc_markinuse(lfs3_t *lfs3, + lfs3_tag_t tag, const lfs3_bptr_t *bptr) { + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr->data.u.buffer; + lfs3_alloc_markinuse_(lfs3, mdir->rbyd.blocks[0]); + lfs3_alloc_markinuse_(lfs3, mdir->rbyd.blocks[1]); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr->data.u.buffer; - lfs_alloc_markinuse_(lfs, rbyd->blocks[0]); + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr->data.u.buffer; + lfs3_alloc_markinuse_(lfs3, rbyd->blocks[0]); - } else if (tag == LFSR_TAG_BLOCK) { - lfs_alloc_markinuse_(lfs, lfsr_bptr_block(bptr)); + } else if (tag == LFS3_TAG_BLOCK) { + lfs3_alloc_markinuse_(lfs3, lfs3_bptr_block(bptr)); } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } -// needed in lfs_alloc_markfree -static lfs_sblock_t lfs_alloc_findfree(lfs_t *lfs); +// needed in lfs3_alloc_markfree +static lfs3_sblock_t lfs3_alloc_findfree(lfs3_t *lfs3); // mark any not-in-use blocks as free -static void lfs_alloc_markfree(lfs_t *lfs) { +static void lfs3_alloc_markfree(lfs3_t *lfs3) { // make lookahead buffer usable - lfs->lookahead.size = lfs_min( - 8*lfs->cfg->lookahead_size, - lfs->lookahead.ckpoint); + lfs3->lookahead.size = lfs3_min( + 8*lfs3->cfg->lookahead_size, + lfs3->lookahead.ckpoint); // signal that lookahead is full, this may be cleared by - // lfs_alloc_findfree - lfs->flags &= ~LFS_I_LOOKAHEAD; + // lfs3_alloc_findfree + lfs3->flags &= ~LFS3_I_LOOKAHEAD; // eagerly find the next free block so lookahead scans can make // the most progress - lfs_alloc_findfree(lfs); + lfs3_alloc_findfree(lfs3); } // increment lookahead buffer -static void lfs_alloc_inc(lfs_t *lfs) { - LFS_ASSERT(lfs->lookahead.size > 0); +static void lfs3_alloc_inc(lfs3_t *lfs3) { + LFS3_ASSERT(lfs3->lookahead.size > 0); // clear lookahead as we increment - lfs->lookahead.buffer[lfs->lookahead.off / 8] - &= ~(1 << (lfs->lookahead.off % 8)); + lfs3->lookahead.buffer[lfs3->lookahead.off / 8] + &= ~(1 << (lfs3->lookahead.off % 8)); // signal that lookahead is no longer full - lfs->flags |= LFS_I_LOOKAHEAD; + lfs3->flags |= LFS3_I_LOOKAHEAD; // increment next/off - lfs->lookahead.off += 1; - if (lfs->lookahead.off == 8*lfs->cfg->lookahead_size) { - lfs->lookahead.off = 0; - lfs->lookahead.window = (lfs->lookahead.window - + 8*lfs->cfg->lookahead_size) - % lfs->block_count; + lfs3->lookahead.off += 1; + if (lfs3->lookahead.off == 8*lfs3->cfg->lookahead_size) { + lfs3->lookahead.off = 0; + lfs3->lookahead.window = (lfs3->lookahead.window + + 8*lfs3->cfg->lookahead_size) + % lfs3->block_count; } // decrement size/ckpoint - lfs->lookahead.size -= 1; - lfs->lookahead.ckpoint -= 1; + lfs3->lookahead.size -= 1; + lfs3->lookahead.ckpoint -= 1; } // find next free block in lookahead buffer, if there is one -static lfs_sblock_t lfs_alloc_findfree(lfs_t *lfs) { - while (lfs->lookahead.size > 0) { - if (!(lfs->lookahead.buffer[lfs->lookahead.off / 8] - & (1 << (lfs->lookahead.off % 8)))) { +static lfs3_sblock_t lfs3_alloc_findfree(lfs3_t *lfs3) { + while (lfs3->lookahead.size > 0) { + if (!(lfs3->lookahead.buffer[lfs3->lookahead.off / 8] + & (1 << (lfs3->lookahead.off % 8)))) { // found a free block - return (lfs->lookahead.window + lfs->lookahead.off) - % lfs->block_count; + return (lfs3->lookahead.window + lfs3->lookahead.off) + % lfs3->block_count; } - lfs_alloc_inc(lfs); + lfs3_alloc_inc(lfs3); } - return LFS_ERR_NOSPC; + return LFS3_ERR_NOSPC; } -static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase) { +static lfs3_sblock_t lfs3_alloc(lfs3_t *lfs3, bool erase) { while (true) { // scan our lookahead buffer for free blocks - lfs_sblock_t block = lfs_alloc_findfree(lfs); - if (block < 0 && block != LFS_ERR_NOSPC) { + lfs3_sblock_t block = lfs3_alloc_findfree(lfs3); + if (block < 0 && block != LFS3_ERR_NOSPC) { return block; } - if (block != LFS_ERR_NOSPC) { + if (block != LFS3_ERR_NOSPC) { // we should never alloc blocks {0,1} - LFS_ASSERT(block != 0 && block != 1); + LFS3_ASSERT(block != 0 && block != 1); // erase requested? if (erase) { - int err = lfsr_bd_erase(lfs, block); + int err = lfs3_bd_erase(lfs3, block); if (err) { // bad erase? try another block - if (err == LFS_ERR_CORRUPT) { - lfs_alloc_inc(lfs); + if (err == LFS3_ERR_CORRUPT) { + lfs3_alloc_inc(lfs3); continue; } return err; @@ -9898,17 +9900,17 @@ static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase) { } // eagerly find the next free block to maximize how many blocks - // lfs_alloc_ckpoint makes available for scanning - lfs_alloc_inc(lfs); - lfs_alloc_findfree(lfs); + // lfs3_alloc_ckpoint makes available for scanning + lfs3_alloc_inc(lfs3); + lfs3_alloc_findfree(lfs3); - #ifdef LFS_DBGALLOCS - LFS_DEBUG("Allocated block 0x%"PRIx32", " + #ifdef LFS3_DBGALLOCS + LFS3_DEBUG("Allocated block 0x%"PRIx32", " "lookahead %"PRId32"/%"PRId32"/%"PRId32, block, - lfs->lookahead.size, - lfs->lookahead.ckpoint, - lfs->cfg->block_count); + lfs3->lookahead.size, + lfs3->lookahead.ckpoint, + lfs3->cfg->block_count); #endif return block; } @@ -9920,13 +9922,13 @@ static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase) { // if we've looked at all blocks since the last checkpoint, we report // the filesystem as out of storage // - if (lfs->lookahead.ckpoint <= 0) { - LFS_ERROR("No more free space " + if (lfs3->lookahead.ckpoint <= 0) { + LFS3_ERROR("No more free space " "(lookahead %"PRId32"/%"PRId32"/%"PRId32")", - lfs->lookahead.size, - lfs->lookahead.ckpoint, - lfs->cfg->block_count); - return LFS_ERR_NOSPC; + lfs3->lookahead.size, + lfs3->lookahead.ckpoint, + lfs3->cfg->block_count); + return LFS3_ERR_NOSPC; } // no blocks in our lookahead buffer? @@ -9934,26 +9936,26 @@ static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase) { // traverse the filesystem, building up knowledge of what blocks are // in-use in the next lookahead window // - lfsr_traversal_t t; - lfsr_traversal_init(&t, LFS_T_RDONLY | LFS_T_LOOKAHEAD); + lfs3_traversal_t t; + lfs3_traversal_init(&t, LFS3_T_RDONLY | LFS3_T_LOOKAHEAD); while (true) { - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(lfs3, &t, &tag, &bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; } // track in-use blocks - lfs_alloc_markinuse(lfs, tag, &bptr); + lfs3_alloc_markinuse(lfs3, tag, &bptr); } // mark anything not seen as free - lfs_alloc_markfree(lfs); + lfs3_alloc_markfree(lfs3); } } @@ -9962,32 +9964,32 @@ static lfs_sblock_t lfs_alloc(lfs_t *lfs, bool erase) { /// Directory operations /// -int lfsr_mkdir(lfs_t *lfs, const char *path) { +int lfs3_mkdir(lfs3_t *lfs3, const char *path) { // prepare our filesystem for writing - int err = lfsr_fs_mkconsistent(lfs); + int err = lfs3_fs_mkconsistent(lfs3); if (err) { return err; } // lookup our parent - lfsr_mdir_t mdir; - lfsr_tag_t tag; - lfsr_did_t did; - err = lfsr_mtree_pathlookup(lfs, &path, + lfs3_mdir_t mdir; + lfs3_tag_t tag; + lfs3_did_t did; + err = lfs3_mtree_pathlookup(lfs3, &path, &mdir, &tag, &did); - if (err && !(err == LFS_ERR_NOENT && lfsr_path_islast(path))) { + if (err && !(err == LFS3_ERR_NOENT && lfs3_path_islast(path))) { return err; } // already exists? pretend orphans don't exist - bool exists = (err != LFS_ERR_NOENT); - if (exists && tag != LFSR_TAG_ORPHAN) { - return LFS_ERR_EXIST; + bool exists = (err != LFS3_ERR_NOENT); + if (exists && tag != LFS3_TAG_ORPHAN) { + return LFS3_ERR_EXIST; } // check that name fits - lfs_size_t name_len = lfsr_path_namelen(path); - if (name_len > lfs->name_limit) { - return LFS_ERR_NAMETOOLONG; + lfs3_size_t name_len = lfs3_path_namelen(path); + if (name_len > lfs3->name_limit) { + return LFS3_ERR_NAMETOOLONG; } // find an arbitrary directory-id (did) @@ -10042,21 +10044,21 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // // Note we also need to be careful to catch integer overflow. // - lfsr_did_t dmask - = (1 << lfs_min( - lfs_nlog2(lfsr_mtree_weight(lfs) >> lfs->mbits) - + lfs_nlog2(lfs->cfg->block_size/32), + lfs3_did_t dmask + = (1 << lfs3_min( + lfs3_nlog2(lfs3_mtree_weight(lfs3) >> lfs3->mbits) + + lfs3_nlog2(lfs3->cfg->block_size/32), 31) ) - 1; - lfsr_did_t did_ = (did ^ lfs_crc32c(0, path, name_len)) & dmask; + lfs3_did_t did_ = (did ^ lfs3_crc32c(0, path, name_len)) & dmask; // check if we have a collision, if we do, search for the next // available did while (true) { - err = lfsr_mtree_namelookup(lfs, did_, NULL, 0, + err = lfs3_mtree_namelookup(lfs3, did_, NULL, 0, &mdir, NULL, NULL); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -10076,61 +10078,61 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // to delete-self in case of powerloss, then create the metadata entry // while atomically cancelling the grm. // - // This is done automatically by lfsr_mdir_commit to avoid issues with + // This is done automatically by lfs3_mdir_commit to avoid issues with // mid updates, since the mid technically doesn't exist yet... // commit our bookmark and a grm to self-remove in case of powerloss - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_BOOKMARK, +1, did_, NULL, 0), - LFSR_RATTR( - LFSR_TAG_GRMPUSH, 0))); + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_BOOKMARK, +1, did_, NULL, 0), + LFS3_RATTR( + LFS3_TAG_GRMPUSH, 0))); if (err) { return err; } - LFS_ASSERT(lfs->grm.queue[0] == mdir.mid); + LFS3_ASSERT(lfs3->grm.queue[0] == mdir.mid); // committing our bookmark may have changed the mid of our metadata entry, // we need to look it up again, we can at least avoid the full path walk - err = lfsr_mtree_namelookup(lfs, did, path, name_len, + err = lfs3_mtree_namelookup(lfs3, did, path, name_len, &mdir, NULL, NULL); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - LFS_ASSERT((exists) ? !err : err == LFS_ERR_NOENT); + LFS3_ASSERT((exists) ? !err : err == LFS3_ERR_NOENT); // commit our new directory into our parent, zeroing the grm in the // process - lfsr_grm_pop(lfs); - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_MASK12 | LFSR_TAG_DIR, (!exists) ? +1 : 0, + lfs3_grm_pop(lfs3); + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_MASK12 | LFS3_TAG_DIR, (!exists) ? +1 : 0, did, path, name_len), - LFSR_RATTR_LEB128( - LFSR_TAG_DID, 0, did_))); + LFS3_RATTR_LEB128( + LFS3_TAG_DID, 0, did_))); if (err) { return err; } // update in-device state - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // mark any clobbered uncreats as zombied if (exists - && lfsr_o_type(o->flags) == LFS_TYPE_REG + && lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == mdir.mid) { - o->flags = (o->flags & ~LFS_o_UNCREAT) - | LFS_o_ZOMBIE - | LFS_o_UNSYNC - | LFS_O_DESYNC; + o->flags = (o->flags & ~LFS3_o_UNCREAT) + | LFS3_o_ZOMBIE + | LFS3_o_UNSYNC + | LFS3_O_DESYNC; // update dir positions } else if (!exists - && lfsr_o_type(o->flags) == LFS_TYPE_DIR - && ((lfsr_dir_t*)o)->did == did + && lfs3_o_type(o->flags) == LFS3_TYPE_DIR + && ((lfs3_dir_t*)o)->did == did && o->mdir.mid >= mdir.mid) { - ((lfsr_dir_t*)o)->pos += 1; + ((lfs3_dir_t*)o)->pos += 1; } } @@ -10138,245 +10140,245 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { } // push a did to grm, but only if the directory is empty -static int lfsr_grm_pushdid(lfs_t *lfs, lfsr_did_t did) { +static int lfs3_grm_pushdid(lfs3_t *lfs3, lfs3_did_t did) { // first lookup the bookmark entry - lfsr_mdir_t bookmark_mdir; - int err = lfsr_mtree_namelookup(lfs, did, NULL, 0, + lfs3_mdir_t bookmark_mdir; + int err = lfs3_mtree_namelookup(lfs3, did, NULL, 0, &bookmark_mdir, NULL, NULL); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - lfsr_mid_t bookmark_mid = bookmark_mdir.mid; + lfs3_mid_t bookmark_mid = bookmark_mdir.mid; // check that the directory is empty bookmark_mdir.mid += 1; - if (lfsr_mrid(lfs, bookmark_mdir.mid) - >= (lfsr_srid_t)bookmark_mdir.rbyd.weight) { - err = lfsr_mtree_lookup(lfs, - lfsr_mbid(lfs, bookmark_mdir.mid-1) + 1, + if (lfs3_mrid(lfs3, bookmark_mdir.mid) + >= (lfs3_srid_t)bookmark_mdir.rbyd.weight) { + err = lfs3_mtree_lookup(lfs3, + lfs3_mbid(lfs3, bookmark_mdir.mid-1) + 1, &bookmark_mdir); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { goto empty; } return err; } } - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, &bookmark_mdir, - LFSR_TAG_MASK8 | LFSR_TAG_NAME, + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, &bookmark_mdir, + LFS3_TAG_MASK8 | LFS3_TAG_NAME, NULL, &data); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - lfsr_did_t did_; - err = lfsr_data_readleb128(lfs, &data, &did_); + lfs3_did_t did_; + err = lfs3_data_readleb128(lfs3, &data, &did_); if (err) { return err; } if (did_ == did) { - return LFS_ERR_NOTEMPTY; + return LFS3_ERR_NOTEMPTY; } empty:; - lfsr_grm_push(lfs, bookmark_mid); + lfs3_grm_push(lfs3, bookmark_mid); return 0; } -// needed in lfsr_remove -static int lfsr_fs_fixgrm(lfs_t *lfs); +// needed in lfs3_remove +static int lfs3_fs_fixgrm(lfs3_t *lfs3); -int lfsr_remove(lfs_t *lfs, const char *path) { +int lfs3_remove(lfs3_t *lfs3, const char *path) { // prepare our filesystem for writing - int err = lfsr_fs_mkconsistent(lfs); + int err = lfs3_fs_mkconsistent(lfs3); if (err) { return err; } // lookup our entry - lfsr_mdir_t mdir; - lfsr_tag_t tag; - lfsr_did_t did; - err = lfsr_mtree_pathlookup(lfs, &path, + lfs3_mdir_t mdir; + lfs3_tag_t tag; + lfs3_did_t did; + err = lfs3_mtree_pathlookup(lfs3, &path, &mdir, &tag, &did); if (err) { return err; } // pretend orphans don't exist - if (tag == LFSR_TAG_ORPHAN) { - return LFS_ERR_NOENT; + if (tag == LFS3_TAG_ORPHAN) { + return LFS3_ERR_NOENT; } // trying to remove the root dir? if (mdir.mid == -1) { - return LFS_ERR_INVAL; + return LFS3_ERR_INVAL; } // if we're removing a directory, we need to also remove the // bookmark entry - lfsr_did_t did_ = 0; - if (tag == LFSR_TAG_DIR) { + lfs3_did_t did_ = 0; + if (tag == LFS3_TAG_DIR) { // first lets figure out the did - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID, + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, &mdir, LFS3_TAG_DID, NULL, &data); if (err) { return err; } - err = lfsr_data_readleb128(lfs, &data, &did_); + err = lfs3_data_readleb128(lfs3, &data, &did_); if (err) { return err; } // mark bookmark for removal with grm - err = lfsr_grm_pushdid(lfs, did_); + err = lfs3_grm_pushdid(lfs3, did_); if (err) { return err; } } // are we removing an opened file? - bool zombie = lfsr_omdir_ismidopen(lfs, mdir.mid, -1); + bool zombie = lfs3_omdir_ismidopen(lfs3, mdir.mid, -1); // remove the metadata entry - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( // create a stickynote if zombied // // we use a create+delete here to also clear any rattrs // and trim the entry size (zombie) - ? LFSR_RATTR_NAME( - LFSR_TAG_MASK12 | LFSR_TAG_STICKYNOTE, 0, - did, path, lfsr_path_namelen(path)) - : LFSR_RATTR( - LFSR_TAG_RM, -1))); + ? LFS3_RATTR_NAME( + LFS3_TAG_MASK12 | LFS3_TAG_STICKYNOTE, 0, + did, path, lfs3_path_namelen(path)) + : LFS3_RATTR( + LFS3_TAG_RM, -1))); if (err) { return err; } // update in-device state - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // mark any clobbered uncreats as zombied if (zombie - && lfsr_o_type(o->flags) == LFS_TYPE_REG + && lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == mdir.mid) { - o->flags |= LFS_o_UNCREAT - | LFS_o_ZOMBIE - | LFS_o_UNSYNC - | LFS_O_DESYNC; + o->flags |= LFS3_o_UNCREAT + | LFS3_o_ZOMBIE + | LFS3_o_UNSYNC + | LFS3_O_DESYNC; // mark any removed dirs as zombied } else if (did_ - && lfsr_o_type(o->flags) == LFS_TYPE_DIR - && ((lfsr_dir_t*)o)->did == did_) { - o->flags |= LFS_o_ZOMBIE; + && lfs3_o_type(o->flags) == LFS3_TYPE_DIR + && ((lfs3_dir_t*)o)->did == did_) { + o->flags |= LFS3_o_ZOMBIE; // update dir positions - } else if (lfsr_o_type(o->flags) == LFS_TYPE_DIR - && ((lfsr_dir_t*)o)->did == did + } else if (lfs3_o_type(o->flags) == LFS3_TYPE_DIR + && ((lfs3_dir_t*)o)->did == did && o->mdir.mid >= mdir.mid) { - if (lfsr_o_iszombie(o->flags)) { - o->flags &= ~LFS_o_ZOMBIE; + if (lfs3_o_iszombie(o->flags)) { + o->flags &= ~LFS3_o_ZOMBIE; } else { - ((lfsr_dir_t*)o)->pos -= 1; + ((lfs3_dir_t*)o)->pos -= 1; } // clobber entangled traversals - } else if (lfsr_o_type(o->flags) == LFS_type_TRAVERSAL) { - if (lfsr_o_iszombie(o->flags)) { - o->flags &= ~LFS_o_ZOMBIE; + } else if (lfs3_o_type(o->flags) == LFS3_type_TRAVERSAL) { + if (lfs3_o_iszombie(o->flags)) { + o->flags &= ~LFS3_o_ZOMBIE; o->mdir.mid -= 1; - lfsr_traversal_clobber(lfs, (lfsr_traversal_t*)o); + lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)o); } } } // if we were a directory, we need to clean up, fortunately we can leave - // this up to lfsr_fs_fixgrm - err = lfsr_fs_fixgrm(lfs); + // this up to lfs3_fs_fixgrm + err = lfs3_fs_fixgrm(lfs3); if (err) { // we did complete the remove, so we shouldn't error here, best // we can do is log this - LFS_WARN("Failed to clean up grm (%d)", err); + LFS3_WARN("Failed to clean up grm (%d)", err); } return 0; } -int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { +int lfs3_rename(lfs3_t *lfs3, const char *old_path, const char *new_path) { // prepare our filesystem for writing - int err = lfsr_fs_mkconsistent(lfs); + int err = lfs3_fs_mkconsistent(lfs3); if (err) { return err; } // lookup old entry - lfsr_mdir_t old_mdir; - lfsr_tag_t old_tag; - lfsr_did_t old_did; - err = lfsr_mtree_pathlookup(lfs, &old_path, + lfs3_mdir_t old_mdir; + lfs3_tag_t old_tag; + lfs3_did_t old_did; + err = lfs3_mtree_pathlookup(lfs3, &old_path, &old_mdir, &old_tag, &old_did); if (err) { return err; } // pretend orphans don't exist - if (old_tag == LFSR_TAG_ORPHAN) { - return LFS_ERR_NOENT; + if (old_tag == LFS3_TAG_ORPHAN) { + return LFS3_ERR_NOENT; } // trying to rename the root? if (old_mdir.mid == -1) { - return LFS_ERR_INVAL; + return LFS3_ERR_INVAL; } // lookup new entry - lfsr_mdir_t new_mdir; - lfsr_tag_t new_tag; - lfsr_did_t new_did; - err = lfsr_mtree_pathlookup(lfs, &new_path, + lfs3_mdir_t new_mdir; + lfs3_tag_t new_tag; + lfs3_did_t new_did; + err = lfs3_mtree_pathlookup(lfs3, &new_path, &new_mdir, &new_tag, &new_did); - if (err && !(err == LFS_ERR_NOENT && lfsr_path_islast(new_path))) { + if (err && !(err == LFS3_ERR_NOENT && lfs3_path_islast(new_path))) { return err; } - bool exists = (err != LFS_ERR_NOENT); + bool exists = (err != LFS3_ERR_NOENT); // there are a few cases we need to watch out for - lfs_size_t new_name_len = lfsr_path_namelen(new_path); - lfsr_did_t new_did_ = 0; + lfs3_size_t new_name_len = lfs3_path_namelen(new_path); + lfs3_did_t new_did_ = 0; if (!exists) { // if we're a file, don't allow trailing slashes - if (old_tag != LFSR_TAG_DIR && lfsr_path_isdir(new_path)) { - return LFS_ERR_NOTDIR; + if (old_tag != LFS3_TAG_DIR && lfs3_path_isdir(new_path)) { + return LFS3_ERR_NOTDIR; } // check that name fits - if (new_name_len > lfs->name_limit) { - return LFS_ERR_NAMETOOLONG; + if (new_name_len > lfs3->name_limit) { + return LFS3_ERR_NAMETOOLONG; } } else { // trying to rename the root? if (new_mdir.mid == -1) { - return LFS_ERR_INVAL; + return LFS3_ERR_INVAL; } // we allow reg <-> stickynote renaming, but renaming a non-dir // to a dir and a dir to a non-dir is an error - if (old_tag != LFSR_TAG_DIR && new_tag == LFSR_TAG_DIR) { - return LFS_ERR_ISDIR; + if (old_tag != LFS3_TAG_DIR && new_tag == LFS3_TAG_DIR) { + return LFS3_ERR_ISDIR; } - if (old_tag == LFSR_TAG_DIR - && new_tag != LFSR_TAG_DIR + if (old_tag == LFS3_TAG_DIR + && new_tag != LFS3_TAG_DIR // pretend orphans don't exist - && new_tag != LFSR_TAG_ORPHAN) { - return LFS_ERR_NOTDIR; + && new_tag != LFS3_TAG_ORPHAN) { + return LFS3_ERR_NOTDIR; } // renaming to ourself is a noop @@ -10386,33 +10388,33 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { // if our destination is a directory, we will be implicitly removing // the directory, we need to create a grm for this - if (new_tag == LFSR_TAG_DIR) { - // TODO deduplicate the isempty check with lfsr_remove? + if (new_tag == LFS3_TAG_DIR) { + // TODO deduplicate the isempty check with lfs3_remove? // first lets figure out the did - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, &new_mdir, LFSR_TAG_DID, + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, &new_mdir, LFS3_TAG_DID, NULL, &data); if (err) { return err; } - err = lfsr_data_readleb128(lfs, &data, &new_did_); + err = lfs3_data_readleb128(lfs3, &data, &new_did_); if (err) { return err; } // mark bookmark for removal with grm - err = lfsr_grm_pushdid(lfs, new_did_); + err = lfs3_grm_pushdid(lfs3, new_did_); if (err) { return err; } } } - if (old_tag == LFSR_TAG_UNKNOWN) { + if (old_tag == LFS3_TAG_UNKNOWN) { // lookup the actual tag - err = lfsr_rbyd_lookup(lfs, &old_mdir.rbyd, - lfsr_mrid(lfs, old_mdir.mid), LFSR_TAG_MASK8 | LFSR_TAG_NAME, + err = lfs3_rbyd_lookup(lfs3, &old_mdir.rbyd, + lfs3_mrid(lfs3, old_mdir.mid), LFS3_TAG_MASK8 | LFS3_TAG_NAME, &old_tag, NULL); if (err) { return err; @@ -10420,90 +10422,90 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { } // mark old entry for removal with a grm - lfsr_grm_push(lfs, old_mdir.mid); + lfs3_grm_push(lfs3, old_mdir.mid); // rename our entry, copying all tags associated with the old rid to the // new rid, while also marking the old rid for removal - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_MASK12 | old_tag, (!exists) ? +1 : 0, + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &new_mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_MASK12 | old_tag, (!exists) ? +1 : 0, new_did, new_path, new_name_len), - LFSR_RATTR_MOVE(&old_mdir))); + LFS3_RATTR_MOVE(&old_mdir))); if (err) { return err; } // update in-device state - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { // mark any clobbered uncreats as zombied if (exists - && lfsr_o_type(o->flags) == LFS_TYPE_REG + && lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == new_mdir.mid) { - o->flags = (o->flags & ~LFS_o_UNCREAT) - | LFS_o_ZOMBIE - | LFS_o_UNSYNC - | LFS_O_DESYNC; + o->flags = (o->flags & ~LFS3_o_UNCREAT) + | LFS3_o_ZOMBIE + | LFS3_o_UNSYNC + | LFS3_O_DESYNC; // update moved files with the new mdir - } else if (lfsr_o_type(o->flags) == LFS_TYPE_REG - && o->mdir.mid == lfs->grm.queue[0]) { + } else if (lfs3_o_type(o->flags) == LFS3_TYPE_REG + && o->mdir.mid == lfs3->grm.queue[0]) { o->mdir = new_mdir; // mark any removed dirs as zombied } else if (new_did_ - && lfsr_o_type(o->flags) == LFS_TYPE_DIR - && ((lfsr_dir_t*)o)->did == new_did_) { - o->flags |= LFS_o_ZOMBIE; + && lfs3_o_type(o->flags) == LFS3_TYPE_DIR + && ((lfs3_dir_t*)o)->did == new_did_) { + o->flags |= LFS3_o_ZOMBIE; // update dir positions - } else if (lfsr_o_type(o->flags) == LFS_TYPE_DIR) { + } else if (lfs3_o_type(o->flags) == LFS3_TYPE_DIR) { if (!exists - && ((lfsr_dir_t*)o)->did == new_did + && ((lfs3_dir_t*)o)->did == new_did && o->mdir.mid >= new_mdir.mid) { - ((lfsr_dir_t*)o)->pos += 1; + ((lfs3_dir_t*)o)->pos += 1; } - if (((lfsr_dir_t*)o)->did == old_did - && o->mdir.mid >= lfs->grm.queue[0]) { - if (o->mdir.mid == lfs->grm.queue[0]) { + if (((lfs3_dir_t*)o)->did == old_did + && o->mdir.mid >= lfs3->grm.queue[0]) { + if (o->mdir.mid == lfs3->grm.queue[0]) { o->mdir.mid += 1; } else { - ((lfsr_dir_t*)o)->pos -= 1; + ((lfs3_dir_t*)o)->pos -= 1; } } // clobber entangled traversals - } else if (lfsr_o_type(o->flags) == LFS_type_TRAVERSAL + } else if (lfs3_o_type(o->flags) == LFS3_type_TRAVERSAL && ((exists && o->mdir.mid == new_mdir.mid) - || o->mdir.mid == lfs->grm.queue[0])) { - lfsr_traversal_clobber(lfs, (lfsr_traversal_t*)o); + || o->mdir.mid == lfs3->grm.queue[0])) { + lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)o); } } // we need to clean up any pending grms, fortunately we can leave - // this up to lfsr_fs_fixgrm - err = lfsr_fs_fixgrm(lfs); + // this up to lfs3_fs_fixgrm + err = lfs3_fs_fixgrm(lfs3); if (err) { // we did complete the remove, so we shouldn't error here, best // we can do is log this - LFS_WARN("Failed to clean up grm (%d)", err); + LFS3_WARN("Failed to clean up grm (%d)", err); } return 0; } // this just populates the info struct based on what we found -static int lfsr_stat_(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfsr_tag_t tag, lfsr_data_t name, - struct lfs_info *info) { +static int lfs3_stat_(lfs3_t *lfs3, const lfs3_mdir_t *mdir, + lfs3_tag_t tag, lfs3_data_t name, + struct lfs3_info *info) { // get file type from the tag - info->type = lfsr_tag_subtype(tag); + info->type = lfs3_tag_subtype(tag); // read the file name - LFS_ASSERT(lfsr_data_size(name) <= LFS_NAME_MAX); - lfs_ssize_t name_len = lfsr_data_read(lfs, &name, - info->name, LFS_NAME_MAX); + LFS3_ASSERT(lfs3_data_size(name) <= LFS3_NAME_MAX); + lfs3_ssize_t name_len = lfs3_data_read(lfs3, &name, + info->name, LFS3_NAME_MAX); if (name_len < 0) { return name_len; } @@ -10513,19 +10515,19 @@ static int lfsr_stat_(lfs_t *lfs, const lfsr_mdir_t *mdir, info->size = 0; // get file size if we're a regular file - if (tag == LFSR_TAG_REG) { - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, mdir, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + if (tag == LFS3_TAG_REG) { + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, mdir, + LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { + if (err != LFS3_ERR_NOENT) { // in bshrubs/btrees, size is always the first field - err = lfsr_data_readleb128(lfs, &data, &info->size); + err = lfs3_data_readleb128(lfs3, &data, &info->size); if (err) { return err; } @@ -10535,55 +10537,55 @@ static int lfsr_stat_(lfs_t *lfs, const lfsr_mdir_t *mdir, return 0; } -int lfsr_stat(lfs_t *lfs, const char *path, struct lfs_info *info) { +int lfs3_stat(lfs3_t *lfs3, const char *path, struct lfs3_info *info) { // lookup our entry - lfsr_mdir_t mdir; - lfsr_tag_t tag; - int err = lfsr_mtree_pathlookup(lfs, &path, + lfs3_mdir_t mdir; + lfs3_tag_t tag; + int err = lfs3_mtree_pathlookup(lfs3, &path, &mdir, &tag, NULL); if (err) { return err; } // pretend orphans don't exist - if (tag == LFSR_TAG_ORPHAN) { - return LFS_ERR_NOENT; + if (tag == LFS3_TAG_ORPHAN) { + return LFS3_ERR_NOENT; } // special case for root if (mdir.mid == -1) { - lfs_strcpy(info->name, "/"); - info->type = LFS_TYPE_DIR; + lfs3_strcpy(info->name, "/"); + info->type = LFS3_TYPE_DIR; info->size = 0; return 0; } // fill out our info struct - return lfsr_stat_(lfs, &mdir, - tag, LFSR_DATA_BUF(path, lfsr_path_namelen(path)), + return lfs3_stat_(lfs3, &mdir, + tag, LFS3_DATA_BUF(path, lfs3_path_namelen(path)), info); } -// needed in lfsr_dir_open -static int lfsr_dir_rewind_(lfs_t *lfs, lfsr_dir_t *dir); +// needed in lfs3_dir_open +static int lfs3_dir_rewind_(lfs3_t *lfs3, lfs3_dir_t *dir); -int lfsr_dir_open(lfs_t *lfs, lfsr_dir_t *dir, const char *path) { +int lfs3_dir_open(lfs3_t *lfs3, lfs3_dir_t *dir, const char *path) { // already open? - LFS_ASSERT(!lfsr_omdir_isopen(lfs, &dir->o)); + LFS3_ASSERT(!lfs3_omdir_isopen(lfs3, &dir->o)); // setup dir state - dir->o.flags = lfsr_o_typeflags(LFS_TYPE_DIR); + dir->o.flags = lfs3_o_typeflags(LFS3_TYPE_DIR); // lookup our directory - lfsr_mdir_t mdir; - lfsr_tag_t tag; - int err = lfsr_mtree_pathlookup(lfs, &path, + lfs3_mdir_t mdir; + lfs3_tag_t tag; + int err = lfs3_mtree_pathlookup(lfs3, &path, &mdir, &tag, NULL); if (err) { return err; } // pretend orphans don't exist - if (tag == LFSR_TAG_ORPHAN) { - return LFS_ERR_NOENT; + if (tag == LFS3_TAG_ORPHAN) { + return LFS3_ERR_NOENT; } // read our did from the mdir, unless we're root @@ -10592,60 +10594,60 @@ int lfsr_dir_open(lfs_t *lfs, lfsr_dir_t *dir, const char *path) { } else { // not a directory? - if (tag != LFSR_TAG_DIR) { - return LFS_ERR_NOTDIR; + if (tag != LFS3_TAG_DIR) { + return LFS3_ERR_NOTDIR; } - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID, + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, &mdir, LFS3_TAG_DID, NULL, &data); if (err) { return err; } - err = lfsr_data_readleb128(lfs, &data, &dir->did); + err = lfs3_data_readleb128(lfs3, &data, &dir->did); if (err) { return err; } } // let rewind initialize the pos state - err = lfsr_dir_rewind_(lfs, dir); + err = lfs3_dir_rewind_(lfs3, dir); if (err) { return err; } // add to tracked mdirs - lfsr_omdir_open(lfs, &dir->o); + lfs3_omdir_open(lfs3, &dir->o); return 0; } -int lfsr_dir_close(lfs_t *lfs, lfsr_dir_t *dir) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &dir->o)); +int lfs3_dir_close(lfs3_t *lfs3, lfs3_dir_t *dir) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &dir->o)); // remove from tracked mdirs - lfsr_omdir_close(lfs, &dir->o); + lfs3_omdir_close(lfs3, &dir->o); return 0; } -int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &dir->o)); +int lfs3_dir_read(lfs3_t *lfs3, lfs3_dir_t *dir, struct lfs3_info *info) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &dir->o)); // was our dir removed? - if (lfsr_o_iszombie(dir->o.flags)) { - return LFS_ERR_NOENT; + if (lfs3_o_iszombie(dir->o.flags)) { + return LFS3_ERR_NOENT; } // handle dots specially if (dir->pos == 0) { - lfs_strcpy(info->name, "."); - info->type = LFS_TYPE_DIR; + lfs3_strcpy(info->name, "."); + info->type = LFS3_TYPE_DIR; info->size = 0; dir->pos += 1; return 0; } else if (dir->pos == 1) { - lfs_strcpy(info->name, ".."); - info->type = LFS_TYPE_DIR; + lfs3_strcpy(info->name, ".."); + info->type = LFS3_TYPE_DIR; info->size = 0; dir->pos += 1; return 0; @@ -10653,10 +10655,10 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) { while (true) { // next mdir? - if (lfsr_mrid(lfs, dir->o.mdir.mid) - >= (lfsr_srid_t)dir->o.mdir.rbyd.weight) { - int err = lfsr_mtree_lookup(lfs, - lfsr_mbid(lfs, dir->o.mdir.mid-1) + 1, + if (lfs3_mrid(lfs3, dir->o.mdir.mid) + >= (lfs3_srid_t)dir->o.mdir.rbyd.weight) { + int err = lfs3_mtree_lookup(lfs3, + lfs3_mbid(lfs3, dir->o.mdir.mid-1) + 1, &dir->o.mdir); if (err) { return err; @@ -10664,36 +10666,36 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) { } // lookup the next name tag - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, &dir->o.mdir, - LFSR_TAG_MASK8 | LFSR_TAG_NAME, + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, &dir->o.mdir, + LFS3_TAG_MASK8 | LFS3_TAG_NAME, &tag, &data); if (err) { return err; } // get the did - lfsr_did_t did; - err = lfsr_data_readleb128(lfs, &data, &did); + lfs3_did_t did; + err = lfs3_data_readleb128(lfs3, &data, &did); if (err) { return err; } // did mismatch? this terminates the dir read if (did != dir->did) { - return LFS_ERR_NOENT; + return LFS3_ERR_NOENT; } // skip orphans, we pretend these don't exist - if (tag == LFSR_TAG_ORPHAN) { + if (tag == LFS3_TAG_ORPHAN) { dir->o.mdir.mid += 1; dir->pos += 1; continue; } // fill out our info struct - err = lfsr_stat_(lfs, &dir->o.mdir, tag, data, + err = lfs3_stat_(lfs3, &dir->o.mdir, tag, data, info); if (err) { return err; @@ -10706,16 +10708,16 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) { } } -int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &dir->o)); +int lfs3_dir_seek(lfs3_t *lfs3, lfs3_dir_t *dir, lfs3_soff_t off) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &dir->o)); // do nothing if removed - if (lfsr_o_iszombie(dir->o.flags)) { + if (lfs3_o_iszombie(dir->o.flags)) { return 0; } // first rewind - int err = lfsr_dir_rewind_(lfs, dir); + int err = lfs3_dir_rewind_(lfs3, dir); if (err) { return err; } @@ -10723,26 +10725,26 @@ int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off) { // then seek to the requested offset // // note the -2 to adjust for dot entries - lfs_off_t off_ = off - 2; + lfs3_off_t off_ = off - 2; while (off_ > 0) { // next mdir? - if (lfsr_mrid(lfs, dir->o.mdir.mid) - >= (lfsr_srid_t)dir->o.mdir.rbyd.weight) { - int err = lfsr_mtree_lookup(lfs, - lfsr_mbid(lfs, dir->o.mdir.mid-1) + 1, + if (lfs3_mrid(lfs3, dir->o.mdir.mid) + >= (lfs3_srid_t)dir->o.mdir.rbyd.weight) { + int err = lfs3_mtree_lookup(lfs3, + lfs3_mbid(lfs3, dir->o.mdir.mid-1) + 1, &dir->o.mdir); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; } } - lfs_off_t d = lfs_min( + lfs3_off_t d = lfs3_min( off_, dir->o.mdir.rbyd.weight - - lfsr_mrid(lfs, dir->o.mdir.mid)); + - lfs3_mrid(lfs3, dir->o.mdir.mid)); dir->o.mdir.mid += d; off_ -= d; } @@ -10751,24 +10753,24 @@ int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off) { return 0; } -lfs_soff_t lfsr_dir_tell(lfs_t *lfs, lfsr_dir_t *dir) { - (void)lfs; - LFS_ASSERT(lfsr_omdir_isopen(lfs, &dir->o)); +lfs3_soff_t lfs3_dir_tell(lfs3_t *lfs3, lfs3_dir_t *dir) { + (void)lfs3; + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &dir->o)); return dir->pos; } -static int lfsr_dir_rewind_(lfs_t *lfs, lfsr_dir_t *dir) { +static int lfs3_dir_rewind_(lfs3_t *lfs3, lfs3_dir_t *dir) { // do nothing if removed - if (lfsr_o_iszombie(dir->o.flags)) { + if (lfs3_o_iszombie(dir->o.flags)) { return 0; } // lookup our bookmark in the mtree - int err = lfsr_mtree_namelookup(lfs, dir->did, NULL, 0, + int err = lfs3_mtree_namelookup(lfs3, dir->did, NULL, 0, &dir->o.mdir, NULL, NULL); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } @@ -10779,10 +10781,10 @@ static int lfsr_dir_rewind_(lfs_t *lfs, lfsr_dir_t *dir) { return 0; } -int lfsr_dir_rewind(lfs_t *lfs, lfsr_dir_t *dir) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &dir->o)); +int lfs3_dir_rewind(lfs3_t *lfs3, lfs3_dir_t *dir) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &dir->o)); - return lfsr_dir_rewind_(lfs, dir); + return lfs3_dir_rewind_(lfs3, dir); } @@ -10790,26 +10792,26 @@ int lfsr_dir_rewind(lfs_t *lfs, lfsr_dir_t *dir) { /// Custom attribute stuff /// -static int lfsr_lookupattr(lfs_t *lfs, const char *path, uint8_t type, - lfsr_mdir_t *mdir_, lfsr_data_t *data_) { +static int lfs3_lookupattr(lfs3_t *lfs3, const char *path, uint8_t type, + lfs3_mdir_t *mdir_, lfs3_data_t *data_) { // lookup our entry - lfsr_tag_t tag; - int err = lfsr_mtree_pathlookup(lfs, &path, + lfs3_tag_t tag; + int err = lfs3_mtree_pathlookup(lfs3, &path, mdir_, &tag, NULL); if (err) { return err; } // pretend orphans don't exist - if (tag == LFSR_TAG_ORPHAN) { - return LFS_ERR_NOENT; + if (tag == LFS3_TAG_ORPHAN) { + return LFS3_ERR_NOENT; } // lookup our attr - err = lfsr_mdir_lookup(lfs, mdir_, LFSR_TAG_ATTR(type), + err = lfs3_mdir_lookup(lfs3, mdir_, LFS3_TAG_ATTR(type), NULL, data_); if (err) { - if (err == LFS_ERR_NOENT) { - return LFS_ERR_NOATTR; + if (err == LFS3_ERR_NOENT) { + return LFS3_ERR_NOATTR; } return err; } @@ -10817,79 +10819,79 @@ static int lfsr_lookupattr(lfs_t *lfs, const char *path, uint8_t type, return 0; } -lfs_ssize_t lfsr_getattr(lfs_t *lfs, const char *path, uint8_t type, - void *buffer, lfs_size_t size) { +lfs3_ssize_t lfs3_getattr(lfs3_t *lfs3, const char *path, uint8_t type, + void *buffer, lfs3_size_t size) { // lookup our attr - lfsr_mdir_t mdir; - lfsr_data_t data; - int err = lfsr_lookupattr(lfs, path, type, + lfs3_mdir_t mdir; + lfs3_data_t data; + int err = lfs3_lookupattr(lfs3, path, type, &mdir, &data); if (err) { return err; } // read the attr - return lfsr_data_read(lfs, &data, buffer, size); + return lfs3_data_read(lfs3, &data, buffer, size); } -lfs_ssize_t lfsr_sizeattr(lfs_t *lfs, const char *path, uint8_t type) { +lfs3_ssize_t lfs3_sizeattr(lfs3_t *lfs3, const char *path, uint8_t type) { // lookup our attr - lfsr_mdir_t mdir; - lfsr_data_t data; - int err = lfsr_lookupattr(lfs, path, type, + lfs3_mdir_t mdir; + lfs3_data_t data; + int err = lfs3_lookupattr(lfs3, path, type, &mdir, &data); if (err) { return err; } // return the attr size - return lfsr_data_size(data); + return lfs3_data_size(data); } -int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type, - const void *buffer, lfs_size_t size) { +int lfs3_setattr(lfs3_t *lfs3, const char *path, uint8_t type, + const void *buffer, lfs3_size_t size) { // prepare our filesystem for writing - int err = lfsr_fs_mkconsistent(lfs); + int err = lfs3_fs_mkconsistent(lfs3); if (err) { return err; } // lookup our attr - lfsr_mdir_t mdir; - lfsr_data_t data; - err = lfsr_lookupattr(lfs, path, type, + lfs3_mdir_t mdir; + lfs3_data_t data; + err = lfs3_lookupattr(lfs3, path, type, &mdir, &data); - if (err && err != LFS_ERR_NOATTR) { + if (err && err != LFS3_ERR_NOATTR) { return err; } // commit our attr - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(type), 0, + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(type), 0, buffer, size))); if (err) { return err; } // update any opened files tracking custom attrs - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (!(lfsr_o_type(o->flags) == LFS_TYPE_REG + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (!(lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == mdir.mid - && !lfsr_o_isdesync(o->flags))) { + && !lfs3_o_isdesync(o->flags))) { continue; } - lfsr_file_t *file = (lfsr_file_t*)o; - for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) { + lfs3_file_t *file = (lfs3_file_t*)o; + for (lfs3_size_t i = 0; i < file->cfg->attr_count; i++) { if (!(file->cfg->attrs[i].type == type - && !lfsr_o_iswronly(file->cfg->attrs[i].flags))) { + && !lfs3_o_iswronly(file->cfg->attrs[i].flags))) { continue; } - lfs_size_t d = lfs_min(size, file->cfg->attrs[i].buffer_size); - lfs_memcpy(file->cfg->attrs[i].buffer, buffer, d); + lfs3_size_t d = lfs3_min(size, file->cfg->attrs[i].buffer_size); + lfs3_memcpy(file->cfg->attrs[i].buffer, buffer, d); if (file->cfg->attrs[i].size) { *file->cfg->attrs[i].size = d; } @@ -10900,47 +10902,47 @@ int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type, return 0; } -int lfsr_removeattr(lfs_t *lfs, const char *path, uint8_t type) { +int lfs3_removeattr(lfs3_t *lfs3, const char *path, uint8_t type) { // prepare our filesystem for writing - int err = lfsr_fs_mkconsistent(lfs); + int err = lfs3_fs_mkconsistent(lfs3); if (err) { return err; } // lookup our attr - lfsr_mdir_t mdir; - err = lfsr_lookupattr(lfs, path, type, + lfs3_mdir_t mdir; + err = lfs3_lookupattr(lfs3, path, type, &mdir, NULL); if (err) { return err; } // commit our removal - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(type), 0))); + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(type), 0))); if (err) { return err; } // update any opened files tracking custom attrs - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (!(lfsr_o_type(o->flags) == LFS_TYPE_REG + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (!(lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == mdir.mid - && !lfsr_o_isdesync(o->flags))) { + && !lfs3_o_isdesync(o->flags))) { continue; } - lfsr_file_t *file = (lfsr_file_t*)o; - for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) { + lfs3_file_t *file = (lfs3_file_t*)o; + for (lfs3_size_t i = 0; i < file->cfg->attr_count; i++) { if (!(file->cfg->attrs[i].type == type - && !lfsr_o_iswronly(file->cfg->attrs[i].flags))) { + && !lfs3_o_iswronly(file->cfg->attrs[i].flags))) { continue; } if (file->cfg->attrs[i].size) { - *file->cfg->attrs[i].size = LFS_ERR_NOATTR; + *file->cfg->attrs[i].size = LFS3_ERR_NOATTR; } } } @@ -10954,63 +10956,63 @@ int lfsr_removeattr(lfs_t *lfs, const char *path, uint8_t type) { /// File operations /// // file helpers -static inline void lfsr_file_discardcache(lfsr_file_t *file) { - file->b.o.flags &= ~LFS_o_UNFLUSH; +static inline void lfs3_file_discardcache(lfs3_file_t *file) { + file->b.o.flags &= ~LFS3_o_UNFLUSH; file->cache.pos = 0; file->cache.size = 0; } -static inline void lfsr_file_discardleaf(lfsr_file_t *file) { - file->b.o.flags &= ~LFS_o_UNCRYST & ~LFS_o_UNGRAFT; +static inline void lfs3_file_discardleaf(lfs3_file_t *file) { + file->b.o.flags &= ~LFS3_o_UNCRYST & ~LFS3_o_UNGRAFT; file->leaf.pos = 0; file->leaf.weight = 0; - lfsr_bptr_discard(&file->leaf.bptr); + lfs3_bptr_discard(&file->leaf.bptr); } -static inline void lfsr_file_discardbshrub(lfsr_file_t *file) { - lfsr_bshrub_init(&file->b); +static inline void lfs3_file_discardbshrub(lfs3_file_t *file) { + lfs3_bshrub_init(&file->b); } -static inline lfs_size_t lfsr_file_cachesize(lfs_t *lfs, - const lfsr_file_t *file) { +static inline lfs3_size_t lfs3_file_cachesize(lfs3_t *lfs3, + const lfs3_file_t *file) { return (file->cfg->cache_size) ? file->cfg->cache_size - : lfs->cfg->file_cache_size; + : lfs3->cfg->file_cache_size; } -static inline lfs_off_t lfsr_file_weight(const lfsr_file_t *file) { - return lfs_max( +static inline lfs3_off_t lfs3_file_weight(const lfs3_file_t *file) { + return lfs3_max( file->leaf.pos + file->leaf.weight, file->b.shrub.weight); } -static inline lfs_off_t lfsr_file_size_(const lfsr_file_t *file) { - return lfs_max( +static inline lfs3_off_t lfs3_file_size_(const lfs3_file_t *file) { + return lfs3_max( file->cache.pos + file->cache.size, - lfsr_file_weight(file)); + lfs3_file_weight(file)); } // file operations -static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) { +static int lfs3_file_fetch(lfs3_t *lfs3, lfs3_file_t *file, bool trunc) { // default data state - lfsr_file_discardbshrub(file); + lfs3_file_discardbshrub(file); // discard the current cache - lfsr_file_discardcache(file); + lfs3_file_discardcache(file); // discard the current leaf - lfsr_file_discardleaf(file); + lfs3_file_discardleaf(file); // don't bother reading disk if we're not created or truncating - if (!lfsr_o_isuncreat(file->b.o.flags) && !trunc) { + if (!lfs3_o_isuncreat(file->b.o.flags) && !trunc) { // lookup the file struct, if there is one - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, &file->b.o.mdir, - LFSR_TAG_MASK8 | LFSR_TAG_DATA, + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, &file->b.o.mdir, + LFS3_TAG_MASK8 | LFS3_TAG_DATA, &tag, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } @@ -11019,25 +11021,25 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) { file->b.shrub_ = file->b.shrub; // found a bshrub/btree? - if (err != LFS_ERR_NOENT) { + if (err != LFS3_ERR_NOENT) { // may be a bshrub (inlined btree) - if (tag == LFSR_TAG_BSHRUB) { - err = lfsr_data_readshrub(lfs, &data, &file->b.o.mdir, + if (tag == LFS3_TAG_BSHRUB) { + err = lfs3_data_readshrub(lfs3, &data, &file->b.o.mdir, &file->b.shrub_); if (err) { return err; } // or a btree - } else if (tag == LFSR_TAG_BTREE) { - err = lfsr_data_fetchbtree(lfs, &data, + } else if (tag == LFS3_TAG_BTREE) { + err = lfs3_data_fetchbtree(lfs3, &data, &file->b.shrub_); if (err) { return err; } } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } @@ -11045,42 +11047,42 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) { file->b.shrub = file->b.shrub_; // mark as in-sync - file->b.o.flags &= ~LFS_o_UNSYNC; + file->b.o.flags &= ~LFS3_o_UNSYNC; } // try to fetch any custom attributes - for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) { + for (lfs3_size_t i = 0; i < file->cfg->attr_count; i++) { // skip writeonly attrs - if (lfsr_o_iswronly(file->cfg->attrs[i].flags)) { + if (lfs3_o_iswronly(file->cfg->attrs[i].flags)) { continue; } // don't bother reading disk if we're not created yet - if (lfsr_o_isuncreat(file->b.o.flags)) { + if (lfs3_o_isuncreat(file->b.o.flags)) { if (file->cfg->attrs[i].size) { - *file->cfg->attrs[i].size = LFS_ERR_NOATTR; + *file->cfg->attrs[i].size = LFS3_ERR_NOATTR; } continue; } // lookup the attr - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, &file->b.o.mdir, - LFSR_TAG_ATTR(file->cfg->attrs[i].type), + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, &file->b.o.mdir, + LFS3_TAG_ATTR(file->cfg->attrs[i].type), NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } // read the attr, if it exists - if (err == LFS_ERR_NOENT - // awkward case here if buffer_size is LFS_ERR_NOATTR - || file->cfg->attrs[i].buffer_size == LFS_ERR_NOATTR) { + if (err == LFS3_ERR_NOENT + // awkward case here if buffer_size is LFS3_ERR_NOATTR + || file->cfg->attrs[i].buffer_size == LFS3_ERR_NOATTR) { if (file->cfg->attrs[i].size) { - *file->cfg->attrs[i].size = LFS_ERR_NOATTR; + *file->cfg->attrs[i].size = LFS3_ERR_NOATTR; } } else { - lfs_ssize_t d = lfsr_data_read(lfs, &data, + lfs3_ssize_t d = lfs3_data_read(lfs3, &data, file->cfg->attrs[i].buffer, file->cfg->attrs[i].buffer_size); if (d < 0) { @@ -11096,52 +11098,52 @@ static int lfsr_file_fetch(lfs_t *lfs, lfsr_file_t *file, bool trunc) { return 0; } -// needed in lfsr_file_opencfg -static void lfsr_file_close_(lfs_t *lfs, const lfsr_file_t *file); -static int lfsr_file_ck(lfs_t *lfs, const lfsr_file_t *file, +// needed in lfs3_file_opencfg +static void lfs3_file_close_(lfs3_t *lfs3, const lfs3_file_t *file); +static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file, uint32_t flags); -int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, +int lfs3_file_opencfg(lfs3_t *lfs3, lfs3_file_t *file, const char *path, uint32_t flags, - const struct lfs_file_config *cfg) { + const struct lfs3_file_config *cfg) { // already open? - LFS_ASSERT(!lfsr_omdir_isopen(lfs, &file->b.o)); + LFS3_ASSERT(!lfs3_omdir_isopen(lfs3, &file->b.o)); // don't allow the forbidden mode! - LFS_ASSERT((flags & 3) != 3); + LFS3_ASSERT((flags & 3) != 3); // unknown flags? - LFS_ASSERT((flags & ~( - LFS_O_RDONLY - | LFS_O_WRONLY - | LFS_O_RDWR - | LFS_O_CREAT - | LFS_O_EXCL - | LFS_O_TRUNC - | LFS_O_APPEND - | LFS_O_FLUSH - | LFS_O_SYNC - | LFS_O_DESYNC - | LFS_O_CKMETA - | LFS_O_CKDATA)) == 0); + LFS3_ASSERT((flags & ~( + LFS3_O_RDONLY + | LFS3_O_WRONLY + | LFS3_O_RDWR + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_TRUNC + | LFS3_O_APPEND + | LFS3_O_FLUSH + | LFS3_O_SYNC + | LFS3_O_DESYNC + | LFS3_O_CKMETA + | LFS3_O_CKDATA)) == 0); // writeable files require a writeable filesystem - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags) || lfsr_o_isrdonly(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) || lfs3_o_isrdonly(flags)); // these flags require a writable file - LFS_ASSERT(!lfsr_o_isrdonly(flags) || !lfsr_o_iscreat(flags)); - LFS_ASSERT(!lfsr_o_isrdonly(flags) || !lfsr_o_isexcl(flags)); - LFS_ASSERT(!lfsr_o_isrdonly(flags) || !lfsr_o_istrunc(flags)); - for (lfs_size_t i = 0; i < cfg->attr_count; i++) { + LFS3_ASSERT(!lfs3_o_isrdonly(flags) || !lfs3_o_iscreat(flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(flags) || !lfs3_o_isexcl(flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(flags) || !lfs3_o_istrunc(flags)); + for (lfs3_size_t i = 0; i < cfg->attr_count; i++) { // these flags require a writable attr - LFS_ASSERT(!lfsr_o_isrdonly(cfg->attrs[i].flags) - || !lfsr_o_iscreat(cfg->attrs[i].flags)); - LFS_ASSERT(!lfsr_o_isrdonly(cfg->attrs[i].flags) - || !lfsr_o_isexcl(cfg->attrs[i].flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(cfg->attrs[i].flags) + || !lfs3_o_iscreat(cfg->attrs[i].flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(cfg->attrs[i].flags) + || !lfs3_o_isexcl(cfg->attrs[i].flags)); } - // mounted with LFS_M_FLUSH/SYNC? implies LFS_O_FLUSH/SYNC - flags |= lfs->flags & (LFS_M_FLUSH | LFS_M_SYNC); + // mounted with LFS3_M_FLUSH/SYNC? implies LFS3_O_FLUSH/SYNC + flags |= lfs3->flags & (LFS3_M_FLUSH | LFS3_M_SYNC); - if (!lfsr_o_isrdonly(flags)) { + if (!lfs3_o_isrdonly(flags)) { // prepare our filesystem for writing - int err = lfsr_fs_mkconsistent(lfs); + int err = lfs3_fs_mkconsistent(lfs3); if (err) { return err; } @@ -11150,195 +11152,195 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, // setup file state file->cfg = cfg; file->b.o.flags = flags - | lfsr_o_typeflags(LFS_TYPE_REG) + | lfs3_o_typeflags(LFS3_TYPE_REG) // default to unsynced for uncreated/truncated files - | LFS_o_UNSYNC; + | LFS3_o_UNSYNC; file->pos = 0; // lookup our parent - lfsr_tag_t tag; - lfsr_did_t did; - int err = lfsr_mtree_pathlookup(lfs, &path, + lfs3_tag_t tag; + lfs3_did_t did; + int err = lfs3_mtree_pathlookup(lfs3, &path, &file->b.o.mdir, &tag, &did); - if (err && !(err == LFS_ERR_NOENT && lfsr_path_islast(path))) { + if (err && !(err == LFS3_ERR_NOENT && lfs3_path_islast(path))) { return err; } - bool exists = err != LFS_ERR_NOENT; + bool exists = err != LFS3_ERR_NOENT; // creating a new entry? - if (!exists || tag == LFSR_TAG_ORPHAN) { - if (!lfsr_o_iscreat(flags)) { - return LFS_ERR_NOENT; + if (!exists || tag == LFS3_TAG_ORPHAN) { + if (!lfs3_o_iscreat(flags)) { + return LFS3_ERR_NOENT; } - LFS_ASSERT(!lfsr_o_isrdonly(flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(flags)); // we're a file, don't allow trailing slashes - if (lfsr_path_isdir(path)) { - return LFS_ERR_NOTDIR; + if (lfs3_path_isdir(path)) { + return LFS3_ERR_NOTDIR; } // create a stickynote entry if we don't have one, this reserves the // mid until first sync if (!exists) { // check that name fits - lfs_size_t name_len = lfsr_path_namelen(path); - if (name_len > lfs->name_limit) { - return LFS_ERR_NAMETOOLONG; + lfs3_size_t name_len = lfs3_path_namelen(path); + if (name_len > lfs3->name_limit) { + return LFS3_ERR_NAMETOOLONG; } - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &file->b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_STICKYNOTE, +1, + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, &file->b.o.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_STICKYNOTE, +1, did, path, name_len))); if (err) { return err; } // update dir positions - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_type(o->flags) == LFS_TYPE_DIR - && ((lfsr_dir_t*)o)->did == did + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_type(o->flags) == LFS3_TYPE_DIR + && ((lfs3_dir_t*)o)->did == did && o->mdir.mid >= file->b.o.mdir.mid) { - ((lfsr_dir_t*)o)->pos += 1; + ((lfs3_dir_t*)o)->pos += 1; } } } } else { // wanted to create a new entry? - if (lfsr_o_isexcl(flags)) { - return LFS_ERR_EXIST; + if (lfs3_o_isexcl(flags)) { + return LFS3_ERR_EXIST; } // wrong type? - if (tag == LFSR_TAG_DIR) { - return LFS_ERR_ISDIR; + if (tag == LFS3_TAG_DIR) { + return LFS3_ERR_ISDIR; } - if (tag == LFSR_TAG_UNKNOWN) { - return LFS_ERR_NOTSUP; + if (tag == LFS3_TAG_UNKNOWN) { + return LFS3_ERR_NOTSUP; } } // if stickynote, mark as uncreated, we need to convert to reg file // on first sync if (!exists - || tag == LFSR_TAG_STICKYNOTE - || tag == LFSR_TAG_ORPHAN) { - file->b.o.flags |= LFS_o_UNCREAT; + || tag == LFS3_TAG_STICKYNOTE + || tag == LFS3_TAG_ORPHAN) { + file->b.o.flags |= LFS3_o_UNCREAT; } // allocate cache if necessary if (file->cfg->cache_buffer) { file->cache.buffer = file->cfg->cache_buffer; } else { - file->cache.buffer = lfs_malloc(lfsr_file_cachesize(lfs, file)); + file->cache.buffer = lfs3_malloc(lfs3_file_cachesize(lfs3, file)); if (!file->cache.buffer) { - return LFS_ERR_NOMEM; + return LFS3_ERR_NOMEM; } } // fetch the file struct and custom attrs - err = lfsr_file_fetch(lfs, file, lfsr_o_istrunc(flags)); + err = lfs3_file_fetch(lfs3, file, lfs3_o_istrunc(flags)); if (err) { goto failed; } // check metadata/data for errors? - if (lfsr_t_isckmeta(flags) || lfsr_t_isckdata(flags)) { - err = lfsr_file_ck(lfs, file, flags); + if (lfs3_t_isckmeta(flags) || lfs3_t_isckdata(flags)) { + err = lfs3_file_ck(lfs3, file, flags); if (err) { goto failed; } } // add to tracked mdirs - lfsr_omdir_open(lfs, &file->b.o); + lfs3_omdir_open(lfs3, &file->b.o); return 0; failed:; // clean up resources - lfsr_file_close_(lfs, file); + lfs3_file_close_(lfs3, file); return err; } // default file config -static const struct lfs_file_config lfsr_file_defaults = {0}; +static const struct lfs3_file_config lfs3_file_defaults = {0}; -int lfsr_file_open(lfs_t *lfs, lfsr_file_t *file, +int lfs3_file_open(lfs3_t *lfs3, lfs3_file_t *file, const char *path, uint32_t flags) { - return lfsr_file_opencfg(lfs, file, path, flags, &lfsr_file_defaults); + return lfs3_file_opencfg(lfs3, file, path, flags, &lfs3_file_defaults); } // clean up resources -static void lfsr_file_close_(lfs_t *lfs, const lfsr_file_t *file) { +static void lfs3_file_close_(lfs3_t *lfs3, const lfs3_file_t *file) { // clean up memory if (!file->cfg->cache_buffer) { - lfs_free(file->cache.buffer); + lfs3_free(file->cache.buffer); } // are we orphaning a file? // // make sure we check _after_ removing ourselves - if (lfsr_o_isuncreat(file->b.o.flags) - && !lfsr_omdir_ismidopen(lfs, file->b.o.mdir.mid, -1)) { + if (lfs3_o_isuncreat(file->b.o.flags) + && !lfs3_omdir_ismidopen(lfs3, file->b.o.mdir.mid, -1)) { // this gets a bit messy, since we're not able to write to the // filesystem if we're rdonly or desynced, fortunately we have // a few tricks // first try to push onto our grm queue - if (lfsr_grm_count(lfs) < 2) { - lfsr_grm_push(lfs, file->b.o.mdir.mid); + if (lfs3_grm_count(lfs3) < 2) { + lfs3_grm_push(lfs3, file->b.o.mdir.mid); // fallback to just marking the filesystem as inconsistent } else { - lfs->flags |= LFS_I_MKCONSISTENT; + lfs3->flags |= LFS3_I_MKCONSISTENT; } } } -// needed in lfsr_file_close -int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file); +// needed in lfs3_file_close +int lfs3_file_sync(lfs3_t *lfs3, lfs3_file_t *file); -int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_close(lfs3_t *lfs3, lfs3_file_t *file) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); - // don't call lfsr_file_sync if we're readonly or desynced + // don't call lfs3_file_sync if we're readonly or desynced int err = 0; - if (!lfsr_o_isrdonly(file->b.o.flags) - && !lfsr_o_isdesync(file->b.o.flags)) { - err = lfsr_file_sync(lfs, file); + if (!lfs3_o_isrdonly(file->b.o.flags) + && !lfs3_o_isdesync(file->b.o.flags)) { + err = lfs3_file_sync(lfs3, file); } // remove from tracked mdirs - lfsr_omdir_close(lfs, &file->b.o); + lfs3_omdir_close(lfs3, &file->b.o); // clean up resources - lfsr_file_close_(lfs, file); + lfs3_file_close_(lfs3, file); return err; } // low-level file reading -static int lfsr_file_lookup_(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_tag_t tag; - lfsr_bid_t weight; - lfsr_data_t data; - int err = lfsr_bshrub_lookupnext(lfs, &file->b, bid, +static int lfs3_file_lookup_(lfs3_t *lfs3, const lfs3_file_t *file, + lfs3_bid_t bid, + lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_bptr_t *bptr_) { + lfs3_tag_t tag; + lfs3_bid_t weight; + lfs3_data_t data; + int err = lfs3_bshrub_lookupnext(lfs3, &file->b, bid, bid_, &tag, &weight, &data); if (err) { return err; } - LFS_ASSERT(tag == LFSR_TAG_DATA - || tag == LFSR_TAG_BLOCK); + LFS3_ASSERT(tag == LFS3_TAG_DATA + || tag == LFS3_TAG_BLOCK); // decode bptrs - if (tag == LFSR_TAG_DATA) { + if (tag == LFS3_TAG_DATA) { bptr_->data = data; } else { - err = lfsr_data_readbptr(lfs, &data, bptr_); + err = lfs3_data_readbptr(lfs3, &data, bptr_); if (err) { return err; } @@ -11346,7 +11348,7 @@ static int lfsr_file_lookup_(lfs_t *lfs, const lfsr_file_t *file, // limit bptrs to btree weights, this may be useful for // compression in the future - bptr_->data = LFSR_DATA_TRUNCATE(bptr_->data, weight); + bptr_->data = LFS3_DATA_TRUNCATE(bptr_->data, weight); if (weight_) { *weight_ = weight; @@ -11354,9 +11356,9 @@ static int lfsr_file_lookup_(lfs_t *lfs, const lfsr_file_t *file, return 0; } -static int lfsr_file_lookup(lfs_t *lfs, const lfsr_file_t *file, - lfsr_bid_t bid, - lfsr_bid_t *bid_, lfsr_bid_t *weight_, lfsr_bptr_t *bptr_) { +static int lfs3_file_lookup(lfs3_t *lfs3, const lfs3_file_t *file, + lfs3_bid_t bid, + lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_bptr_t *bptr_) { // hits our leaf? if (bid >= file->leaf.pos && bid < file->leaf.pos + file->leaf.weight) { @@ -11379,14 +11381,14 @@ static int lfsr_file_lookup(lfs_t *lfs, const lfsr_file_t *file, if (weight_) { *weight_ = file->leaf.pos - file->b.shrub.weight; } - lfsr_bptr_discard(bptr_); + lfs3_bptr_discard(bptr_); return 0; } // lookup on disk - lfsr_bid_t bid__; - lfsr_bid_t weight__; - int err = lfsr_file_lookup_(lfs, file, bid, + lfs3_bid_t bid__; + lfs3_bid_t weight__; + int err = lfs3_file_lookup_(lfs3, file, bid, &bid__, &weight__, bptr_); if (err) { return err; @@ -11397,21 +11399,21 @@ static int lfsr_file_lookup(lfs_t *lfs, const lfsr_file_t *file, // slice left leaf? if (bid > file->leaf.pos + file->leaf.weight && bid__-(weight__-1) < file->leaf.pos + file->leaf.weight) { - lfs_soff_t d = (file->leaf.pos + file->leaf.weight) + lfs3_soff_t d = (file->leaf.pos + file->leaf.weight) - (bid__-(weight__-1)); weight__ -= d; - bptr_->data = LFSR_DATA_SLICE(bptr_->data, - lfs_min(d, lfsr_bptr_size(bptr_)), + bptr_->data = LFS3_DATA_SLICE(bptr_->data, + lfs3_min(d, lfs3_bptr_size(bptr_)), -1); // slice right leaf? } else if (bid < file->leaf.pos && bid__+1 > file->leaf.pos) { - lfs_soff_t d = bid__+1 - file->leaf.pos; + lfs3_soff_t d = bid__+1 - file->leaf.pos; bid__ -= d; weight__ -= d; - bptr_->data = LFSR_DATA_SLICE(bptr_->data, + bptr_->data = LFS3_DATA_SLICE(bptr_->data, -1, - lfsr_bptr_size(bptr_) - lfs_min(d, lfsr_bptr_size(bptr_))); + lfs3_bptr_size(bptr_) - lfs3_min(d, lfs3_bptr_size(bptr_))); } if (bid_) { @@ -11423,41 +11425,41 @@ static int lfsr_file_lookup(lfs_t *lfs, const lfsr_file_t *file, return 0; } -// needed in lfsr_file_read_ -static int lfsr_file_crystallize(lfs_t *lfs, lfsr_file_t *file); +// needed in lfs3_file_read_ +static int lfs3_file_crystallize(lfs3_t *lfs3, lfs3_file_t *file); -static lfs_ssize_t lfsr_file_read_(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, uint8_t *buffer, lfs_size_t size) { +static lfs3_ssize_t lfs3_file_read_(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_off_t pos, uint8_t *buffer, lfs3_size_t size) { // need to fetch a new leaf? if (!(pos >= file->leaf.pos && pos < file->leaf.pos + file->leaf.weight)) { // leaf in use? we need to crystallize/graft it // - // it would be easier to just call lfsr_file_flush here, but + // it would be easier to just call lfs3_file_flush here, but // we don't want to drag in the extra stack usage - if (lfsr_o_isungraft(file->b.o.flags) - || lfsr_o_isuncryst(file->b.o.flags)) { - int err = lfsr_file_crystallize(lfs, file); + if (lfs3_o_isungraft(file->b.o.flags) + || lfs3_o_isuncryst(file->b.o.flags)) { + int err = lfs3_file_crystallize(lfs3, file); if (err) { return err; } } // fetch a leaf - lfsr_bid_t bid; - lfsr_bid_t weight; - lfsr_bptr_t bptr; - int err = lfsr_file_lookup_(lfs, file, pos, + lfs3_bid_t bid; + lfs3_bid_t weight; + lfs3_bptr_t bptr; + int err = lfs3_file_lookup_(lfs3, file, pos, &bid, &weight, &bptr); if (err) { return err; } - #ifdef LFS_CKFETCHES + #ifdef LFS3_CKFETCHES // checking fetches? - if (lfsr_m_isckfetches(lfs->flags) - && lfsr_bptr_isbptr(&bptr)) { - err = lfsr_bptr_ck(lfs, &bptr); + if (lfs3_m_isckfetches(lfs3->flags) + && lfs3_bptr_isbptr(&bptr)) { + err = lfs3_bptr_ck(lfs3, &bptr); if (err) { return err; } @@ -11470,18 +11472,18 @@ static lfs_ssize_t lfsr_file_read_(lfs_t *lfs, lfsr_file_t *file, } // any data on disk? - lfs_off_t pos_ = pos; - if (pos_ < file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr)) { + lfs3_off_t pos_ = pos; + if (pos_ < file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr)) { // note one important side-effect here is a strict // data hint - lfs_ssize_t d = lfs_min( + lfs3_ssize_t d = lfs3_min( size, - lfsr_bptr_size(&file->leaf.bptr) + lfs3_bptr_size(&file->leaf.bptr) - (pos_ - file->leaf.pos)); - lfsr_data_t slice = LFSR_DATA_SLICE(file->leaf.bptr.data, + lfs3_data_t slice = LFS3_DATA_SLICE(file->leaf.bptr.data, pos_ - file->leaf.pos, d); - d = lfsr_data_read(lfs, &slice, + d = lfs3_data_read(lfs3, &slice, buffer, d); if (d < 0) { return d; @@ -11493,10 +11495,10 @@ static lfs_ssize_t lfsr_file_read_(lfs_t *lfs, lfsr_file_t *file, } // found a hole? fill with zeros - lfs_ssize_t d = lfs_min( + lfs3_ssize_t d = lfs3_min( size, file->leaf.pos+file->leaf.weight - pos_); - lfs_memset(buffer, 0, d); + lfs3_memset(buffer, 0, d); pos_ += d; buffer += d; @@ -11507,27 +11509,27 @@ static lfs_ssize_t lfsr_file_read_(lfs_t *lfs, lfsr_file_t *file, // high-level file reading -lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, - void *buffer, lfs_size_t size) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +lfs3_ssize_t lfs3_file_read(lfs3_t *lfs3, lfs3_file_t *file, + void *buffer, lfs3_size_t size) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't read from writeonly files - LFS_ASSERT(!lfsr_o_iswronly(file->b.o.flags)); - LFS_ASSERT(file->pos + size <= 0x7fffffff); + LFS3_ASSERT(!lfs3_o_iswronly(file->b.o.flags)); + LFS3_ASSERT(file->pos + size <= 0x7fffffff); - lfs_off_t pos_ = file->pos; + lfs3_off_t pos_ = file->pos; uint8_t *buffer_ = buffer; - while (size > 0 && pos_ < lfsr_file_size_(file)) { + while (size > 0 && pos_ < lfs3_file_size_(file)) { // keep track of the next highest priority data offset - lfs_ssize_t d = lfs_min(size, lfsr_file_size_(file) - pos_); + lfs3_ssize_t d = lfs3_min(size, lfs3_file_size_(file) - pos_); // any data in our cache? if (pos_ < file->cache.pos + file->cache.size && file->cache.size != 0) { if (pos_ >= file->cache.pos) { - lfs_ssize_t d_ = lfs_min( + lfs3_ssize_t d_ = lfs3_min( d, file->cache.size - (pos_ - file->cache.pos)); - lfs_memcpy(buffer_, + lfs3_memcpy(buffer_, &file->cache.buffer[pos_ - file->cache.pos], d_); @@ -11539,17 +11541,17 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, } // cached data takes priority - d = lfs_min(d, file->cache.pos - pos_); + d = lfs3_min(d, file->cache.pos - pos_); } // any data in our btree? - if (pos_ < lfsr_file_weight(file)) { + if (pos_ < lfs3_file_weight(file)) { // bypass cache? - if ((lfs_size_t)d >= lfsr_file_cachesize(lfs, file)) { - lfs_ssize_t d_ = lfsr_file_read_(lfs, file, + if ((lfs3_size_t)d >= lfs3_file_cachesize(lfs3, file)) { + lfs3_ssize_t d_ = lfs3_file_read_(lfs3, file, pos_, buffer_, d); if (d_ < 0) { - LFS_ASSERT(d_ != LFS_ERR_NOENT); + LFS3_ASSERT(d_ != LFS3_ERR_NOENT); return d_; } @@ -11564,19 +11566,19 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, // note that flush does not change the actual file data, so if // a read fails it's ok to fall back to our flushed state // - if (lfsr_o_isunflush(file->b.o.flags)) { - int err = lfsr_file_flush(lfs, file); + if (lfs3_o_isunflush(file->b.o.flags)) { + int err = lfs3_file_flush(lfs3, file); if (err) { return err; } - lfsr_file_discardcache(file); + lfs3_file_discardcache(file); } // try to fill our cache with some data - lfs_ssize_t d_ = lfsr_file_read_(lfs, file, + lfs3_ssize_t d_ = lfs3_file_read_(lfs3, file, pos_, file->cache.buffer, d); if (d_ < 0) { - LFS_ASSERT(d != LFS_ERR_NOENT); + LFS3_ASSERT(d != LFS3_ERR_NOENT); return d_; } file->cache.pos = pos_; @@ -11585,7 +11587,7 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, } // found a hole? fill with zeros - lfs_memset(buffer_, 0, d); + lfs3_memset(buffer_, 0, d); pos_ += d; buffer_ += d; @@ -11593,79 +11595,79 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, } // update file and return amount read - lfs_size_t read = pos_ - file->pos; + lfs3_size_t read = pos_ - file->pos; file->pos = pos_; return read; } // low-level file writing -static int lfsr_file_commit(lfs_t *lfs, lfsr_file_t *file, - lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { - return lfsr_bshrub_commit(lfs, &file->b, +static int lfs3_file_commit(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + return lfs3_bshrub_commit(lfs3, &file->b, bid, rattrs, rattr_count); } // graft bptr/fragments into our bshrub/btree -static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, lfs_off_t weight, lfs_soff_t delta, +static int lfs3_file_graft(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_off_t pos, lfs3_off_t weight, lfs3_soff_t delta, // data_count=-1 => single bptr // data_count>=0 => list of concatenated fragments - const lfsr_data_t *datas, lfs_ssize_t data_count) { + const lfs3_data_t *datas, lfs3_ssize_t data_count) { // note! we must never allow our btree size to overflow, even // temporarily // can't carve more than the graft weight - LFS_ASSERT(delta >= -(lfs_soff_t)weight); + LFS3_ASSERT(delta >= -(lfs3_soff_t)weight); // carving the entire tree? revert to no bshrub/btree if (pos == 0 && weight >= file->b.shrub.weight - && delta == -(lfs_soff_t)weight) { - lfsr_file_discardbshrub(file); + && delta == -(lfs3_soff_t)weight) { + lfs3_file_discardbshrub(file); return 0; } // try to merge commits where possible - lfsr_bid_t bid = file->b.shrub.weight; - lfsr_rattr_t rattrs[3]; - lfs_size_t rattr_count = 0; - lfsr_bptr_t l; - lfsr_bptr_t r; + lfs3_bid_t bid = file->b.shrub.weight; + lfs3_rattr_t rattrs[3]; + lfs3_size_t rattr_count = 0; + lfs3_bptr_t l; + lfs3_bptr_t r; // need a hole? if (pos > file->b.shrub.weight) { // can we coalesce? if (file->b.shrub.weight > 0) { - bid = lfs_min(bid, file->b.shrub.weight-1); - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_GROW, +(pos - file->b.shrub.weight)); + bid = lfs3_min(bid, file->b.shrub.weight-1); + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_GROW, +(pos - file->b.shrub.weight)); // new hole } else { - bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_DATA, +(pos - file->b.shrub.weight)); + bid = lfs3_min(bid, file->b.shrub.weight); + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_DATA, +(pos - file->b.shrub.weight)); } } // try to carve any existing data - lfsr_rattr_t r_rattr_ = {.tag=0}; + lfs3_rattr_t r_rattr_ = {.tag=0}; while (pos < file->b.shrub.weight) { - lfsr_bid_t weight_; - lfsr_bptr_t bptr_; - int err = lfsr_file_lookup_(lfs, file, pos, + lfs3_bid_t weight_; + lfs3_bptr_t bptr_; + int err = lfs3_file_lookup_(lfs3, file, pos, &bid, &weight_, &bptr_); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - #ifdef LFS_CKFETCHES + #ifdef LFS3_CKFETCHES // checking fetches? - if (lfsr_m_isckfetches(lfs->flags) - && lfsr_bptr_isbptr(&bptr_)) { - err = lfsr_bptr_ck(lfs, &bptr_); + if (lfs3_m_isckfetches(lfs3->flags) + && lfs3_bptr_isbptr(&bptr_)) { + err = lfs3_bptr_ck(lfs3, &bptr_); if (err) { return err; } @@ -11674,73 +11676,73 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file, // note, an entry can be both a left and right sibling l = bptr_; - l.data = LFSR_DATA_SLICE(bptr_.data, + l.data = LFS3_DATA_SLICE(bptr_.data, -1, pos - (bid-(weight_-1))); r = bptr_; - r.data = LFSR_DATA_SLICE(bptr_.data, + r.data = LFS3_DATA_SLICE(bptr_.data, pos+weight - (bid-(weight_-1)), -1); // left sibling needs carving but falls underneath our // fragment threshold? break into fragments - while (lfsr_bptr_isbptr(&bptr_) - && lfsr_bptr_size(&l) > lfs->cfg->fragment_size - && lfsr_bptr_size(&l) < lfs_min( - lfs->cfg->fragment_thresh, - lfs->cfg->crystal_thresh)) { - bptr_.data = LFSR_DATA_SLICE(bptr_.data, - lfs->cfg->fragment_size, + while (lfs3_bptr_isbptr(&bptr_) + && lfs3_bptr_size(&l) > lfs3->cfg->fragment_size + && lfs3_bptr_size(&l) < lfs3_min( + lfs3->cfg->fragment_thresh, + lfs3->cfg->crystal_thresh)) { + bptr_.data = LFS3_DATA_SLICE(bptr_.data, + lfs3->cfg->fragment_size, -1); - err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS( - LFSR_RATTR_DATA( - LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_DATA, - -(weight_ - lfs->cfg->fragment_size), - &LFSR_DATA_TRUNCATE(l.data, - lfs->cfg->fragment_size)), - LFSR_RATTR_BPTR( - LFSR_TAG_BLOCK, - +(weight_ - lfs->cfg->fragment_size), + err = lfs3_file_commit(lfs3, file, bid, LFS3_RATTRS( + LFS3_RATTR_DATA( + LFS3_TAG_GROW | LFS3_TAG_MASK8 | LFS3_TAG_DATA, + -(weight_ - lfs3->cfg->fragment_size), + &LFS3_DATA_TRUNCATE(l.data, + lfs3->cfg->fragment_size)), + LFS3_RATTR_BPTR( + LFS3_TAG_BLOCK, + +(weight_ - lfs3->cfg->fragment_size), &bptr_))); if (err) { return err; } - weight_ -= lfs->cfg->fragment_size; - l.data = LFSR_DATA_SLICE(bptr_.data, + weight_ -= lfs3->cfg->fragment_size; + l.data = LFS3_DATA_SLICE(bptr_.data, -1, pos - (bid-(weight_-1))); } // right sibling needs carving but falls underneath our // fragment threshold? break into fragments - while (lfsr_bptr_isbptr(&bptr_) - && lfsr_bptr_size(&r) > lfs->cfg->fragment_size - && lfsr_bptr_size(&r) < lfs_min( - lfs->cfg->fragment_thresh, - lfs->cfg->crystal_thresh)) { - bptr_.data = LFSR_DATA_SLICE(bptr_.data, + while (lfs3_bptr_isbptr(&bptr_) + && lfs3_bptr_size(&r) > lfs3->cfg->fragment_size + && lfs3_bptr_size(&r) < lfs3_min( + lfs3->cfg->fragment_thresh, + lfs3->cfg->crystal_thresh)) { + bptr_.data = LFS3_DATA_SLICE(bptr_.data, -1, - lfsr_bptr_size(&bptr_) - lfs->cfg->fragment_size); + lfs3_bptr_size(&bptr_) - lfs3->cfg->fragment_size); - err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS( - LFSR_RATTR_BPTR( - LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_BLOCK, - -(weight_ - lfsr_bptr_size(&bptr_)), + err = lfs3_file_commit(lfs3, file, bid, LFS3_RATTRS( + LFS3_RATTR_BPTR( + LFS3_TAG_GROW | LFS3_TAG_MASK8 | LFS3_TAG_BLOCK, + -(weight_ - lfs3_bptr_size(&bptr_)), &bptr_), - LFSR_RATTR_DATA( - LFSR_TAG_DATA, - +(weight_ - lfsr_bptr_size(&bptr_)), - &LFSR_DATA_FRUNCATE(r.data, - lfs->cfg->fragment_size)))); + LFS3_RATTR_DATA( + LFS3_TAG_DATA, + +(weight_ - lfs3_bptr_size(&bptr_)), + &LFS3_DATA_FRUNCATE(r.data, + lfs3->cfg->fragment_size)))); if (err) { return err; } - bid -= (weight_-lfsr_bptr_size(&bptr_)); - weight_ -= (weight_-lfsr_bptr_size(&bptr_)); - r.data = LFSR_DATA_SLICE(bptr_.data, + bid -= (weight_-lfs3_bptr_size(&bptr_)); + weight_ -= (weight_-lfs3_bptr_size(&bptr_)); + r.data = LFS3_DATA_SLICE(bptr_.data, pos+weight - (bid-(weight_-1)), -1); } @@ -11748,47 +11750,47 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file, // found left sibling? if (bid-(weight_-1) < pos) { // can we get away with a grow attribute? - if (lfsr_bptr_size(&bptr_) == lfsr_bptr_size(&l)) { - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_GROW, -(bid+1 - pos)); + if (lfs3_bptr_size(&bptr_) == lfs3_bptr_size(&l)) { + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_GROW, -(bid+1 - pos)); // carve fragment? - } else if (!lfsr_bptr_isbptr(&bptr_) - || lfsr_bptr_size(&l) <= lfs->cfg->fragment_size) { - rattrs[rattr_count++] = LFSR_RATTR_DATA( - LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_DATA, + } else if (!lfs3_bptr_isbptr(&bptr_) + || lfs3_bptr_size(&l) <= lfs3->cfg->fragment_size) { + rattrs[rattr_count++] = LFS3_RATTR_DATA( + LFS3_TAG_GROW | LFS3_TAG_MASK8 | LFS3_TAG_DATA, -(bid+1 - pos), &l.data); // carve bptr? } else { - rattrs[rattr_count++] = LFSR_RATTR_BPTR( - LFSR_TAG_GROW | LFSR_TAG_MASK8 | LFSR_TAG_BLOCK, + rattrs[rattr_count++] = LFS3_RATTR_BPTR( + LFS3_TAG_GROW | LFS3_TAG_MASK8 | LFS3_TAG_BLOCK, -(bid+1 - pos), &l); } // completely overwriting this entry? } else { - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_RM, -weight_); + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_RM, -weight_); } // spans more than one entry? we can't do everything in one // commit because it might span more than one btree leaf, so // commit what we have and move on to next entry if (pos+weight > bid+1) { - LFS_ASSERT(lfsr_bptr_size(&r) == 0); - LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); + LFS3_ASSERT(lfs3_bptr_size(&r) == 0); + LFS3_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); - err = lfsr_file_commit(lfs, file, bid, + err = lfs3_file_commit(lfs3, file, bid, rattrs, rattr_count); if (err) { return err; } - delta += lfs_min(weight, bid+1 - pos); - weight -= lfs_min(weight, bid+1 - pos); + delta += lfs3_min(weight, bid+1 - pos); + weight -= lfs3_min(weight, bid+1 - pos); rattr_count = 0; continue; } @@ -11796,63 +11798,63 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file, // found right sibling? if (pos+weight < bid+1) { // can we coalesce a hole? - if (lfsr_bptr_size(&r) == 0) { + if (lfs3_bptr_size(&r) == 0) { delta += bid+1 - (pos+weight); // carve fragment? - } else if (!lfsr_bptr_isbptr(&bptr_) - || lfsr_bptr_size(&r) <= lfs->cfg->fragment_size) { - r_rattr_ = LFSR_RATTR_DATA( - LFSR_TAG_DATA, bid+1 - (pos+weight), + } else if (!lfs3_bptr_isbptr(&bptr_) + || lfs3_bptr_size(&r) <= lfs3->cfg->fragment_size) { + r_rattr_ = LFS3_RATTR_DATA( + LFS3_TAG_DATA, bid+1 - (pos+weight), &r.data); // carve bptr? } else { - r_rattr_ = LFSR_RATTR_BPTR( - LFSR_TAG_BLOCK, bid+1 - (pos+weight), + r_rattr_ = LFS3_RATTR_BPTR( + LFS3_TAG_BLOCK, bid+1 - (pos+weight), &r); } } - delta += lfs_min(weight, bid+1 - pos); - weight -= lfs_min(weight, bid+1 - pos); + delta += lfs3_min(weight, bid+1 - pos); + weight -= lfs3_min(weight, bid+1 - pos); break; } // append our data if (weight + delta > 0) { - lfs_size_t dsize = 0; - for (lfs_size_t i = 0; - i < ((data_count < 0) ? 1 : (lfs_size_t)data_count); + lfs3_size_t dsize = 0; + for (lfs3_size_t i = 0; + i < ((data_count < 0) ? 1 : (lfs3_size_t)data_count); i++) { - dsize += lfsr_data_size(datas[i]); + dsize += lfs3_data_size(datas[i]); } // can we coalesce a hole? if (dsize == 0 && pos > 0) { - bid = lfs_min(bid, file->b.shrub.weight-1); - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_GROW, +(weight + delta)); + bid = lfs3_min(bid, file->b.shrub.weight-1); + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_GROW, +(weight + delta)); // need a new hole? } else if (dsize == 0) { - bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_DATA, +(weight + delta)); + bid = lfs3_min(bid, file->b.shrub.weight); + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_DATA, +(weight + delta)); // append a new fragment? } else if (data_count >= 0) { - bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR_CAT_( - LFSR_TAG_DATA, +(weight + delta), + bid = lfs3_min(bid, file->b.shrub.weight); + rattrs[rattr_count++] = LFS3_RATTR_CAT_( + LFS3_TAG_DATA, +(weight + delta), datas, data_count); // append a new bptr? } else { - bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR_BPTR( - LFSR_TAG_BLOCK, +(weight + delta), - (const lfsr_bptr_t*)datas); + bid = lfs3_min(bid, file->b.shrub.weight); + rattrs[rattr_count++] = LFS3_RATTR_BPTR( + LFS3_TAG_BLOCK, +(weight + delta), + (const lfs3_bptr_t*)datas); } } @@ -11863,9 +11865,9 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file, // commit pending rattrs if (rattr_count > 0) { - LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); + LFS3_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); - int err = lfsr_file_commit(lfs, file, bid, + int err = lfs3_file_commit(lfs3, file, bid, rattrs, rattr_count); if (err) { return err; @@ -11875,76 +11877,76 @@ static int lfsr_file_graft(lfs_t *lfs, lfsr_file_t *file, return 0; } -static int lfsr_file_crystallize_(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t block_pos, lfs_soff_t crystal_min, lfs_soff_t crystal_max, - lfs_off_t pos, const uint8_t *buffer, lfs_size_t size) { +static int lfs3_file_crystallize_(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_off_t block_pos, lfs3_soff_t crystal_min, lfs3_soff_t crystal_max, + lfs3_off_t pos, const uint8_t *buffer, lfs3_size_t size) { // align to prog_size, limit to block_size and theoretical file size - lfs_off_t crystal_limit = lfs_min( - block_pos + lfs_min( - lfs_aligndown( - (lfs_off_t)crystal_max, - lfs->cfg->prog_size), - lfs->cfg->block_size), - lfs_max( + lfs3_off_t crystal_limit = lfs3_min( + block_pos + lfs3_min( + lfs3_aligndown( + (lfs3_off_t)crystal_max, + lfs3->cfg->prog_size), + lfs3->cfg->block_size), + lfs3_max( pos + size, - lfsr_file_weight(file))); + lfs3_file_weight(file))); // do we need to allocate a new block? - if (!lfsr_bptr_isbptr(&file->leaf.bptr) - || !lfsr_bptr_iserased(&file->leaf.bptr)) { + if (!lfs3_bptr_isbptr(&file->leaf.bptr) + || !lfs3_bptr_iserased(&file->leaf.bptr)) { goto relocate; } // if we're resuming crystallization, block pointer shouldn't be // truncated or anything - LFS_ASSERT(file->leaf.pos - lfsr_bptr_off(&file->leaf.bptr) + LFS3_ASSERT(file->leaf.pos - lfs3_bptr_off(&file->leaf.bptr) == block_pos); - LFS_ASSERT(lfsr_bptr_off(&file->leaf.bptr) - + lfsr_bptr_size(&file->leaf.bptr) - == lfsr_bptr_cksize(&file->leaf.bptr)); - LFS_ASSERT(lfsr_bptr_size(&file->leaf.bptr) + LFS3_ASSERT(lfs3_bptr_off(&file->leaf.bptr) + + lfs3_bptr_size(&file->leaf.bptr) + == lfs3_bptr_cksize(&file->leaf.bptr)); + LFS3_ASSERT(lfs3_bptr_size(&file->leaf.bptr) == file->leaf.weight); // before we write, claim the erased state! - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_type(o->flags) == LFS_TYPE_REG + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_type(o->flags) == LFS3_TYPE_REG && o != &file->b.o - && lfsr_bptr_block(&((lfsr_file_t*)o)->leaf.bptr) - == lfsr_bptr_block(&file->leaf.bptr)) { - lfsr_bptr_claim(&((lfsr_file_t*)o)->leaf.bptr); + && lfs3_bptr_block(&((lfs3_file_t*)o)->leaf.bptr) + == lfs3_bptr_block(&file->leaf.bptr)) { + lfs3_bptr_claim(&((lfs3_file_t*)o)->leaf.bptr); } } // create a temporary copy in case an error happens - lfsr_bptr_t bptr = file->leaf.bptr; + lfs3_bptr_t bptr = file->leaf.bptr; while (true) { // crystallize data into our block // // i.e. eagerly merge any right neighbors unless that would put // us over our crystal_size/block_size - lfs_off_t pos_ = block_pos - + lfsr_bptr_off(&bptr) - + lfsr_bptr_size(&bptr); - uint32_t cksum_ = lfsr_bptr_cksum(&bptr); + lfs3_off_t pos_ = block_pos + + lfs3_bptr_off(&bptr) + + lfs3_bptr_size(&bptr); + uint32_t cksum_ = lfs3_bptr_cksum(&bptr); while (pos_ < crystal_limit) { // keep track of the next highest priority data offset - lfs_ssize_t d = crystal_limit - pos_; + lfs3_ssize_t d = crystal_limit - pos_; // any data in our buffer? if (pos_ < pos + size && size > 0) { if (pos_ >= pos) { - lfs_ssize_t d_ = lfs_min( + lfs3_ssize_t d_ = lfs3_min( d, size - (pos_ - pos)); - int err = lfsr_bd_prog(lfs, lfsr_bptr_block(&bptr), + int err = lfs3_bd_prog(lfs3, lfs3_bptr_block(&bptr), pos_ - block_pos, &buffer[pos_ - pos], d_, &cksum_, true); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -11955,26 +11957,26 @@ static int lfsr_file_crystallize_(lfs_t *lfs, lfsr_file_t *file, } // buffered data takes priority - d = lfs_min(d, pos - pos_); + d = lfs3_min(d, pos - pos_); } // any data on disk? - if (pos_ < lfsr_file_weight(file)) { - lfsr_bid_t bid__; - lfsr_bid_t weight__; - lfsr_bptr_t bptr__; - int err = lfsr_file_lookup(lfs, file, pos_, + if (pos_ < lfs3_file_weight(file)) { + lfs3_bid_t bid__; + lfs3_bid_t weight__; + lfs3_bptr_t bptr__; + int err = lfs3_file_lookup(lfs3, file, pos_, &bid__, &weight__, &bptr__); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - #ifdef LFS_CKFETCHES + #ifdef LFS3_CKFETCHES // checking fetches? - if (lfsr_m_isckfetches(lfs->flags) - && lfsr_bptr_isbptr(&bptr__)) { - err = lfsr_bptr_ck(lfs, &bptr__); + if (lfs3_m_isckfetches(lfs3->flags) + && lfs3_bptr_isbptr(&bptr__)) { + err = lfs3_bptr_ck(lfs3, &bptr__); if (err) { return err; } @@ -11984,37 +11986,37 @@ static int lfsr_file_crystallize_(lfs_t *lfs, lfsr_file_t *file, // is this data a pure hole? stop early to (FUTURE) // better leverage erased-state in sparse files, and to // try to avoid writing a bunch of unnecessary zeros - if ((pos_ >= bid__-(weight__-1) + lfsr_bptr_size(&bptr__) + if ((pos_ >= bid__-(weight__-1) + lfs3_bptr_size(&bptr__) // does this data exceed our block_size? also // stop early to try to avoid messing up // block alignment - || (bid__-(weight__-1) + lfsr_bptr_size(&bptr__)) + || (bid__-(weight__-1) + lfs3_bptr_size(&bptr__)) - block_pos - > lfs->cfg->block_size) + > lfs3->cfg->block_size) // but make sure to include all of the requested // crystal if explicit, otherwise above loops // may never terminate - && (lfs_soff_t)(pos_ - block_pos) >= crystal_min) { + && (lfs3_soff_t)(pos_ - block_pos) >= crystal_min) { break; } - if (pos_ < bid__-(weight__-1) + lfsr_bptr_size(&bptr__)) { + if (pos_ < bid__-(weight__-1) + lfs3_bptr_size(&bptr__)) { // note one important side-effect here is a strict // data hint - lfs_ssize_t d_ = lfs_min( + lfs3_ssize_t d_ = lfs3_min( d, - (bid__-(weight__-1) + lfsr_bptr_size(&bptr__)) + (bid__-(weight__-1) + lfs3_bptr_size(&bptr__)) - pos_); - err = lfsr_bd_progdata(lfs, lfsr_bptr_block(&bptr), + err = lfs3_bd_progdata(lfs3, lfs3_bptr_block(&bptr), pos_ - block_pos, - LFSR_DATA_SLICE(bptr__.data, + LFS3_DATA_SLICE(bptr__.data, pos_ - (bid__-(weight__-1)), d_), &cksum_, true); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -12025,18 +12027,18 @@ static int lfsr_file_crystallize_(lfs_t *lfs, lfsr_file_t *file, } // found a hole? just make sure next leaf takes priority - d = lfs_min(d, bid__+1 - pos_); + d = lfs3_min(d, bid__+1 - pos_); } // found a hole? fill with zeros - int err = lfsr_bd_set(lfs, lfsr_bptr_block(&bptr), + int err = lfs3_bd_set(lfs3, lfs3_bptr_block(&bptr), pos_ - block_pos, 0, d, &cksum_, true); if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); + LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; @@ -12051,37 +12053,37 @@ static int lfsr_file_crystallize_(lfs_t *lfs, lfsr_file_t *file, // doing this retroactively to the pcache greatly simplifies the // above loop, though we may end up reading more than is // strictly necessary - lfs_ssize_t d = (pos_ - block_pos) % lfs->cfg->prog_size; - lfs->pcache.size -= d; + lfs3_ssize_t d = (pos_ - block_pos) % lfs3->cfg->prog_size; + lfs3->pcache.size -= d; pos_ -= d; // finalize our write - int err = lfsr_bd_flush(lfs, + int err = lfs3_bd_flush(lfs3, &cksum_, true); if (err) { // bad prog? try another block - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { goto relocate; } return err; } // update our block pointer - LFS_ASSERT(pos_ - block_pos >= lfsr_bptr_off(&bptr)); - LFS_ASSERT(pos_ - block_pos <= lfs->cfg->block_size); - file->leaf.pos = block_pos + lfsr_bptr_off(&bptr); - file->leaf.weight = pos_ - (block_pos + lfsr_bptr_off(&bptr)); - lfsr_bptr_init(&file->leaf.bptr, - LFSR_DATA_DISK( - lfsr_bptr_block(&bptr), - lfsr_bptr_off(&bptr), - pos_ - (block_pos + lfsr_bptr_off(&bptr))), + LFS3_ASSERT(pos_ - block_pos >= lfs3_bptr_off(&bptr)); + LFS3_ASSERT(pos_ - block_pos <= lfs3->cfg->block_size); + file->leaf.pos = block_pos + lfs3_bptr_off(&bptr); + file->leaf.weight = pos_ - (block_pos + lfs3_bptr_off(&bptr)); + lfs3_bptr_init(&file->leaf.bptr, + LFS3_DATA_DISK( + lfs3_bptr_block(&bptr), + lfs3_bptr_off(&bptr), + pos_ - (block_pos + lfs3_bptr_off(&bptr))), // mark as erased - (pos_ - block_pos) | LFSR_BPTR_ISERASED, + (pos_ - block_pos) | LFS3_BPTR_ISERASED, cksum_); // mark as uncrystallized and ungrafted - file->b.o.flags |= LFS_o_UNCRYST | LFS_o_UNGRAFT; + file->b.o.flags |= LFS3_o_UNCRYST | LFS3_o_UNGRAFT; return 0; relocate:; @@ -12089,47 +12091,47 @@ static int lfsr_file_crystallize_(lfs_t *lfs, lfsr_file_t *file, // // note if we relocate, we rewrite the entire block from // block_pos using what we can find in our tree - lfs_sblock_t block = lfs_alloc(lfs, true); + lfs3_sblock_t block = lfs3_alloc(lfs3, true); if (block < 0) { return block; } - lfsr_bptr_init(&bptr, - LFSR_DATA_DISK(block, 0, 0), + lfs3_bptr_init(&bptr, + LFS3_DATA_DISK(block, 0, 0), // mark as erased - LFSR_BPTR_ISERASED | 0, + LFS3_BPTR_ISERASED | 0, 0); } } -static int lfsr_file_crystallize(lfs_t *lfs, lfsr_file_t *file) { +static int lfs3_file_crystallize(lfs3_t *lfs3, lfs3_file_t *file) { bool flushable = ( file->cache.pos - >= file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr)); + >= file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr)); // finish crystallizing - if (lfsr_o_isuncryst(file->b.o.flags)) { + if (lfs3_o_isuncryst(file->b.o.flags)) { // uncrystallized files must be unsynced - LFS_ASSERT(lfsr_o_isunsync(file->b.o.flags)); + LFS3_ASSERT(lfs3_o_isunsync(file->b.o.flags)); // only blocks can be uncrystallized - LFS_ASSERT(lfsr_bptr_isbptr(&file->leaf.bptr)); - LFS_ASSERT(lfsr_bptr_iserased(&file->leaf.bptr)); + LFS3_ASSERT(lfs3_bptr_isbptr(&file->leaf.bptr)); + LFS3_ASSERT(lfs3_bptr_iserased(&file->leaf.bptr)); // finish crystallizing the block - int err = lfsr_file_crystallize_(lfs, file, - file->leaf.pos - lfsr_bptr_off(&file->leaf.bptr), -1, -1, + int err = lfs3_file_crystallize_(lfs3, file, + file->leaf.pos - lfs3_bptr_off(&file->leaf.bptr), -1, -1, file->cache.pos, file->cache.buffer, file->cache.size); if (err) { return err; } // mark as crystallized - file->b.o.flags &= ~LFS_o_UNCRYST; + file->b.o.flags &= ~LFS3_o_UNCRYST; } // and graft into tree - if (lfsr_o_isungraft(file->b.o.flags)) { - int err = lfsr_file_graft(lfs, file, + if (lfs3_o_isungraft(file->b.o.flags)) { + int err = lfs3_file_graft(lfs3, file, file->leaf.pos, file->leaf.weight, 0, &file->leaf.bptr.data, -1); if (err) { @@ -12137,27 +12139,27 @@ static int lfsr_file_crystallize(lfs_t *lfs, lfsr_file_t *file) { } // mark as grafted - file->b.o.flags &= ~LFS_o_UNGRAFT; + file->b.o.flags &= ~LFS3_o_UNGRAFT; } // eagerly mark as flushed if this included all of our cache if (flushable - && file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr) + && file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr) >= file->cache.pos + file->cache.size) { - file->b.o.flags &= ~LFS_o_UNFLUSH; + file->b.o.flags &= ~LFS3_o_UNFLUSH; } return 0; } -static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, const uint8_t *buffer, lfs_size_t size) { +static int lfs3_file_flush_(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_off_t pos, const uint8_t *buffer, lfs3_size_t size) { // we can skip some btree lookups if we know we are aligned from a // previous iteration, we already do way too many btree lookups bool aligned = false; // if crystallization is disabled, just skip to writing fragments - if (lfs->cfg->crystal_thresh > lfs->cfg->block_size) { + if (lfs3->cfg->crystal_thresh > lfs3->cfg->block_size) { goto fragment; } @@ -12168,18 +12170,18 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // note that the threshold to resume crystallization (prog_size), // is often much lower than the threshold to start crystallization // (crystal_thresh) - lfs_off_t block_start = file->leaf.pos - - lfsr_bptr_off(&file->leaf.bptr); - lfs_off_t block_end = file->leaf.pos - + lfsr_bptr_size(&file->leaf.bptr); - if (lfsr_bptr_isbptr(&file->leaf.bptr) - && lfsr_bptr_iserased(&file->leaf.bptr) + lfs3_off_t block_start = file->leaf.pos + - lfs3_bptr_off(&file->leaf.bptr); + lfs3_off_t block_end = file->leaf.pos + + lfs3_bptr_size(&file->leaf.bptr); + if (lfs3_bptr_isbptr(&file->leaf.bptr) + && lfs3_bptr_iserased(&file->leaf.bptr) && pos >= block_end - && pos < block_start + lfs->cfg->block_size - && pos - block_end < lfs->cfg->crystal_thresh + && pos < block_start + lfs3->cfg->block_size + && pos - block_end < lfs3->cfg->crystal_thresh // need to bail if we can't meet prog alignment - && (pos + size) - block_end >= lfs->cfg->prog_size) { - int err = lfsr_file_crystallize_(lfs, file, + && (pos + size) - block_end >= lfs3->cfg->prog_size) { + int err = lfs3_file_crystallize_(lfs3, file, block_start, (pos + size) - block_start, (pos + size) - block_start, @@ -12189,12 +12191,12 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, } // update buffer state - lfs_soff_t d = lfs_max( - file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr), + lfs3_soff_t d = lfs3_max( + file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr), pos) - pos; pos += d; - buffer += lfs_min(d, size); - size -= lfs_min(d, size); + buffer += lfs3_min(d, size); + size -= lfs3_min(d, size); // we should be aligned now aligned = true; @@ -12213,73 +12215,73 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // crystallization anyways // default to arbitrary alignment - lfs_off_t crystal_start = pos; - lfs_off_t crystal_end = pos + size; + lfs3_off_t crystal_start = pos; + lfs3_off_t crystal_end = pos + size; // if we haven't already exceeded our crystallization threshold, // find left crystal neighbor - lfs_off_t poke = lfs_smax( - crystal_start - (lfs->cfg->crystal_thresh-1), + lfs3_off_t poke = lfs3_smax( + crystal_start - (lfs3->cfg->crystal_thresh-1), 0); - if (crystal_end - crystal_start < lfs->cfg->crystal_thresh + if (crystal_end - crystal_start < lfs3->cfg->crystal_thresh && crystal_start > 0 - && poke < lfsr_file_weight(file) + && poke < lfs3_file_weight(file) // don't bother looking up left after the first block && !aligned) { - lfsr_bid_t bid; - lfsr_bid_t weight; - lfsr_bptr_t bptr; - int err = lfsr_file_lookup(lfs, file, poke, + lfs3_bid_t bid; + lfs3_bid_t weight; + lfs3_bptr_t bptr; + int err = lfs3_file_lookup(lfs3, file, poke, &bid, &weight, &bptr); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // if left crystal neighbor is a fragment and there is no // obvious hole between our own crystal and our neighbor, // include as a part of our crystal - if (!lfsr_bptr_isbptr(&bptr) - && lfsr_bptr_size(&bptr) > 0 + if (!lfs3_bptr_isbptr(&bptr) + && lfs3_bptr_size(&bptr) > 0 // hole? holes can be quite large and shouldn't // trigger crystallization - && bid-(weight-1) + lfsr_bptr_size(&bptr) >= poke) { + && bid-(weight-1) + lfs3_bptr_size(&bptr) >= poke) { crystal_start = bid-(weight-1); // otherwise our neighbor determines our crystal boundary } else { - crystal_start = lfs_min(bid+1, crystal_start); + crystal_start = lfs3_min(bid+1, crystal_start); } } // if we haven't already exceeded our crystallization threshold, // find right crystal neighbor - poke = lfs_min( - crystal_start + (lfs->cfg->crystal_thresh-1), - lfsr_file_weight(file)-1); - if (crystal_end - crystal_start < lfs->cfg->crystal_thresh - && crystal_end < lfsr_file_weight(file)) { - lfsr_bid_t bid; - lfsr_bid_t weight; - lfsr_bptr_t bptr; - int err = lfsr_file_lookup(lfs, file, poke, + poke = lfs3_min( + crystal_start + (lfs3->cfg->crystal_thresh-1), + lfs3_file_weight(file)-1); + if (crystal_end - crystal_start < lfs3->cfg->crystal_thresh + && crystal_end < lfs3_file_weight(file)) { + lfs3_bid_t bid; + lfs3_bid_t weight; + lfs3_bptr_t bptr; + int err = lfs3_file_lookup(lfs3, file, poke, &bid, &weight, &bptr); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // if right crystal neighbor is a fragment, include as a part // of our crystal - if (!lfsr_bptr_isbptr(&bptr) - && lfsr_bptr_size(&bptr) > 0) { - crystal_end = lfs_max( - bid-(weight-1) + lfsr_bptr_size(&bptr), + if (!lfs3_bptr_isbptr(&bptr) + && lfs3_bptr_size(&bptr) > 0) { + crystal_end = lfs3_max( + bid-(weight-1) + lfs3_bptr_size(&bptr), crystal_end); // otherwise treat as crystal boundary } else { - crystal_end = lfs_max( + crystal_end = lfs3_max( bid-(weight-1), crystal_end); } @@ -12289,9 +12291,9 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // write to the file // below our crystallization threshold? fallback to writing fragments - if (crystal_end - crystal_start < lfs->cfg->crystal_thresh + if (crystal_end - crystal_start < lfs3->cfg->crystal_thresh // enough for prog alignment? - || crystal_end - crystal_start < lfs->cfg->prog_size) { + || crystal_end - crystal_start < lfs3->cfg->prog_size) { goto fragment; } @@ -12300,14 +12302,14 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // can we resume crystallizing with the fragments on disk? block_start = file->leaf.pos - - lfsr_bptr_off(&file->leaf.bptr); + - lfs3_bptr_off(&file->leaf.bptr); block_end = file->leaf.pos - + lfsr_bptr_size(&file->leaf.bptr); - if (lfsr_bptr_isbptr(&file->leaf.bptr) - && lfsr_bptr_iserased(&file->leaf.bptr) + + lfs3_bptr_size(&file->leaf.bptr); + if (lfs3_bptr_isbptr(&file->leaf.bptr) + && lfs3_bptr_iserased(&file->leaf.bptr) && crystal_start >= block_end - && crystal_start < block_start + lfs->cfg->block_size) { - int err = lfsr_file_crystallize_(lfs, file, + && crystal_start < block_start + lfs3->cfg->block_size) { + int err = lfs3_file_crystallize_(lfs3, file, block_start, crystal_end - block_start, crystal_end - block_start, @@ -12317,12 +12319,12 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, } // update buffer state, this may or may not make progress - lfs_soff_t d = lfs_max( - file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr), + lfs3_soff_t d = lfs3_max( + file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr), pos) - pos; pos += d; - buffer += lfs_min(d, size); - size -= lfs_min(d, size); + buffer += lfs3_min(d, size); + size -= lfs3_min(d, size); // we should be aligned now aligned = true; @@ -12331,14 +12333,14 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // if we're mid-crystallization, finish crystallizing the block // and graft it into our bshrub/btree - int err = lfsr_file_crystallize(lfs, file); + int err = lfs3_file_crystallize(lfs3, file); if (err) { return err; } - // mark as unerased so lfsr_file_crystallize doesn't try to + // mark as unerased so lfs3_file_crystallize doesn't try to // resume crystallizing this block - lfsr_bptr_claim(&file->leaf.bptr); + lfs3_bptr_claim(&file->leaf.bptr); // before we can crystallize we need to figure out the best // block alignment, we use the entry immediately to the left of @@ -12347,38 +12349,38 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, && file->b.shrub.weight > 0 // don't bother to lookup left after the first block && !aligned) { - lfsr_bid_t bid; - lfsr_bid_t weight; - lfsr_bptr_t bptr; - int err = lfsr_file_lookup(lfs, file, - lfs_min( + lfs3_bid_t bid; + lfs3_bid_t weight; + lfs3_bptr_t bptr; + int err = lfs3_file_lookup(lfs3, file, + lfs3_min( crystal_start-1, file->b.shrub.weight-1), &bid, &weight, &bptr); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // is our left neighbor in the same block? if (crystal_start - (bid-(weight-1)) - < lfs->cfg->block_size - && lfsr_bptr_size(&bptr) > 0) { + < lfs3->cfg->block_size + && lfs3_bptr_size(&bptr) > 0) { crystal_start = bid-(weight-1); // no? is our left neighbor at least our left block neighbor? // align to block alignment } else if (crystal_start - (bid-(weight-1)) - < 2*lfs->cfg->block_size - && lfsr_bptr_size(&bptr) > 0) { - crystal_start = bid-(weight-1) + lfs->cfg->block_size; + < 2*lfs3->cfg->block_size + && lfs3_bptr_size(&bptr) > 0) { + crystal_start = bid-(weight-1) + lfs3->cfg->block_size; } } // start crystallizing! // - // lfsr_file_crystallize_ handles block allocation/relocation - err = lfsr_file_crystallize_(lfs, file, + // lfs3_file_crystallize_ handles block allocation/relocation + err = lfs3_file_crystallize_(lfs3, file, crystal_start, crystal_end - crystal_start, crystal_end - crystal_start, @@ -12388,12 +12390,12 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, } // update buffer state, this may or may not make progress - lfs_soff_t d = lfs_max( - file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr), + lfs3_soff_t d = lfs3_max( + file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr), pos) - pos; pos += d; - buffer += lfs_min(d, size); - size -= lfs_min(d, size); + buffer += lfs3_min(d, size); + size -= lfs3_min(d, size); // we should be aligned now aligned = true; @@ -12407,9 +12409,9 @@ fragment:; // // but note we're still tracking its erased state for future // writes! - if (lfsr_o_isungraft(file->b.o.flags)) { + if (lfs3_o_isungraft(file->b.o.flags)) { // graft our crystal - int err = lfsr_file_graft(lfs, file, + int err = lfs3_file_graft(lfs3, file, file->leaf.pos, file->leaf.weight, 0, &file->leaf.bptr.data, -1); if (err) { @@ -12417,7 +12419,7 @@ fragment:; } // mark as grafted - file->b.o.flags &= ~LFS_o_UNGRAFT; + file->b.o.flags &= ~LFS3_o_UNGRAFT; } // do we need to discard our leaf? we need to discard fragments @@ -12430,44 +12432,44 @@ fragment:; // unfortunately we don't know where our fragment will end up // until after the commit, so we can't track it in our leaf // quite yet - if (!lfsr_bptr_isbptr(&file->leaf.bptr) - || (pos < file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr) + if (!lfs3_bptr_isbptr(&file->leaf.bptr) + || (pos < file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr) && pos + size > file->leaf.pos)) { - lfsr_file_discardleaf(file); + lfs3_file_discardleaf(file); } // truncate to our fragment size - lfs_off_t fragment_start = pos; - lfs_off_t fragment_end = fragment_start + lfs_min( + lfs3_off_t fragment_start = pos; + lfs3_off_t fragment_end = fragment_start + lfs3_min( size, - lfs->cfg->fragment_size); + lfs3->cfg->fragment_size); - lfsr_data_t datas[3]; - lfs_size_t data_count = 0; + lfs3_data_t datas[3]; + lfs3_size_t data_count = 0; // do we have a left sibling? don't bother to lookup if fragment // is already full - if (fragment_end - fragment_start < lfs->cfg->fragment_size + if (fragment_end - fragment_start < lfs3->cfg->fragment_size && fragment_start > 0 - && fragment_start <= lfsr_file_weight(file) + && fragment_start <= lfs3_file_weight(file) // don't bother to lookup left after first fragment && !aligned) { - lfsr_bid_t bid; - lfsr_bid_t weight; - lfsr_bptr_t bptr; - int err = lfsr_file_lookup(lfs, file, + lfs3_bid_t bid; + lfs3_bid_t weight; + lfs3_bptr_t bptr; + int err = lfs3_file_lookup(lfs3, file, fragment_start-1, &bid, &weight, &bptr); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - #ifdef LFS_CKFETCHES + #ifdef LFS3_CKFETCHES // checking fetches? - if (lfsr_m_isckfetches(lfs->flags) - && lfsr_bptr_isbptr(&bptr)) { - err = lfsr_bptr_ck(lfs, &bptr); + if (lfs3_m_isckfetches(lfs3->flags) + && lfs3_bptr_isbptr(&bptr)) { + err = lfs3_bptr_ck(lfs3, &bptr); if (err) { return err; } @@ -12475,21 +12477,21 @@ fragment:; #endif // can we coalesce? - if (bid-(weight-1) + lfsr_bptr_size(&bptr) >= fragment_start + if (bid-(weight-1) + lfs3_bptr_size(&bptr) >= fragment_start && fragment_end - (bid-(weight-1)) - <= lfs->cfg->fragment_size) { - datas[data_count++] = LFSR_DATA_TRUNCATE(bptr.data, + <= lfs3->cfg->fragment_size) { + datas[data_count++] = LFS3_DATA_TRUNCATE(bptr.data, fragment_start - (bid-(weight-1))); fragment_start = bid-(weight-1); - fragment_end = fragment_start + lfs_min( + fragment_end = fragment_start + lfs3_min( fragment_end - (bid-(weight-1)), - lfs->cfg->fragment_size); + lfs3->cfg->fragment_size); } } // append our new data - datas[data_count++] = LFSR_DATA_BUF( + datas[data_count++] = LFS3_DATA_BUF( buffer, fragment_end - pos); @@ -12497,24 +12499,24 @@ fragment:; // is already full // // note this may the same as our left sibling - if (fragment_end - fragment_start < lfs->cfg->fragment_size - && fragment_end < lfsr_file_weight(file)) { - lfsr_bid_t bid; - lfsr_bid_t weight; - lfsr_bptr_t bptr; - int err = lfsr_file_lookup(lfs, file, + if (fragment_end - fragment_start < lfs3->cfg->fragment_size + && fragment_end < lfs3_file_weight(file)) { + lfs3_bid_t bid; + lfs3_bid_t weight; + lfs3_bptr_t bptr; + int err = lfs3_file_lookup(lfs3, file, fragment_end, &bid, &weight, &bptr); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - #ifdef LFS_CKFETCHES + #ifdef LFS3_CKFETCHES // checking fetches? - if (lfsr_m_isckfetches(lfs->flags) - && lfsr_bptr_isbptr(&bptr)) { - err = lfsr_bptr_ck(lfs, &bptr); + if (lfs3_m_isckfetches(lfs3->flags) + && lfs3_bptr_isbptr(&bptr)) { + err = lfs3_bptr_ck(lfs3, &bptr); if (err) { return err; } @@ -12522,27 +12524,27 @@ fragment:; #endif // can we coalesce? - if (fragment_end < bid-(weight-1) + lfsr_bptr_size(&bptr) - && bid-(weight-1) + lfsr_bptr_size(&bptr) + if (fragment_end < bid-(weight-1) + lfs3_bptr_size(&bptr) + && bid-(weight-1) + lfs3_bptr_size(&bptr) - fragment_start - <= lfs->cfg->fragment_size) { - datas[data_count++] = LFSR_DATA_FRUNCATE(bptr.data, - bid-(weight-1) + lfsr_bptr_size(&bptr) + <= lfs3->cfg->fragment_size) { + datas[data_count++] = LFS3_DATA_FRUNCATE(bptr.data, + bid-(weight-1) + lfs3_bptr_size(&bptr) - fragment_end); - fragment_end = fragment_start + lfs_min( - bid-(weight-1) + lfsr_bptr_size(&bptr) + fragment_end = fragment_start + lfs3_min( + bid-(weight-1) + lfs3_bptr_size(&bptr) - fragment_start, - lfs->cfg->fragment_size); + lfs3->cfg->fragment_size); } } // make sure we didn't overflow our data buffer - LFS_ASSERT(data_count <= 3); + LFS3_ASSERT(data_count <= 3); // once we've figured out what fragment to write, graft it into // our tree - int err = lfsr_file_graft(lfs, file, + int err = lfs3_file_graft(lfs3, file, fragment_start, fragment_end - fragment_start, 0, datas, data_count); if (err) { @@ -12550,10 +12552,10 @@ fragment:; } // update buffer state - lfs_ssize_t d = fragment_end - pos; + lfs3_ssize_t d = fragment_end - pos; pos += d; - buffer += lfs_min(d, size); - size -= lfs_min(d, size); + buffer += lfs3_min(d, size); + size -= lfs3_min(d, size); // we should be aligned now aligned = true; @@ -12565,11 +12567,11 @@ fragment:; // high-level file writing -lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, - const void *buffer, lfs_size_t size) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +lfs3_ssize_t lfs3_file_write(lfs3_t *lfs3, lfs3_file_t *file, + const void *buffer, lfs3_size_t size) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't write to readonly files - LFS_ASSERT(!lfsr_o_isrdonly(file->b.o.flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(file->b.o.flags)); // size=0 is a bit special and is guaranteed to have no effects on the // underlying file, this means no updating file pos or file size @@ -12581,26 +12583,26 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, // would this write make our file larger than our file limit? int err; - if (size > lfs->file_limit - file->pos) { - err = LFS_ERR_FBIG; + if (size > lfs3->file_limit - file->pos) { + err = LFS3_ERR_FBIG; goto failed; } // clobber entangled traversals - lfsr_omdir_clobber(lfs, &file->b.o, LFS_t_DIRTY); + lfs3_omdir_clobber(lfs3, &file->b.o, LFS3_t_DIRTY); // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // mark as unsynced in case we fail - file->b.o.flags |= LFS_o_UNSYNC; + file->b.o.flags |= LFS3_o_UNSYNC; // update pos if we are appending - lfs_off_t pos = file->pos; - if (lfsr_o_isappend(file->b.o.flags)) { - pos = lfsr_file_size_(file); + lfs3_off_t pos = file->pos; + if (lfs3_o_isappend(file->b.o.flags)) { + pos = lfs3_file_size_(file); } const uint8_t *buffer_ = buffer; - lfs_size_t written = 0; + lfs3_size_t written = 0; while (size > 0) { // bypass cache? // @@ -12608,10 +12610,10 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, // strictly necessary, but enforces a more intuitive write order // and avoids weird cases with low-level write heuristics // - if ((!lfsr_o_isunflush(file->b.o.flags) + if ((!lfs3_o_isunflush(file->b.o.flags) || file->cache.size == 0) - && size >= lfsr_file_cachesize(lfs, file)) { - err = lfsr_file_flush_(lfs, file, + && size >= lfs3_file_cachesize(lfs3, file)) { + err = lfs3_file_flush_(lfs3, file, pos, buffer_, size); if (err) { goto failed; @@ -12621,13 +12623,13 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, // // note we need to clear the cache anyways to avoid any // out-of-date data - file->cache.pos = pos + size - lfsr_file_cachesize(lfs, file); - lfs_memcpy(file->cache.buffer, - &buffer_[size - lfsr_file_cachesize(lfs, file)], - lfsr_file_cachesize(lfs, file)); - file->cache.size = lfsr_file_cachesize(lfs, file); + file->cache.pos = pos + size - lfs3_file_cachesize(lfs3, file); + lfs3_memcpy(file->cache.buffer, + &buffer_[size - lfs3_file_cachesize(lfs3, file)], + lfs3_file_cachesize(lfs3, file)); + file->cache.size = lfs3_file_cachesize(lfs3, file); - file->b.o.flags &= ~LFS_o_UNFLUSH; + file->b.o.flags &= ~LFS3_o_UNFLUSH; written += size; pos += size; buffer_ += size; @@ -12645,32 +12647,32 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, // 2. Bypassing the cache above means we only write to the // cache once, and flush at most twice. // - if ((!lfsr_o_isunflush(file->b.o.flags) + if ((!lfs3_o_isunflush(file->b.o.flags) || file->cache.size == 0) || (pos >= file->cache.pos && pos <= file->cache.pos + file->cache.size && pos < file->cache.pos - + lfsr_file_cachesize(lfs, file))) { + + lfs3_file_cachesize(lfs3, file))) { // unused cache? we can move it where we need it - if ((!lfsr_o_isunflush(file->b.o.flags) + if ((!lfs3_o_isunflush(file->b.o.flags) || file->cache.size == 0)) { file->cache.pos = pos; file->cache.size = 0; } - lfs_size_t d = lfs_min( + lfs3_size_t d = lfs3_min( size, - lfsr_file_cachesize(lfs, file) + lfs3_file_cachesize(lfs3, file) - (pos - file->cache.pos)); - lfs_memcpy(&file->cache.buffer[pos - file->cache.pos], + lfs3_memcpy(&file->cache.buffer[pos - file->cache.pos], buffer_, d); - file->cache.size = lfs_max( + file->cache.size = lfs3_max( file->cache.size, pos+d - file->cache.pos); - file->b.o.flags |= LFS_o_UNFLUSH; + file->b.o.flags |= LFS3_o_UNFLUSH; written += d; pos += d; buffer_ += d; @@ -12679,28 +12681,28 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, } // flush our cache so the above can't fail - err = lfsr_file_flush_(lfs, file, + err = lfs3_file_flush_(lfs3, file, file->cache.pos, file->cache.buffer, file->cache.size); if (err) { goto failed; } - file->b.o.flags &= ~LFS_o_UNFLUSH; + file->b.o.flags &= ~LFS3_o_UNFLUSH; } // update our pos file->pos = pos; // flush if requested - if (lfsr_o_isflush(file->b.o.flags)) { - err = lfsr_file_flush(lfs, file); + if (lfs3_o_isflush(file->b.o.flags)) { + err = lfs3_file_flush(lfs3, file); if (err) { goto failed; } } // sync if requested - if (lfsr_o_issync(file->b.o.flags)) { - err = lfsr_file_sync(lfs, file); + if (lfs3_o_issync(file->b.o.flags)) { + err = lfs3_file_sync(lfs3, file); if (err) { goto failed; } @@ -12709,46 +12711,46 @@ lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, return written; failed:; - // mark as desync so lfsr_file_close doesn't write to disk - file->b.o.flags |= LFS_O_DESYNC; + // mark as desync so lfs3_file_close doesn't write to disk + file->b.o.flags |= LFS3_O_DESYNC; return err; } -int lfsr_file_flush(lfs_t *lfs, lfsr_file_t *file) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_flush(lfs3_t *lfs3, lfs3_file_t *file) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't write to readonly files - LFS_ASSERT(!lfsr_o_isrdonly(file->b.o.flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(file->b.o.flags)); // do nothing if our file is already flushed, crystallized, // and grafted - if (!lfsr_o_isunflush(file->b.o.flags) - && !lfsr_o_isuncryst(file->b.o.flags) - && !lfsr_o_isungraft(file->b.o.flags)) { + if (!lfs3_o_isunflush(file->b.o.flags) + && !lfs3_o_isuncryst(file->b.o.flags) + && !lfs3_o_isungraft(file->b.o.flags)) { return 0; } // unflushed files must be unsynced - LFS_ASSERT(lfsr_o_isunsync(file->b.o.flags)); + LFS3_ASSERT(lfs3_o_isunsync(file->b.o.flags)); // clobber entangled traversals - lfsr_omdir_clobber(lfs, &file->b.o, LFS_t_DIRTY); + lfs3_omdir_clobber(lfs3, &file->b.o, LFS3_t_DIRTY); // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); int err; // flush our cache - if (lfsr_o_isunflush(file->b.o.flags)) { - err = lfsr_file_flush_(lfs, file, + if (lfs3_o_isunflush(file->b.o.flags)) { + err = lfs3_file_flush_(lfs3, file, file->cache.pos, file->cache.buffer, file->cache.size); if (err) { goto failed; } // mark as flushed - file->b.o.flags &= ~LFS_o_UNFLUSH; + file->b.o.flags &= ~LFS3_o_UNFLUSH; } // and crystallize/graft our leaf - err = lfsr_file_crystallize(lfs, file); + err = lfs3_file_crystallize(lfs3, file); if (err) { goto failed; } @@ -12756,99 +12758,99 @@ int lfsr_file_flush(lfs_t *lfs, lfsr_file_t *file) { return 0; failed:; - // mark as desync so lfsr_file_close doesn't write to disk - file->b.o.flags |= LFS_O_DESYNC; + // mark as desync so lfs3_file_close doesn't write to disk + file->b.o.flags |= LFS3_O_DESYNC; return err; } -// this LFS_NOINLINE is to force lfsr_file_sync_ off the stack hot-path -LFS_NOINLINE -static int lfsr_file_sync_(lfs_t *lfs, lfsr_file_t *file) { +// this LFS3_NOINLINE is to force lfs3_file_sync_ off the stack hot-path +LFS3_NOINLINE +static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file) { // build a commit of any pending file metadata - lfsr_rattr_t rattrs[4]; - lfs_size_t rattr_count = 0; - lfsr_data_t name_data; - lfsr_rattr_t shrub_rattrs[1]; - lfs_size_t shrub_rattr_count = 0; - lfsr_shrubcommit_t shrub_commit; + lfs3_rattr_t rattrs[4]; + lfs3_size_t rattr_count = 0; + lfs3_data_t name_data; + lfs3_rattr_t shrub_rattrs[1]; + lfs3_size_t shrub_rattr_count = 0; + lfs3_shrubcommit_t shrub_commit; // not created yet? need to convert to normal file - if (lfsr_o_isuncreat(file->b.o.flags)) { + if (lfs3_o_isuncreat(file->b.o.flags)) { // uncreated files must be unsynced - LFS_ASSERT(lfsr_o_isunsync(file->b.o.flags)); + LFS3_ASSERT(lfs3_o_isunsync(file->b.o.flags)); - int err = lfsr_rbyd_lookup(lfs, &file->b.o.mdir.rbyd, - lfsr_mrid(lfs, file->b.o.mdir.mid), LFSR_TAG_STICKYNOTE, + int err = lfs3_rbyd_lookup(lfs3, &file->b.o.mdir.rbyd, + lfs3_mrid(lfs3, file->b.o.mdir.mid), LFS3_TAG_STICKYNOTE, NULL, &name_data); if (err) { // orphan flag but no stickynote tag? - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } - rattrs[rattr_count++] = LFSR_RATTR_DATA( - LFSR_TAG_MASK8 | LFSR_TAG_REG, 0, + rattrs[rattr_count++] = LFS3_RATTR_DATA( + LFS3_TAG_MASK8 | LFS3_TAG_REG, 0, &name_data); } // pending small file flush? - if (lfsr_o_isunflush(file->b.o.flags)) { + if (lfs3_o_isunflush(file->b.o.flags)) { // this only works if the file is entirely in our cache - LFS_ASSERT(file->cache.pos == 0); - LFS_ASSERT(file->cache.size == lfsr_file_size_(file)); + LFS3_ASSERT(file->cache.pos == 0); + LFS3_ASSERT(file->cache.size == lfs3_file_size_(file)); // reset the bshrub - lfsr_file_discardbshrub(file); + lfs3_file_discardbshrub(file); // build a small shrub commit if (file->cache.size > 0) { - shrub_rattrs[shrub_rattr_count++] = LFSR_RATTR_DATA( - LFSR_TAG_DATA, +file->cache.size, - (const lfsr_data_t*)&file->cache); + shrub_rattrs[shrub_rattr_count++] = LFS3_RATTR_DATA( + LFS3_TAG_DATA, +file->cache.size, + (const lfs3_data_t*)&file->cache); - LFS_ASSERT(shrub_rattr_count - <= sizeof(shrub_rattrs)/sizeof(lfsr_rattr_t)); + LFS3_ASSERT(shrub_rattr_count + <= sizeof(shrub_rattrs)/sizeof(lfs3_rattr_t)); shrub_commit.bshrub = &file->b; shrub_commit.rid = 0; shrub_commit.rattrs = shrub_rattrs; shrub_commit.rattr_count = shrub_rattr_count; - rattrs[rattr_count++] = LFSR_RATTR_SHRUBCOMMIT(&shrub_commit); + rattrs[rattr_count++] = LFS3_RATTR_SHRUBCOMMIT(&shrub_commit); } } // pending file changes? - if (lfsr_o_isunsync(file->b.o.flags)) { + if (lfs3_o_isunsync(file->b.o.flags)) { // make sure data is on-disk before committing metadata - int err = lfsr_bd_sync(lfs); + int err = lfs3_bd_sync(lfs3); if (err) { return err; } // zero size files should have no bshrub/btree - LFS_ASSERT(lfsr_file_size_(file) > 0 - || lfsr_bshrub_isbnull(&file->b)); + LFS3_ASSERT(lfs3_file_size_(file) > 0 + || lfs3_bshrub_isbnull(&file->b)); // no bshrub/btree? - if (lfsr_bshrub_isbnull(&file->b) - && !(lfsr_o_isunflush(file->b.o.flags) + if (lfs3_bshrub_isbnull(&file->b) + && !(lfs3_o_isunflush(file->b.o.flags) && file->cache.size > 0)) { - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, 0); + rattrs[rattr_count++] = LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, 0); // bshrub? - } else if (lfsr_bshrub_isbshrub(&file->b) - || (lfsr_o_isunflush(file->b.o.flags) + } else if (lfs3_bshrub_isbshrub(&file->b) + || (lfs3_o_isunflush(file->b.o.flags) && file->cache.size > 0)) { - rattrs[rattr_count++] = LFSR_RATTR_SHRUB( - LFSR_TAG_MASK8 | LFSR_TAG_BSHRUB, 0, + rattrs[rattr_count++] = LFS3_RATTR_SHRUB( + LFS3_TAG_MASK8 | LFS3_TAG_BSHRUB, 0, // note we use the staged trunk here &file->b.shrub_); // btree? - } else if (lfsr_bshrub_isbtree(&file->b)) { - rattrs[rattr_count++] = LFSR_RATTR_BTREE( - LFSR_TAG_MASK8 | LFSR_TAG_BTREE, 0, + } else if (lfs3_bshrub_isbtree(&file->b)) { + rattrs[rattr_count++] = LFS3_RATTR_BTREE( + LFS3_TAG_MASK8 | LFS3_TAG_BTREE, 0, &file->b.shrub); } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } @@ -12857,32 +12859,32 @@ static int lfsr_file_sync_(lfs_t *lfs, lfsr_file_t *file) { // this gets real messy, since users can change custom attributes // whenever they want without informing littlefs, the best we can do // is read from disk to manually check if any attributes changed - bool attrs = lfsr_o_isunsync(file->b.o.flags); + bool attrs = lfs3_o_isunsync(file->b.o.flags); if (!attrs) { - for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) { + for (lfs3_size_t i = 0; i < file->cfg->attr_count; i++) { // skip readonly attrs and lazy attrs - if (lfsr_o_isrdonly(file->cfg->attrs[i].flags) - || lfsr_a_islazy(file->cfg->attrs[i].flags)) { + if (lfs3_o_isrdonly(file->cfg->attrs[i].flags) + || lfs3_a_islazy(file->cfg->attrs[i].flags)) { continue; } // lookup the attr - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, &file->b.o.mdir, - LFSR_TAG_ATTR(file->cfg->attrs[i].type), + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, &file->b.o.mdir, + LFS3_TAG_ATTR(file->cfg->attrs[i].type), NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } // does disk match our attr? - lfs_scmp_t cmp = lfsr_attr_cmp(lfs, &file->cfg->attrs[i], - (err != LFS_ERR_NOENT) ? &data : NULL); + lfs3_scmp_t cmp = lfs3_attr_cmp(lfs3, &file->cfg->attrs[i], + (err != LFS3_ERR_NOENT) ? &data : NULL); if (cmp < 0) { return cmp; } - if (cmp != LFS_CMP_EQ) { + if (cmp != LFS3_CMP_EQ) { attrs = true; break; } @@ -12890,18 +12892,18 @@ static int lfsr_file_sync_(lfs_t *lfs, lfsr_file_t *file) { } if (attrs) { // need to append custom attributes - rattrs[rattr_count++] = LFSR_RATTR_ATTRS( + rattrs[rattr_count++] = LFS3_RATTR_ATTRS( file->cfg->attrs, file->cfg->attr_count); } // pending metadata? looks like we need to write to disk if (rattr_count > 0) { // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // commit! - LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); - int err = lfsr_mdir_commit(lfs, &file->b.o.mdir, + LFS3_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); + int err = lfs3_mdir_commit(lfs3, &file->b.o.mdir, rattrs, rattr_count); if (err) { return err; @@ -12911,15 +12913,15 @@ static int lfsr_file_sync_(lfs_t *lfs, lfsr_file_t *file) { return 0; } -int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_sync(lfs3_t *lfs3, lfs3_file_t *file) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't write to readonly files, if you want to resync call - // lfsr_file_resync - LFS_ASSERT(!lfsr_o_isrdonly(file->b.o.flags)); + // lfs3_file_resync + LFS3_ASSERT(!lfs3_o_isrdonly(file->b.o.flags)); // removed? sync is just a noop in this case int err; - if (lfsr_o_iszombie(file->b.o.flags)) { + if (lfs3_o_iszombie(file->b.o.flags)) { return 0; } @@ -12932,16 +12934,16 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { // // though don't flush quite yet if our file is small and can be // combined with sync in a single commit - if (file->cache.size == lfsr_file_size_(file) - && file->cache.size <= lfs->cfg->inline_size - && file->cache.size <= lfs->cfg->fragment_size - && file->cache.size < lfs->cfg->crystal_thresh) { - if (lfsr_o_isungraft(file->b.o.flags)) { - file->b.o.flags |= LFS_o_UNFLUSH; + if (file->cache.size == lfs3_file_size_(file) + && file->cache.size <= lfs3->cfg->inline_size + && file->cache.size <= lfs3->cfg->fragment_size + && file->cache.size < lfs3->cfg->crystal_thresh) { + if (lfs3_o_isungraft(file->b.o.flags)) { + file->b.o.flags |= LFS3_o_UNFLUSH; } - lfsr_file_discardleaf(file); + lfs3_file_discardleaf(file); } else { - err = lfsr_file_flush(lfs, file); + err = lfs3_file_flush(lfs3, file); if (err) { goto failed; } @@ -12950,34 +12952,34 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { // commit any pending metadata to disk // // the use of a second function here is mainly to isolate the stack - // costs of lfsr_file_flush and lfsr_file_sync_ + // costs of lfs3_file_flush and lfs3_file_sync_ // - err = lfsr_file_sync_(lfs, file); + err = lfs3_file_sync_(lfs3, file); if (err) { goto failed; } // update in-device state - for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { - if (lfsr_o_type(o->flags) == LFS_TYPE_REG + for (lfs3_omdir_t *o = lfs3->omdirs; o; o = o->next) { + if (lfs3_o_type(o->flags) == LFS3_TYPE_REG && o->mdir.mid == file->b.o.mdir.mid // don't double update && o != &file->b.o) { - lfsr_file_t *file_ = (lfsr_file_t*)o; + lfs3_file_t *file_ = (lfs3_file_t*)o; // notify all files of creation - file_->b.o.flags &= ~LFS_o_UNCREAT; + file_->b.o.flags &= ~LFS3_o_UNCREAT; // mark desynced files an unsynced - if (lfsr_o_isdesync(file_->b.o.flags)) { - file_->b.o.flags |= LFS_o_UNSYNC; + if (lfs3_o_isdesync(file_->b.o.flags)) { + file_->b.o.flags |= LFS3_o_UNSYNC; // update synced files } else { // update flags - file_->b.o.flags &= ~LFS_o_UNSYNC - & ~LFS_o_UNFLUSH - & ~LFS_o_UNCRYST - & ~LFS_o_UNGRAFT; + file_->b.o.flags &= ~LFS3_o_UNSYNC + & ~LFS3_o_UNFLUSH + & ~LFS3_o_UNCRYST + & ~LFS3_o_UNGRAFT; // update shrubs file_->b.shrub = file->b.shrub; // update leaves @@ -12987,38 +12989,38 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { // // note we need to be careful if caches have different // sizes, prefer the most recent data in this case - lfs_size_t d = file->cache.size - lfs_min( - lfsr_file_cachesize(lfs, file_), + lfs3_size_t d = file->cache.size - lfs3_min( + lfs3_file_cachesize(lfs3, file_), file->cache.size); file_->cache.pos = file->cache.pos + d; - lfs_memcpy(file_->cache.buffer, + lfs3_memcpy(file_->cache.buffer, file->cache.buffer + d, file->cache.size - d); file_->cache.size = file->cache.size - d; // update any custom attrs - for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) { - if (lfsr_o_isrdonly(file->cfg->attrs[i].flags)) { + for (lfs3_size_t i = 0; i < file->cfg->attr_count; i++) { + if (lfs3_o_isrdonly(file->cfg->attrs[i].flags)) { continue; } - for (lfs_size_t j = 0; j < file_->cfg->attr_count; j++) { + for (lfs3_size_t j = 0; j < file_->cfg->attr_count; j++) { if (!(file_->cfg->attrs[j].type == file->cfg->attrs[i].type - && !lfsr_o_iswronly( + && !lfs3_o_iswronly( file_->cfg->attrs[j].flags))) { continue; } - if (lfsr_attr_isnoattr(&file->cfg->attrs[i])) { + if (lfs3_attr_isnoattr(&file->cfg->attrs[i])) { if (file_->cfg->attrs[j].size) { - *file_->cfg->attrs[j].size = LFS_ERR_NOATTR; + *file_->cfg->attrs[j].size = LFS3_ERR_NOATTR; } } else { - lfs_size_t d = lfs_min( - lfsr_attr_size(&file->cfg->attrs[i]), + lfs3_size_t d = lfs3_min( + lfs3_attr_size(&file->cfg->attrs[i]), file_->cfg->attrs[j].buffer_size); - lfs_memcpy(file_->cfg->attrs[j].buffer, + lfs3_memcpy(file_->cfg->attrs[j].buffer, file->cfg->attrs[i].buffer, d); if (file_->cfg->attrs[j].size) { @@ -13030,86 +13032,86 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { } // clobber entangled traversals - } else if (lfsr_o_type(o->flags) == LFS_type_TRAVERSAL + } else if (lfs3_o_type(o->flags) == LFS3_type_TRAVERSAL && o->mdir.mid == file->b.o.mdir.mid) { - lfsr_traversal_clobber(lfs, (lfsr_traversal_t*)o); + lfs3_traversal_clobber(lfs3, (lfs3_traversal_t*)o); } } // mark as synced - file->b.o.flags &= ~LFS_o_UNSYNC - & ~LFS_o_UNFLUSH - & ~LFS_o_UNCRYST - & ~LFS_o_UNGRAFT - & ~LFS_o_UNCREAT - & ~LFS_O_DESYNC; + file->b.o.flags &= ~LFS3_o_UNSYNC + & ~LFS3_o_UNFLUSH + & ~LFS3_o_UNCRYST + & ~LFS3_o_UNGRAFT + & ~LFS3_o_UNCREAT + & ~LFS3_O_DESYNC; return 0; failed:; - file->b.o.flags |= LFS_O_DESYNC; + file->b.o.flags |= LFS3_O_DESYNC; return err; } -int lfsr_file_desync(lfs_t *lfs, lfsr_file_t *file) { - (void)lfs; - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_desync(lfs3_t *lfs3, lfs3_file_t *file) { + (void)lfs3; + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // mark as desynced - file->b.o.flags |= LFS_O_DESYNC; + file->b.o.flags |= LFS3_O_DESYNC; return 0; } -int lfsr_file_resync(lfs_t *lfs, lfsr_file_t *file) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_resync(lfs3_t *lfs3, lfs3_file_t *file) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // removed? we can't resync int err; - if (lfsr_o_iszombie(file->b.o.flags)) { - err = LFS_ERR_NOENT; + if (lfs3_o_iszombie(file->b.o.flags)) { + err = LFS3_ERR_NOENT; goto failed; } // do nothing if already in-sync - if (lfsr_o_isunsync(file->b.o.flags)) { + if (lfs3_o_isunsync(file->b.o.flags)) { // refetch the file struct from disk - err = lfsr_file_fetch(lfs, file, false); + err = lfs3_file_fetch(lfs3, file, false); if (err) { goto failed; } } // mark as resynced - file->b.o.flags &= ~LFS_O_DESYNC; + file->b.o.flags &= ~LFS3_O_DESYNC; return 0; failed:; - file->b.o.flags |= LFS_O_DESYNC; + file->b.o.flags |= LFS3_O_DESYNC; return err; } // other file operations -lfs_soff_t lfsr_file_seek(lfs_t *lfs, lfsr_file_t *file, - lfs_soff_t off, uint8_t whence) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +lfs3_soff_t lfs3_file_seek(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_soff_t off, uint8_t whence) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // TODO check for out-of-range? // figure out our new file position - lfs_off_t pos_; - if (whence == LFS_SEEK_SET) { + lfs3_off_t pos_; + if (whence == LFS3_SEEK_SET) { pos_ = off; - } else if (whence == LFS_SEEK_CUR) { + } else if (whence == LFS3_SEEK_CUR) { pos_ = file->pos + off; - } else if (whence == LFS_SEEK_END) { - pos_ = lfsr_file_size_(file) + off; + } else if (whence == LFS3_SEEK_END) { + pos_ = lfs3_file_size_(file) + off; } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } // out of range? - if (pos_ > lfs->file_limit) { - return LFS_ERR_INVAL; + if (pos_ > lfs3->file_limit) { + return LFS3_ERR_INVAL; } // update file position @@ -13117,52 +13119,52 @@ lfs_soff_t lfsr_file_seek(lfs_t *lfs, lfsr_file_t *file, return pos_; } -lfs_soff_t lfsr_file_tell(lfs_t *lfs, lfsr_file_t *file) { - (void)lfs; - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +lfs3_soff_t lfs3_file_tell(lfs3_t *lfs3, lfs3_file_t *file) { + (void)lfs3; + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); return file->pos; } -lfs_soff_t lfsr_file_rewind(lfs_t *lfs, lfsr_file_t *file) { - (void)lfs; - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +lfs3_soff_t lfs3_file_rewind(lfs3_t *lfs3, lfs3_file_t *file) { + (void)lfs3; + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); file->pos = 0; return 0; } -lfs_soff_t lfsr_file_size(lfs_t *lfs, lfsr_file_t *file) { - (void)lfs; - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +lfs3_soff_t lfs3_file_size(lfs3_t *lfs3, lfs3_file_t *file) { + (void)lfs3; + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); - return lfsr_file_size_(file); + return lfs3_file_size_(file); } -int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_truncate(lfs3_t *lfs3, lfs3_file_t *file, lfs3_off_t size_) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't write to readonly files - LFS_ASSERT(!lfsr_o_isrdonly(file->b.o.flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(file->b.o.flags)); // do nothing if our size does not change - lfs_off_t size = lfsr_file_size_(file); - if (lfsr_file_size_(file) == size_) { + lfs3_off_t size = lfs3_file_size_(file); + if (lfs3_file_size_(file) == size_) { return 0; } // exceeds our file limit? int err; - if (size_ > lfs->file_limit) { - err = LFS_ERR_FBIG; + if (size_ > lfs3->file_limit) { + err = LFS3_ERR_FBIG; goto failed; } // clobber entangled traversals - lfsr_omdir_clobber(lfs, &file->b.o, LFS_t_DIRTY); + lfs3_omdir_clobber(lfs3, &file->b.o, LFS3_t_DIRTY); // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // mark as unsynced in case we fail - file->b.o.flags |= LFS_o_UNSYNC; + file->b.o.flags |= LFS3_o_UNSYNC; // if our leaf is a fragment or will be fragmented, we need // to go ahead and graft + discard it, otherwise we risk out-of-date @@ -13170,22 +13172,22 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { // // note this is mostly to match the behavior of fruncate, where we // _really_ don't want to discard erased-state - if (!lfsr_bptr_isbptr(&file->leaf.bptr) - || size_ - lfs_min(file->leaf.pos, size_) - < lfs_min( - lfs->cfg->fragment_thresh, - lfs->cfg->crystal_thresh)) { - err = lfsr_file_crystallize(lfs, file); + if (!lfs3_bptr_isbptr(&file->leaf.bptr) + || size_ - lfs3_min(file->leaf.pos, size_) + < lfs3_min( + lfs3->cfg->fragment_thresh, + lfs3->cfg->crystal_thresh)) { + err = lfs3_file_crystallize(lfs3, file); if (err) { goto failed; } - lfsr_file_discardleaf(file); + lfs3_file_discardleaf(file); } // truncate our btree - err = lfsr_file_graft(lfs, file, - lfs_min(size, size_), size - lfs_min(size, size_), + err = lfs3_file_graft(lfs3, file, + lfs3_min(size, size_), size - lfs3_min(size, size_), +size_ - size, NULL, 0); if (err) { @@ -13193,56 +13195,56 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { } // truncate our leaf - if (size_ < file->leaf.pos + lfsr_bptr_size(&file->leaf.bptr)) { - lfsr_bptr_claim(&file->leaf.bptr); - file->b.o.flags &= ~LFS_o_UNCRYST; + if (size_ < file->leaf.pos + lfs3_bptr_size(&file->leaf.bptr)) { + lfs3_bptr_claim(&file->leaf.bptr); + file->b.o.flags &= ~LFS3_o_UNCRYST; } - file->leaf.bptr.data = LFSR_DATA_TRUNCATE( + file->leaf.bptr.data = LFS3_DATA_TRUNCATE( file->leaf.bptr.data, - size_ - lfs_min(file->leaf.pos, size_)); - file->leaf.weight = lfs_min( + size_ - lfs3_min(file->leaf.pos, size_)); + file->leaf.weight = lfs3_min( file->leaf.weight, - size_ - lfs_min(file->leaf.pos, size_)); - file->leaf.pos = lfs_min(file->leaf.pos, size_); + size_ - lfs3_min(file->leaf.pos, size_)); + file->leaf.pos = lfs3_min(file->leaf.pos, size_); // truncate our cache - file->cache.size = lfs_min( + file->cache.size = lfs3_min( file->cache.size, - size_ - lfs_min(file->cache.pos, size_)); - file->cache.pos = lfs_min(file->cache.pos, size_); + size_ - lfs3_min(file->cache.pos, size_)); + file->cache.pos = lfs3_min(file->cache.pos, size_); return 0; failed:; - // mark as desync so lfsr_file_close doesn't write to disk - file->b.o.flags |= LFS_O_DESYNC; + // mark as desync so lfs3_file_close doesn't write to disk + file->b.o.flags |= LFS3_O_DESYNC; return err; } -int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_fruncate(lfs3_t *lfs3, lfs3_file_t *file, lfs3_off_t size_) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't write to readonly files - LFS_ASSERT(!lfsr_o_isrdonly(file->b.o.flags)); + LFS3_ASSERT(!lfs3_o_isrdonly(file->b.o.flags)); // do nothing if our size does not change - lfs_off_t size = lfsr_file_size_(file); + lfs3_off_t size = lfs3_file_size_(file); if (size == size_) { return 0; } // exceeds our file limit? int err; - if (size_ > lfs->file_limit) { - err = LFS_ERR_FBIG; + if (size_ > lfs3->file_limit) { + err = LFS3_ERR_FBIG; goto failed; } // clobber entangled traversals - lfsr_omdir_clobber(lfs, &file->b.o, LFS_t_DIRTY); + lfs3_omdir_clobber(lfs3, &file->b.o, LFS3_t_DIRTY); // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // mark as unsynced in case we fail - file->b.o.flags |= LFS_o_UNSYNC; + file->b.o.flags |= LFS3_o_UNSYNC; // if our leaf is a fragment or will be fragmented, we need // to go ahead and graft + discard it, otherwise we risk out-of-date @@ -13251,26 +13253,26 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { // note that fruncate is commonly used when logging, where we // _really_ don't want to discard erased-state, otherwise we'd just // discard this unconditionally - if (!lfsr_bptr_isbptr(&file->leaf.bptr) - || lfsr_bptr_size(&file->leaf.bptr) - lfs_min( - lfs_smax( + if (!lfs3_bptr_isbptr(&file->leaf.bptr) + || lfs3_bptr_size(&file->leaf.bptr) - lfs3_min( + lfs3_smax( size - size_ - file->leaf.pos, 0), - lfsr_bptr_size(&file->leaf.bptr)) - < lfs_min( - lfs->cfg->fragment_thresh, - lfs->cfg->crystal_thresh)) { - err = lfsr_file_crystallize(lfs, file); + lfs3_bptr_size(&file->leaf.bptr)) + < lfs3_min( + lfs3->cfg->fragment_thresh, + lfs3->cfg->crystal_thresh)) { + err = lfs3_file_crystallize(lfs3, file); if (err) { goto failed; } - lfsr_file_discardleaf(file); + lfs3_file_discardleaf(file); } // fruncate our btree - err = lfsr_file_graft(lfs, file, - 0, lfs_smax(size - size_, 0), + err = lfs3_file_graft(lfs3, file, + 0, lfs3_smax(size - size_, 0), +size_ - size, NULL, 0); if (err) { @@ -13278,79 +13280,79 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { } // fruncate our leaf - if ((lfs_soff_t)(size - size_) - > (lfs_soff_t)(file->leaf.pos - + lfsr_bptr_size(&file->leaf.bptr))) { - lfsr_bptr_claim(&file->leaf.bptr); - file->b.o.flags &= ~LFS_o_UNCRYST; + if ((lfs3_soff_t)(size - size_) + > (lfs3_soff_t)(file->leaf.pos + + lfs3_bptr_size(&file->leaf.bptr))) { + lfs3_bptr_claim(&file->leaf.bptr); + file->b.o.flags &= ~LFS3_o_UNCRYST; } - file->leaf.bptr.data = LFSR_DATA_FRUNCATE( + file->leaf.bptr.data = LFS3_DATA_FRUNCATE( file->leaf.bptr.data, - lfsr_bptr_size(&file->leaf.bptr) - lfs_min( - lfs_smax( + lfs3_bptr_size(&file->leaf.bptr) - lfs3_min( + lfs3_smax( size - size_ - file->leaf.pos, 0), - lfsr_bptr_size(&file->leaf.bptr))); - file->leaf.weight -= lfs_min( - lfs_smax( + lfs3_bptr_size(&file->leaf.bptr))); + file->leaf.weight -= lfs3_min( + lfs3_smax( size - size_ - file->leaf.pos, 0), file->leaf.weight); - file->leaf.pos -= lfs_smin( + file->leaf.pos -= lfs3_smin( size - size_, file->leaf.pos); // fruncate our cache - lfs_memmove(file->cache.buffer, - &file->cache.buffer[lfs_min( - lfs_smax( + lfs3_memmove(file->cache.buffer, + &file->cache.buffer[lfs3_min( + lfs3_smax( size - size_ - file->cache.pos, 0), file->cache.size)], - file->cache.size - lfs_min( - lfs_smax( + file->cache.size - lfs3_min( + lfs3_smax( size - size_ - file->cache.pos, 0), file->cache.size)); - file->cache.size -= lfs_min( - lfs_smax( + file->cache.size -= lfs3_min( + lfs3_smax( size - size_ - file->cache.pos, 0), file->cache.size); - file->cache.pos -= lfs_smin( + file->cache.pos -= lfs3_smin( size - size_, file->cache.pos); // fruncate _does_ update pos, to keep the same pos relative to end // of file, though we can't let pos go negative - file->pos -= lfs_smin( + file->pos -= lfs3_smin( size - size_, file->pos); return 0; failed:; - // mark as desync so lfsr_file_close doesn't write to disk - file->b.o.flags |= LFS_O_DESYNC; + // mark as desync so lfs3_file_close doesn't write to disk + file->b.o.flags |= LFS3_O_DESYNC; return err; } // file check functions -static int lfsr_file_traverse_(lfs_t *lfs, const lfsr_bshrub_t *bshrub, - lfsr_btraversal_t *bt, - lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bptr_t *bptr) { - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_bshrub_traverse(lfs, bshrub, bt, +static int lfs3_file_traverse_(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, + lfs3_btraversal_t *bt, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bptr_t *bptr) { + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_bshrub_traverse(lfs3, bshrub, bt, bid_, &tag, &data); if (err) { return err; } // decode bptrs - if (tag == LFSR_TAG_BLOCK) { - err = lfsr_data_readbptr(lfs, &data, + if (tag == LFS3_TAG_BLOCK) { + err = lfs3_data_readbptr(lfs3, &data, bptr); if (err) { return err; @@ -13365,35 +13367,35 @@ static int lfsr_file_traverse_(lfs_t *lfs, const lfsr_bshrub_t *bshrub, return 0; } -static int lfsr_file_traverse(lfs_t *lfs, const lfsr_file_t *file, - lfsr_btraversal_t *bt, - lfsr_bid_t *bid_, lfsr_tag_t *tag_, lfsr_bptr_t *bptr) { - return lfsr_file_traverse_(lfs, &file->b, bt, +static int lfs3_file_traverse(lfs3_t *lfs3, const lfs3_file_t *file, + lfs3_btraversal_t *bt, + lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bptr_t *bptr) { + return lfs3_file_traverse_(lfs3, &file->b, bt, bid_, tag_, bptr); } -static int lfsr_file_ck(lfs_t *lfs, const lfsr_file_t *file, +static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file, uint32_t flags) { // validate ungrafted data block? - if (lfsr_t_isckdata(flags) - && lfsr_o_isungraft(file->b.o.flags)) { - LFS_ASSERT(lfsr_bptr_isbptr(&file->leaf.bptr)); - int err = lfsr_bptr_ck(lfs, &file->leaf.bptr); + if (lfs3_t_isckdata(flags) + && lfs3_o_isungraft(file->b.o.flags)) { + LFS3_ASSERT(lfs3_bptr_isbptr(&file->leaf.bptr)); + int err = lfs3_bptr_ck(lfs3, &file->leaf.bptr); if (err) { return err; } } // traverse the file's bshrub/btree - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); while (true) { - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(lfs, file, &bt, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(lfs3, file, &bt, NULL, &tag, &bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -13404,11 +13406,11 @@ static int lfsr_file_ck(lfs_t *lfs, const lfsr_file_t *file, // this may end up revalidating some btree nodes when ckfetches // is enabled, but we need to revalidate cached btree nodes or // we risk missing errors in ckmeta scans - if ((lfsr_t_isckmeta(flags) - || lfsr_t_isckdata(flags)) - && tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; - err = lfsr_rbyd_fetchck(lfs, rbyd, + if ((lfs3_t_isckmeta(flags) + || lfs3_t_isckdata(flags)) + && tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; + err = lfs3_rbyd_fetchck(lfs3, rbyd, rbyd->blocks[0], rbyd->trunk, rbyd->cksum); if (err) { @@ -13417,9 +13419,9 @@ static int lfsr_file_ck(lfs_t *lfs, const lfsr_file_t *file, } // validate data blocks? - if (lfsr_t_isckdata(flags) - && tag == LFSR_TAG_BLOCK) { - err = lfsr_bptr_ck(lfs, &bptr); + if (lfs3_t_isckdata(flags) + && tag == LFS3_TAG_BLOCK) { + err = lfs3_bptr_ck(lfs3, &bptr); if (err) { return err; } @@ -13429,22 +13431,22 @@ static int lfsr_file_ck(lfs_t *lfs, const lfsr_file_t *file, return 0; } -int lfsr_file_ckmeta(lfs_t *lfs, lfsr_file_t *file) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_ckmeta(lfs3_t *lfs3, lfs3_file_t *file) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't read from writeonly files - LFS_ASSERT(!lfsr_o_iswronly(file->b.o.flags)); + LFS3_ASSERT(!lfs3_o_iswronly(file->b.o.flags)); - return lfsr_file_ck(lfs, file, - LFS_T_RDONLY | LFS_T_CKMETA); + return lfs3_file_ck(lfs3, file, + LFS3_T_RDONLY | LFS3_T_CKMETA); } -int lfsr_file_ckdata(lfs_t *lfs, lfsr_file_t *file) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &file->b.o)); +int lfs3_file_ckdata(lfs3_t *lfs3, lfs3_file_t *file) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &file->b.o)); // can't read from writeonly files - LFS_ASSERT(!lfsr_o_iswronly(file->b.o.flags)); + LFS3_ASSERT(!lfs3_o_iswronly(file->b.o.flags)); - return lfsr_file_ck(lfs, file, - LFS_T_RDONLY | LFS_T_CKMETA | LFS_T_CKDATA); + return lfs3_file_ck(lfs3, file, + LFS3_T_RDONLY | LFS3_T_CKMETA | LFS3_T_CKDATA); } @@ -13452,157 +13454,159 @@ int lfsr_file_ckdata(lfs_t *lfs, lfsr_file_t *file) { /// High-level filesystem operations /// -// needed in lfs_init -static int lfs_deinit(lfs_t *lfs); +// needed in lfs3_init +static int lfs3_deinit(lfs3_t *lfs3); // initialize littlefs state, assert on bad configuration -static int lfs_init(lfs_t *lfs, uint32_t flags, - const struct lfs_config *cfg) { +static int lfs3_init(lfs3_t *lfs3, uint32_t flags, + const struct lfs3_config *cfg) { // unknown flags? - LFS_ASSERT((flags & ~( - LFS_M_RDWR - | LFS_M_RDONLY - | LFS_M_FLUSH - | LFS_M_SYNC - | LFS_IFDEF_REVDBG(LFS_M_REVDBG, 0) - | LFS_IFDEF_REVNOISE(LFS_M_REVNOISE, 0) - | LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, 0) - | LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, 0) - | LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, 0) - | LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, 0))) == 0); - #if defined(LFS_REVNOISE) && defined(LFS_REVDBG) - // LFS_M_REVDBG and LFS_M_REVNOISE are incompatible - LFS_ASSERT(!lfsr_m_isrevdbg(flags) || !lfsr_m_isrevnoise(flags)); + LFS3_ASSERT((flags & ~( + LFS3_M_RDWR + | LFS3_M_RDONLY + | LFS3_M_FLUSH + | LFS3_M_SYNC + | LFS3_IFDEF_REVDBG(LFS3_M_REVDBG, 0) + | LFS3_IFDEF_REVNOISE(LFS3_M_REVNOISE, 0) + | LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, 0) + | LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, 0) + | LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, 0) + | LFS3_IFDEF_CKDATACKSUMREADS( + LFS3_M_CKDATACKSUMREADS, + 0))) == 0); + #if defined(LFS3_REVNOISE) && defined(LFS3_REVDBG) + // LFS3_M_REVDBG and LFS3_M_REVNOISE are incompatible + LFS3_ASSERT(!lfs3_m_isrevdbg(flags) || !lfs3_m_isrevnoise(flags)); #endif // TODO this all needs to be cleaned up - lfs->cfg = cfg; + lfs3->cfg = cfg; int err = 0; - // validate that the lfs-cfg sizes were initiated properly before + // validate that the lfs3-cfg sizes were initiated properly before // performing any arithmetic logics with them - LFS_ASSERT(lfs->cfg->read_size != 0); - LFS_ASSERT(lfs->cfg->prog_size != 0); - LFS_ASSERT(lfs->cfg->rcache_size != 0); - LFS_ASSERT(lfs->cfg->pcache_size != 0); + LFS3_ASSERT(lfs3->cfg->read_size != 0); + LFS3_ASSERT(lfs3->cfg->prog_size != 0); + LFS3_ASSERT(lfs3->cfg->rcache_size != 0); + LFS3_ASSERT(lfs3->cfg->pcache_size != 0); // cache sizes must be a multiple of their operation sizes - LFS_ASSERT(lfs->cfg->rcache_size % lfs->cfg->read_size == 0); - LFS_ASSERT(lfs->cfg->pcache_size % lfs->cfg->prog_size == 0); + LFS3_ASSERT(lfs3->cfg->rcache_size % lfs3->cfg->read_size == 0); + LFS3_ASSERT(lfs3->cfg->pcache_size % lfs3->cfg->prog_size == 0); // block_size must be a multiple of both prog/read size - LFS_ASSERT(lfs->cfg->block_size % lfs->cfg->read_size == 0); - LFS_ASSERT(lfs->cfg->block_size % lfs->cfg->prog_size == 0); + LFS3_ASSERT(lfs3->cfg->block_size % lfs3->cfg->read_size == 0); + LFS3_ASSERT(lfs3->cfg->block_size % lfs3->cfg->prog_size == 0); // block_size is currently limited to 28-bits - LFS_ASSERT(lfs->cfg->block_size <= 0x0fffffff); + LFS3_ASSERT(lfs3->cfg->block_size <= 0x0fffffff); - #ifdef LFS_GC + #ifdef LFS3_GC // unknown gc flags? - LFS_ASSERT((lfs->cfg->gc_flags & ~( - LFS_GC_MKCONSISTENT - | LFS_GC_LOOKAHEAD - | LFS_GC_COMPACT - | LFS_GC_CKMETA - | LFS_GC_CKDATA)) == 0); + LFS3_ASSERT((lfs3->cfg->gc_flags & ~( + LFS3_GC_MKCONSISTENT + | LFS3_GC_LOOKAHEAD + | LFS3_GC_COMPACT + | LFS3_GC_CKMETA + | LFS3_GC_CKDATA)) == 0); #endif // check that gc_compact_thresh makes sense // // metadata can't be compacted below block_size/2, and metadata can't // exceed a block - LFS_ASSERT(lfs->cfg->gc_compact_thresh == 0 - || lfs->cfg->gc_compact_thresh >= lfs->cfg->block_size/2); - LFS_ASSERT(lfs->cfg->gc_compact_thresh == (lfs_size_t)-1 - || lfs->cfg->gc_compact_thresh <= lfs->cfg->block_size); + LFS3_ASSERT(lfs3->cfg->gc_compact_thresh == 0 + || lfs3->cfg->gc_compact_thresh >= lfs3->cfg->block_size/2); + LFS3_ASSERT(lfs3->cfg->gc_compact_thresh == (lfs3_size_t)-1 + || lfs3->cfg->gc_compact_thresh <= lfs3->cfg->block_size); // inline_size must be <= block_size/4 - LFS_ASSERT(lfs->cfg->inline_size <= lfs->cfg->block_size/4); + LFS3_ASSERT(lfs3->cfg->inline_size <= lfs3->cfg->block_size/4); // fragment_size must be <= block_size/4 - LFS_ASSERT(lfs->cfg->fragment_size <= lfs->cfg->block_size/4); + LFS3_ASSERT(lfs3->cfg->fragment_size <= lfs3->cfg->block_size/4); // fragment_thresh > crystal_thresh is probably a mistake - LFS_ASSERT(lfs->cfg->fragment_thresh == (lfs_size_t)-1 - || lfs->cfg->fragment_thresh <= lfs->cfg->crystal_thresh); + LFS3_ASSERT(lfs3->cfg->fragment_thresh == (lfs3_size_t)-1 + || lfs3->cfg->fragment_thresh <= lfs3->cfg->crystal_thresh); // setup flags - lfs->flags = flags + lfs3->flags = flags // assume we contain orphans until proven otherwise - | LFS_I_MKCONSISTENT + | LFS3_I_MKCONSISTENT // default to an empty lookahead - | LFS_I_LOOKAHEAD + | LFS3_I_LOOKAHEAD // default to assuming we need compaction somewhere, worst case - // this just makes lfsr_fs_gc read more than is strictly needed - | LFS_I_COMPACT + // this just makes lfs3_fs_gc read more than is strictly needed + | LFS3_I_COMPACT // default to needing a ckmeta/ckdata scan - | LFS_I_CKMETA - | LFS_I_CKDATA; + | LFS3_I_CKMETA + | LFS3_I_CKDATA; // copy block_count so we can mutate it - lfs->block_count = lfs->cfg->block_count; + lfs3->block_count = lfs3->cfg->block_count; // setup read cache - lfs->rcache.block = 0; - lfs->rcache.off = 0; - lfs->rcache.size = 0; - if (lfs->cfg->rcache_buffer) { - lfs->rcache.buffer = lfs->cfg->rcache_buffer; + lfs3->rcache.block = 0; + lfs3->rcache.off = 0; + lfs3->rcache.size = 0; + if (lfs3->cfg->rcache_buffer) { + lfs3->rcache.buffer = lfs3->cfg->rcache_buffer; } else { - lfs->rcache.buffer = lfs_malloc(lfs->cfg->rcache_size); - if (!lfs->rcache.buffer) { - err = LFS_ERR_NOMEM; + lfs3->rcache.buffer = lfs3_malloc(lfs3->cfg->rcache_size); + if (!lfs3->rcache.buffer) { + err = LFS3_ERR_NOMEM; goto failed; } } // setup program cache - lfs->pcache.block = 0; - lfs->pcache.off = 0; - lfs->pcache.size = 0; - if (lfs->cfg->pcache_buffer) { - lfs->pcache.buffer = lfs->cfg->pcache_buffer; + lfs3->pcache.block = 0; + lfs3->pcache.off = 0; + lfs3->pcache.size = 0; + if (lfs3->cfg->pcache_buffer) { + lfs3->pcache.buffer = lfs3->cfg->pcache_buffer; } else { - lfs->pcache.buffer = lfs_malloc(lfs->cfg->pcache_size); - if (!lfs->pcache.buffer) { - err = LFS_ERR_NOMEM; + lfs3->pcache.buffer = lfs3_malloc(lfs3->cfg->pcache_size); + if (!lfs3->pcache.buffer) { + err = LFS3_ERR_NOMEM; goto failed; } } - #ifdef LFS_CKMETAPARITY + #ifdef LFS3_CKMETAPARITY // setup ptail, nothing should actually check off=0 - lfs->ptail.block = 0; - lfs->ptail.off = 0; + lfs3->ptail.block = 0; + lfs3->ptail.off = 0; #endif // setup lookahead buffer, note mount finishes initializing this after // we establish a decent pseudo-random seed - LFS_ASSERT(lfs->cfg->lookahead_size > 0); - if (lfs->cfg->lookahead_buffer) { - lfs->lookahead.buffer = lfs->cfg->lookahead_buffer; + LFS3_ASSERT(lfs3->cfg->lookahead_size > 0); + if (lfs3->cfg->lookahead_buffer) { + lfs3->lookahead.buffer = lfs3->cfg->lookahead_buffer; } else { - lfs->lookahead.buffer = lfs_malloc(lfs->cfg->lookahead_size); - if (!lfs->lookahead.buffer) { - err = LFS_ERR_NOMEM; + lfs3->lookahead.buffer = lfs3_malloc(lfs3->cfg->lookahead_size); + if (!lfs3->lookahead.buffer) { + err = LFS3_ERR_NOMEM; goto failed; } } - lfs->lookahead.window = 0; - lfs->lookahead.off = 0; - lfs->lookahead.size = 0; - lfs->lookahead.ckpoint = 0; - lfs_alloc_discard(lfs); + lfs3->lookahead.window = 0; + lfs3->lookahead.off = 0; + lfs3->lookahead.size = 0; + lfs3->lookahead.ckpoint = 0; + lfs3_alloc_discard(lfs3); // check that the size limits are sane - LFS_ASSERT(lfs->cfg->name_limit <= LFS_NAME_MAX); - lfs->name_limit = lfs->cfg->name_limit; - if (!lfs->name_limit) { - lfs->name_limit = LFS_NAME_MAX; + LFS3_ASSERT(lfs3->cfg->name_limit <= LFS3_NAME_MAX); + lfs3->name_limit = lfs3->cfg->name_limit; + if (!lfs3->name_limit) { + lfs3->name_limit = LFS3_NAME_MAX; } - LFS_ASSERT(lfs->cfg->file_limit <= LFS_FILE_MAX); - lfs->file_limit = lfs->cfg->file_limit; - if (!lfs->file_limit) { - lfs->file_limit = LFS_FILE_MAX; + LFS3_ASSERT(lfs3->cfg->file_limit <= LFS3_FILE_MAX); + lfs3->file_limit = lfs3->cfg->file_limit; + if (!lfs3->file_limit) { + lfs3->file_limit = LFS3_FILE_MAX; } // TODO do we need to recalculate these after mount? @@ -13613,12 +13617,12 @@ static int lfs_init(lfs_t *lfs, uint32_t flags, // alternate which metadata block we erase each compaction, and limit // to 28-bits so we always have some bits to determine the most recent // revision. - if (lfs->cfg->block_recycles != -1) { - lfs->recycle_bits = lfs_min( - lfs_nlog2(2*(lfs->cfg->block_recycles+1)+1)-1, + if (lfs3->cfg->block_recycles != -1) { + lfs3->recycle_bits = lfs3_min( + lfs3_nlog2(2*(lfs3->cfg->block_recycles+1)+1)-1, 28); } else { - lfs->recycle_bits = -1; + lfs3->recycle_bits = -1; } // calculate the upper-bound cost of a single rbyd attr after compaction @@ -13651,15 +13655,15 @@ static int lfs_init(lfs_t *lfs, uint32_t flags, // // t = 2 + log128(file_limit+1) + log128(block_size) // - // Note this is different from LFSR_TAG_DSIZE, which is the worst case + // Note this is different from LFS3_TAG_DSIZE, which is the worst case // tag encoding at compile-time. // uint8_t tag_estimate = 2 - + (lfs_nlog2(lfs->file_limit+1)+7-1)/7 - + (lfs_nlog2(lfs->cfg->block_size)+7-1)/7; - LFS_ASSERT(tag_estimate <= LFSR_TAG_DSIZE); - lfs->rattr_estimate = 3*tag_estimate + 4; + + (lfs3_nlog2(lfs3->file_limit+1)+7-1)/7 + + (lfs3_nlog2(lfs3->cfg->block_size)+7-1)/7; + LFS3_ASSERT(tag_estimate <= LFS3_TAG_DSIZE); + lfs3->rattr_estimate = 3*tag_estimate + 4; // calculate the upper-bound cost of a single mdir attr after compaction // @@ -13668,9 +13672,9 @@ static int lfs_init(lfs_t *lfs, uint32_t flags, tag_estimate = 2 + 1 - + (lfs_nlog2(lfs->cfg->block_size)+7-1)/7; - LFS_ASSERT(tag_estimate <= LFSR_TAG_DSIZE); - lfs->mattr_estimate = 3*tag_estimate + 4; + + (lfs3_nlog2(lfs3->cfg->block_size)+7-1)/7; + LFS3_ASSERT(tag_estimate <= LFS3_TAG_DSIZE); + lfs3->mattr_estimate = 3*tag_estimate + 4; // calculate the number of bits we need to reserve for mdir rids // @@ -13708,40 +13712,40 @@ static int lfs_init(lfs_t *lfs, uint32_t flags, // metadata entries per block. But we intentionally don't leverage this // to maintain compatibility with a theoretical perfect implementation. // - lfs->mbits = lfs_nlog2(lfs->cfg->block_size) - 3; + lfs3->mbits = lfs3_nlog2(lfs3->cfg->block_size) - 3; // zero linked-list of opened mdirs - lfs->omdirs = NULL; + lfs3->omdirs = NULL; // zero gstate - lfs->gcksum = 0; - lfs->gcksum_p = 0; - lfs->gcksum_d = 0; + lfs3->gcksum = 0; + lfs3->gcksum_p = 0; + lfs3->gcksum_d = 0; - lfs->grm.queue[0] = -1; - lfs->grm.queue[1] = -1; - lfs_memset(lfs->grm_p, 0, LFSR_GRM_DSIZE); - lfs_memset(lfs->grm_d, 0, LFSR_GRM_DSIZE); + lfs3->grm.queue[0] = -1; + lfs3->grm.queue[1] = -1; + lfs3_memset(lfs3->grm_p, 0, LFS3_GRM_DSIZE); + lfs3_memset(lfs3->grm_d, 0, LFS3_GRM_DSIZE); return 0; failed:; - lfs_deinit(lfs); + lfs3_deinit(lfs3); return err; } -static int lfs_deinit(lfs_t *lfs) { +static int lfs3_deinit(lfs3_t *lfs3) { // free allocated memory - if (!lfs->cfg->rcache_buffer) { - lfs_free(lfs->rcache.buffer); + if (!lfs3->cfg->rcache_buffer) { + lfs3_free(lfs3->rcache.buffer); } - if (!lfs->cfg->pcache_buffer) { - lfs_free(lfs->pcache.buffer); + if (!lfs3->cfg->pcache_buffer) { + lfs3_free(lfs3->pcache.buffer); } - if (!lfs->cfg->lookahead_buffer) { - lfs_free(lfs->lookahead.buffer); + if (!lfs3->cfg->lookahead_buffer) { + lfs3_free(lfs3->lookahead.buffer); } return 0; @@ -13759,81 +13763,81 @@ static int lfs_deinit(lfs_t *lfs) { // // note, "understanding" does not necessarily mean support // -#define LFSR_RCOMPAT_NONSTANDARD 0x00000001 // Non-standard filesystem format -#define LFSR_RCOMPAT_WRONLY 0x00000002 // Reading is disallowed -#define LFSR_RCOMPAT_BMOSS 0x00000010 // Files may use inlined data -#define LFSR_RCOMPAT_BSPROUT 0x00000020 // Files may use block pointers -#define LFSR_RCOMPAT_BSHRUB 0x00000040 // Files may use inlined btrees -#define LFSR_RCOMPAT_BTREE 0x00000080 // Files may use btrees -#define LFSR_RCOMPAT_MMOSS 0x00000100 // May use an inlined mdir -#define LFSR_RCOMPAT_MSPROUT 0x00000200 // May use an mdir pointer -#define LFSR_RCOMPAT_MSHRUB 0x00000400 // May use an inlined mtree -#define LFSR_RCOMPAT_MTREE 0x00000800 // May use an mtree -#define LFSR_RCOMPAT_GRM 0x00001000 // Global-remove in use +#define LFS3_RCOMPAT_NONSTANDARD 0x00000001 // Non-standard filesystem format +#define LFS3_RCOMPAT_WRONLY 0x00000002 // Reading is disallowed +#define LFS3_RCOMPAT_BMOSS 0x00000010 // Files may use inlined data +#define LFS3_RCOMPAT_BSPROUT 0x00000020 // Files may use block pointers +#define LFS3_RCOMPAT_BSHRUB 0x00000040 // Files may use inlined btrees +#define LFS3_RCOMPAT_BTREE 0x00000080 // Files may use btrees +#define LFS3_RCOMPAT_MMOSS 0x00000100 // May use an inlined mdir +#define LFS3_RCOMPAT_MSPROUT 0x00000200 // May use an mdir pointer +#define LFS3_RCOMPAT_MSHRUB 0x00000400 // May use an inlined mtree +#define LFS3_RCOMPAT_MTREE 0x00000800 // May use an mtree +#define LFS3_RCOMPAT_GRM 0x00001000 // Global-remove in use // internal -#define LFSR_rcompat_OVERFLOW 0x80000000 // Can't represent all flags +#define LFS3_rcompat_OVERFLOW 0x80000000 // Can't represent all flags -#define LFSR_RCOMPAT_COMPAT \ - (LFSR_RCOMPAT_BSHRUB \ - | LFSR_RCOMPAT_BTREE \ - | LFSR_RCOMPAT_MMOSS \ - | LFSR_RCOMPAT_MTREE \ - | LFSR_RCOMPAT_GRM) +#define LFS3_RCOMPAT_COMPAT \ + (LFS3_RCOMPAT_BSHRUB \ + | LFS3_RCOMPAT_BTREE \ + | LFS3_RCOMPAT_MMOSS \ + | LFS3_RCOMPAT_MTREE \ + | LFS3_RCOMPAT_GRM) -#define LFSR_WCOMPAT_NONSTANDARD 0x00000001 // Non-standard filesystem format -#define LFSR_WCOMPAT_RDONLY 0x00000002 // Writing is disallowed -#define LFSR_WCOMPAT_DIR 0x00000010 // Directory files in use -#define LFSR_WCOMPAT_GCKSUM 0x00001000 // Global-checksum in use +#define LFS3_WCOMPAT_NONSTANDARD 0x00000001 // Non-standard filesystem format +#define LFS3_WCOMPAT_RDONLY 0x00000002 // Writing is disallowed +#define LFS3_WCOMPAT_DIR 0x00000010 // Directory files in use +#define LFS3_WCOMPAT_GCKSUM 0x00001000 // Global-checksum in use // internal -#define LFSR_wcompat_OVERFLOW 0x80000000 // Can't represent all flags +#define LFS3_wcompat_OVERFLOW 0x80000000 // Can't represent all flags -#define LFSR_WCOMPAT_COMPAT \ - (LFSR_WCOMPAT_DIR \ - | LFSR_WCOMPAT_GCKSUM) +#define LFS3_WCOMPAT_COMPAT \ + (LFS3_WCOMPAT_DIR \ + | LFS3_WCOMPAT_GCKSUM) -#define LFSR_OCOMPAT_NONSTANDARD 0x00000001 // Non-standard filesystem format +#define LFS3_OCOMPAT_NONSTANDARD 0x00000001 // Non-standard filesystem format // internal -#define LFSR_ocompat_OVERFLOW 0x80000000 // Can't represent all flags +#define LFS3_ocompat_OVERFLOW 0x80000000 // Can't represent all flags -#define LFSR_OCOMPAT_COMPAT 0 +#define LFS3_OCOMPAT_COMPAT 0 -typedef uint32_t lfsr_rcompat_t; -typedef uint32_t lfsr_wcompat_t; -typedef uint32_t lfsr_ocompat_t; +typedef uint32_t lfs3_rcompat_t; +typedef uint32_t lfs3_wcompat_t; +typedef uint32_t lfs3_ocompat_t; -static inline bool lfsr_rcompat_isincompat(lfsr_rcompat_t rcompat) { - return rcompat != LFSR_RCOMPAT_COMPAT; +static inline bool lfs3_rcompat_isincompat(lfs3_rcompat_t rcompat) { + return rcompat != LFS3_RCOMPAT_COMPAT; } -static inline bool lfsr_wcompat_isincompat(lfsr_wcompat_t wcompat) { - return wcompat != LFSR_WCOMPAT_COMPAT; +static inline bool lfs3_wcompat_isincompat(lfs3_wcompat_t wcompat) { + return wcompat != LFS3_WCOMPAT_COMPAT; } -static inline bool lfsr_ocompat_isincompat(lfsr_ocompat_t ocompat) { - return ocompat != LFSR_OCOMPAT_COMPAT; +static inline bool lfs3_ocompat_isincompat(lfs3_ocompat_t ocompat) { + return ocompat != LFS3_OCOMPAT_COMPAT; } // compat flags on-disk encoding // // little-endian, truncated bits must be assumed zero -static int lfsr_data_readcompat(lfs_t *lfs, lfsr_data_t *data, +static int lfs3_data_readcompat(lfs3_t *lfs3, lfs3_data_t *data, uint32_t *compat) { // allow truncated compat flags uint8_t buf[4] = {0}; - lfs_ssize_t d = lfsr_data_read(lfs, data, buf, 4); + lfs3_ssize_t d = lfs3_data_read(lfs3, data, buf, 4); if (d < 0) { return d; } - *compat = lfs_fromle32(buf); + *compat = lfs3_fromle32(buf); // if any out-of-range flags are set, set the internal overflow bit, // this is a compromise in correctness and and compat-flag complexity // // we don't really care about performance here - while (lfsr_data_size(*data) > 0) { + while (lfs3_data_size(*data) > 0) { uint8_t b; - lfs_ssize_t d = lfsr_data_read(lfs, data, &b, 1); + lfs3_ssize_t d = lfs3_data_read(lfs3, data, &b, 1); if (d < 0) { return d; } @@ -13849,57 +13853,57 @@ static int lfsr_data_readcompat(lfs_t *lfs, lfsr_data_t *data, // all the compat parsing is basically the same, so try to reuse code -static inline int lfsr_data_readrcompat(lfs_t *lfs, lfsr_data_t *data, - lfsr_rcompat_t *rcompat) { - return lfsr_data_readcompat(lfs, data, rcompat); +static inline int lfs3_data_readrcompat(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_rcompat_t *rcompat) { + return lfs3_data_readcompat(lfs3, data, rcompat); } -static inline int lfsr_data_readwcompat(lfs_t *lfs, lfsr_data_t *data, - lfsr_wcompat_t *wcompat) { - return lfsr_data_readcompat(lfs, data, wcompat); +static inline int lfs3_data_readwcompat(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_wcompat_t *wcompat) { + return lfs3_data_readcompat(lfs3, data, wcompat); } -static inline int lfsr_data_readocompat(lfs_t *lfs, lfsr_data_t *data, - lfsr_ocompat_t *ocompat) { - return lfsr_data_readcompat(lfs, data, ocompat); +static inline int lfs3_data_readocompat(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_ocompat_t *ocompat) { + return lfs3_data_readcompat(lfs3, data, ocompat); } // disk geometry // // note these are stored minus 1 to avoid overflow issues -struct lfsr_geometry { - lfs_off_t block_size; - lfs_off_t block_count; +struct lfs3_geometry { + lfs3_off_t block_size; + lfs3_off_t block_count; }; // geometry on-disk encoding -static lfsr_data_t lfsr_data_fromgeometry(const lfsr_geometry_t *geometry, - uint8_t buffer[static LFSR_GEOMETRY_DSIZE]) { - lfs_ssize_t d = 0; - lfs_ssize_t d_ = lfs_toleb128(geometry->block_size-1, &buffer[d], 4); +static lfs3_data_t lfs3_data_fromgeometry(const lfs3_geometry_t *geometry, + uint8_t buffer[static LFS3_GEOMETRY_DSIZE]) { + lfs3_ssize_t d = 0; + lfs3_ssize_t d_ = lfs3_toleb128(geometry->block_size-1, &buffer[d], 4); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - d_ = lfs_toleb128(geometry->block_count-1, &buffer[d], 5); + d_ = lfs3_toleb128(geometry->block_count-1, &buffer[d], 5); if (d_ < 0) { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } d += d_; - return LFSR_DATA_BUF(buffer, d); + return LFS3_DATA_BUF(buffer, d); } -static int lfsr_data_readgeometry(lfs_t *lfs, lfsr_data_t *data, - lfsr_geometry_t *geometry) { - int err = lfsr_data_readlleb128(lfs, data, &geometry->block_size); +static int lfs3_data_readgeometry(lfs3_t *lfs3, lfs3_data_t *data, + lfs3_geometry_t *geometry) { + int err = lfs3_data_readlleb128(lfs3, data, &geometry->block_size); if (err) { return err; } - err = lfsr_data_readleb128(lfs, data, &geometry->block_count); + err = lfs3_data_readleb128(lfs3, data, &geometry->block_count); if (err) { return err; } @@ -13909,77 +13913,77 @@ static int lfsr_data_readgeometry(lfs_t *lfs, lfsr_data_t *data, return 0; } -static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) { +static int lfs3_mountmroot(lfs3_t *lfs3, const lfs3_mdir_t *mroot) { // check the disk version uint8_t version[2] = {0, 0}; - lfsr_data_t data; - int err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_VERSION, + lfs3_data_t data; + int err = lfs3_mdir_lookup(lfs3, mroot, LFS3_TAG_VERSION, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - lfs_ssize_t d = lfsr_data_read(lfs, &data, version, 2); + if (err != LFS3_ERR_NOENT) { + lfs3_ssize_t d = lfs3_data_read(lfs3, &data, version, 2); if (d < 0) { return err; } } - if (version[0] != LFS_DISK_VERSION_MAJOR - || version[1] > LFS_DISK_VERSION_MINOR) { - LFS_ERROR("Incompatible version v%"PRId32".%"PRId32" " + if (version[0] != LFS3_DISK_VERSION_MAJOR + || version[1] > LFS3_DISK_VERSION_MINOR) { + LFS3_ERROR("Incompatible version v%"PRId32".%"PRId32" " "(!= v%"PRId32".%"PRId32")", version[0], version[1], - LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR); - return LFS_ERR_NOTSUP; + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR); + return LFS3_ERR_NOTSUP; } // check for any rcompatflags, we must understand these to read // the filesystem - lfsr_rcompat_t rcompat = 0; - err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_RCOMPAT, + lfs3_rcompat_t rcompat = 0; + err = lfs3_mdir_lookup(lfs3, mroot, LFS3_TAG_RCOMPAT, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - err = lfsr_data_readrcompat(lfs, &data, &rcompat); + if (err != LFS3_ERR_NOENT) { + err = lfs3_data_readrcompat(lfs3, &data, &rcompat); if (err) { return err; } } - if (lfsr_rcompat_isincompat(rcompat)) { - LFS_ERROR("Incompatible rcompat flags 0x%0"PRIx32" (!= 0x%0"PRIx32")", + if (lfs3_rcompat_isincompat(rcompat)) { + LFS3_ERROR("Incompatible rcompat flags 0x%0"PRIx32" (!= 0x%0"PRIx32")", rcompat, - LFSR_RCOMPAT_COMPAT); - return LFS_ERR_NOTSUP; + LFS3_RCOMPAT_COMPAT); + return LFS3_ERR_NOTSUP; } // check for any wcompatflags, we must understand these to write // the filesystem - lfsr_wcompat_t wcompat = 0; - err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_WCOMPAT, + lfs3_wcompat_t wcompat = 0; + err = lfs3_mdir_lookup(lfs3, mroot, LFS3_TAG_WCOMPAT, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - err = lfsr_data_readwcompat(lfs, &data, &wcompat); + if (err != LFS3_ERR_NOENT) { + err = lfs3_data_readwcompat(lfs3, &data, &wcompat); if (err) { return err; } } - if (lfsr_wcompat_isincompat(wcompat)) { - LFS_WARN("Incompatible wcompat flags 0x%0"PRIx32" (!= 0x%0"PRIx32")", + if (lfs3_wcompat_isincompat(wcompat)) { + LFS3_WARN("Incompatible wcompat flags 0x%0"PRIx32" (!= 0x%0"PRIx32")", wcompat, - LFSR_WCOMPAT_COMPAT); + LFS3_WCOMPAT_COMPAT); // we can continue if rdonly - if (!lfsr_m_isrdonly(lfs->flags)) { - return LFS_ERR_NOTSUP; + if (!lfs3_m_isrdonly(lfs3->flags)) { + return LFS3_ERR_NOTSUP; } } @@ -13987,183 +13991,183 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) { // ignore these anyways // check the on-disk geometry - lfsr_geometry_t geometry; - err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_GEOMETRY, + lfs3_geometry_t geometry; + err = lfs3_mdir_lookup(lfs3, mroot, LFS3_TAG_GEOMETRY, NULL, &data); if (err) { - if (err == LFS_ERR_NOENT) { - LFS_ERROR("No geometry found"); - return LFS_ERR_INVAL; + if (err == LFS3_ERR_NOENT) { + LFS3_ERROR("No geometry found"); + return LFS3_ERR_INVAL; } return err; } - err = lfsr_data_readgeometry(lfs, &data, &geometry); + err = lfs3_data_readgeometry(lfs3, &data, &geometry); if (err) { return err; } // either block_size matches or it doesn't, we don't support variable // block_sizes - if (geometry.block_size != lfs->cfg->block_size) { - LFS_ERROR("Incompatible block size %"PRId32" (!= %"PRId32")", + if (geometry.block_size != lfs3->cfg->block_size) { + LFS3_ERROR("Incompatible block size %"PRId32" (!= %"PRId32")", geometry.block_size, - lfs->cfg->block_size); - return LFS_ERR_NOTSUP; + lfs3->cfg->block_size); + return LFS3_ERR_NOTSUP; } // on-disk block_count must be <= configured block_count - if (geometry.block_count > lfs->cfg->block_count) { - LFS_ERROR("Incompatible block count %"PRId32" (> %"PRId32")", + if (geometry.block_count > lfs3->cfg->block_count) { + LFS3_ERROR("Incompatible block count %"PRId32" (> %"PRId32")", geometry.block_count, - lfs->cfg->block_count); - return LFS_ERR_NOTSUP; + lfs3->cfg->block_count); + return LFS3_ERR_NOTSUP; } - lfs->block_count = geometry.block_count; + lfs3->block_count = geometry.block_count; // read the name limit - lfs_size_t name_limit = 0xff; - err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_NAMELIMIT, + lfs3_size_t name_limit = 0xff; + err = lfs3_mdir_lookup(lfs3, mroot, LFS3_TAG_NAMELIMIT, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - err = lfsr_data_readleb128(lfs, &data, &name_limit); - if (err && err != LFS_ERR_CORRUPT) { + if (err != LFS3_ERR_NOENT) { + err = lfs3_data_readleb128(lfs3, &data, &name_limit); + if (err && err != LFS3_ERR_CORRUPT) { return err; } - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { name_limit = -1; } } - if (name_limit > lfs->name_limit) { - LFS_ERROR("Incompatible name limit %"PRId32" (> %"PRId32")", + if (name_limit > lfs3->name_limit) { + LFS3_ERROR("Incompatible name limit %"PRId32" (> %"PRId32")", name_limit, - lfs->name_limit); - return LFS_ERR_NOTSUP; + lfs3->name_limit); + return LFS3_ERR_NOTSUP; } - lfs->name_limit = name_limit; + lfs3->name_limit = name_limit; // read the file limit - lfs_off_t file_limit = 0x7fffffff; - err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_FILELIMIT, + lfs3_off_t file_limit = 0x7fffffff; + err = lfs3_mdir_lookup(lfs3, mroot, LFS3_TAG_FILELIMIT, NULL, &data); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT) { - err = lfsr_data_readleb128(lfs, &data, &file_limit); - if (err && err != LFS_ERR_CORRUPT) { + if (err != LFS3_ERR_NOENT) { + err = lfs3_data_readleb128(lfs3, &data, &file_limit); + if (err && err != LFS3_ERR_CORRUPT) { return err; } - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { file_limit = -1; } } - if (file_limit > lfs->file_limit) { - LFS_ERROR("Incompatible file limit %"PRId32" (> %"PRId32")", + if (file_limit > lfs3->file_limit) { + LFS3_ERROR("Incompatible file limit %"PRId32" (> %"PRId32")", file_limit, - lfs->file_limit); - return LFS_ERR_NOTSUP; + lfs3->file_limit); + return LFS3_ERR_NOTSUP; } - lfs->file_limit = file_limit; + lfs3->file_limit = file_limit; // check for unknown configs - lfsr_tag_t tag; - err = lfsr_mdir_lookupnext(lfs, mroot, LFSR_TAG_UNKNOWNCONFIG, + lfs3_tag_t tag; + err = lfs3_mdir_lookupnext(lfs3, mroot, LFS3_TAG_UNKNOWNCONFIG, &tag, NULL); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err != LFS_ERR_NOENT - && lfsr_tag_suptype(tag) == LFSR_TAG_CONFIG) { - LFS_ERROR("Unknown config 0x%04"PRIx16, + if (err != LFS3_ERR_NOENT + && lfs3_tag_suptype(tag) == LFS3_TAG_CONFIG) { + LFS3_ERROR("Unknown config 0x%04"PRIx16, tag); - return LFS_ERR_NOTSUP; + return LFS3_ERR_NOTSUP; } return 0; } -static int lfsr_mountinited(lfs_t *lfs) { - // mark mroot as invalid to prevent lfsr_mtree_traverse from getting +static int lfs3_mountinited(lfs3_t *lfs3) { + // mark mroot as invalid to prevent lfs3_mtree_traverse from getting // confused - lfs->mroot.mid = -1; - lfs->mroot.rbyd.blocks[0] = -1; - lfs->mroot.rbyd.blocks[1] = -1; + lfs3->mroot.mid = -1; + lfs3->mroot.rbyd.blocks[0] = -1; + lfs3->mroot.rbyd.blocks[1] = -1; // default to no mtree, this is allowed and implies all files are inlined // in the mroot - lfsr_btree_init(&lfs->mtree); + lfs3_btree_init(&lfs3->mtree); // zero gcksum/gdeltas, we'll read these from our mdirs - lfs->gcksum = 0; - lfsr_fs_flushgdelta(lfs); + lfs3->gcksum = 0; + lfs3_fs_flushgdelta(lfs3); // traverse the mtree rooted at mroot 0x{1,0} // // we do validate btree inner nodes here, how can we trust our // mdirs are valid if we haven't checked the btree inner nodes at // least once? - lfsr_traversal_t t; - lfsr_traversal_init(&t, LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA); + lfs3_traversal_t t; + lfs3_traversal_init(&t, LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA); while (true) { - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(lfs3, &t, &tag, &bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; } // found an mdir? - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; // found an mroot? if (mdir->mid == -1) { // check for the magic string, all mroot should have this - lfsr_data_t data; - err = lfsr_mdir_lookup(lfs, mdir, LFSR_TAG_MAGIC, + lfs3_data_t data; + err = lfs3_mdir_lookup(lfs3, mdir, LFS3_TAG_MAGIC, NULL, &data); if (err) { - if (err == LFS_ERR_NOENT) { - LFS_ERROR("No littlefs magic found"); - return LFS_ERR_CORRUPT; + if (err == LFS3_ERR_NOENT) { + LFS3_ERROR("No littlefs magic found"); + return LFS3_ERR_CORRUPT; } return err; } // treat corrupted magic as no magic - lfs_scmp_t cmp = lfsr_data_cmp(lfs, data, "littlefs", 8); + lfs3_scmp_t cmp = lfs3_data_cmp(lfs3, data, "littlefs", 8); if (cmp < 0) { return cmp; } - if (cmp != LFS_CMP_EQ) { - LFS_ERROR("No littlefs magic found"); - return LFS_ERR_CORRUPT; + if (cmp != LFS3_CMP_EQ) { + LFS3_ERROR("No littlefs magic found"); + return LFS3_ERR_CORRUPT; } // are we the last mroot? - err = lfsr_mdir_lookup(lfs, mdir, LFSR_TAG_MROOT, + err = lfs3_mdir_lookup(lfs3, mdir, LFS3_TAG_MROOT, NULL, NULL); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { // track active mroot - lfs->mroot = *mdir; + lfs3->mroot = *mdir; // mount/validate config in active mroot - err = lfsr_mountmroot(lfs, &lfs->mroot); + err = lfs3_mountmroot(lfs3, &lfs3->mroot); if (err) { return err; } @@ -14171,24 +14175,24 @@ static int lfsr_mountinited(lfs_t *lfs) { } // build gcksum out of mdir cksums - lfs->gcksum ^= mdir->rbyd.cksum; + lfs3->gcksum ^= mdir->rbyd.cksum; // collect any gdeltas from this mdir - err = lfsr_fs_consumegdelta(lfs, mdir); + err = lfs3_fs_consumegdelta(lfs3, mdir); if (err) { return err; } // found an mtree inner-node? - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; // found the root of the mtree? keep track of this - if (lfs->mtree.weight == 0) { - lfs->mtree = *rbyd; + if (lfs3->mtree.weight == 0) { + lfs3->mtree = *rbyd; } } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } @@ -14217,16 +14221,16 @@ static int lfsr_mountinited(lfs_t *lfs) { // 1->1 mapping of t(g) in 2^31 fields, and losing at most 3-bits of // info when calculating d_i. // - if (lfs_crc32c_cube(lfs->gcksum) != lfs->gcksum_d) { - LFS_ERROR("Found gcksum mismatch, cksum^3 %08"PRIx32" " + if (lfs3_crc32c_cube(lfs3->gcksum) != lfs3->gcksum_d) { + LFS3_ERROR("Found gcksum mismatch, cksum^3 %08"PRIx32" " "(!= %08"PRIx32")", - lfs_crc32c_cube(lfs->gcksum), - lfs->gcksum_d); - return LFS_ERR_CORRUPT; + lfs3_crc32c_cube(lfs3->gcksum), + lfs3->gcksum_d); + return LFS3_ERR_CORRUPT; } // keep track of the current gcksum - lfs->gcksum_p = lfs->gcksum; + lfs3->gcksum_p = lfs3->gcksum; // once we've mounted and derived a pseudo-random seed, initialize our // block allocator @@ -14234,144 +14238,144 @@ static int lfsr_mountinited(lfs_t *lfs) { // the purpose of this is to avoid bad wear patterns such as always // allocating blocks near the beginning of disk after a power-loss // - lfs->lookahead.window = lfs->gcksum % lfs->block_count; + lfs3->lookahead.window = lfs3->gcksum % lfs3->block_count; // TODO should the consumegdelta above take gstate/gdelta as a parameter? // keep track of the current gstate on disk - lfs_memcpy(lfs->grm_p, lfs->grm_d, LFSR_GRM_DSIZE); + lfs3_memcpy(lfs3->grm_p, lfs3->grm_d, LFS3_GRM_DSIZE); // decode grm so we can report any removed files as missing - int err = lfsr_data_readgrm(lfs, - &LFSR_DATA_BUF(lfs->grm_p, LFSR_GRM_DSIZE)); + int err = lfs3_data_readgrm(lfs3, + &LFS3_DATA_BUF(lfs3->grm_p, LFS3_GRM_DSIZE)); if (err) { // TODO switch to read-only? return err; } // found pending grms? this should only happen if we lost power - if (lfsr_grm_count(lfs) == 2) { - LFS_INFO("Found pending grm %"PRId32".%"PRId32" %"PRId32".%"PRId32, - lfsr_dbgmbid(lfs, lfs->grm.queue[0]), - lfsr_dbgmrid(lfs, lfs->grm.queue[0]), - lfsr_dbgmbid(lfs, lfs->grm.queue[1]), - lfsr_dbgmrid(lfs, lfs->grm.queue[1])); - } else if (lfsr_grm_count(lfs) == 1) { - LFS_INFO("Found pending grm %"PRId32".%"PRId32, - lfsr_dbgmbid(lfs, lfs->grm.queue[0]), - lfsr_dbgmrid(lfs, lfs->grm.queue[0])); + if (lfs3_grm_count(lfs3) == 2) { + LFS3_INFO("Found pending grm %"PRId32".%"PRId32" %"PRId32".%"PRId32, + lfs3_dbgmbid(lfs3, lfs3->grm.queue[0]), + lfs3_dbgmrid(lfs3, lfs3->grm.queue[0]), + lfs3_dbgmbid(lfs3, lfs3->grm.queue[1]), + lfs3_dbgmrid(lfs3, lfs3->grm.queue[1])); + } else if (lfs3_grm_count(lfs3) == 1) { + LFS3_INFO("Found pending grm %"PRId32".%"PRId32, + lfs3_dbgmbid(lfs3, lfs3->grm.queue[0]), + lfs3_dbgmrid(lfs3, lfs3->grm.queue[0])); } return 0; } -// needed in lfsr_mount -static int lfsr_fs_gc_(lfs_t *lfs, lfsr_traversal_t *t, - uint32_t flags, lfs_soff_t steps); +// needed in lfs3_mount +static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, + uint32_t flags, lfs3_soff_t steps); -int lfsr_mount(lfs_t *lfs, uint32_t flags, - const struct lfs_config *cfg) { - #ifdef LFS_YES_RDONLY - flags |= LFS_M_RDONLY; +int lfs3_mount(lfs3_t *lfs3, uint32_t flags, + const struct lfs3_config *cfg) { + #ifdef LFS3_YES_RDONLY + flags |= LFS3_M_RDONLY; #endif - #ifdef LFS_YES_FLUSH - flags |= LFS_M_FLUSH; + #ifdef LFS3_YES_FLUSH + flags |= LFS3_M_FLUSH; #endif - #ifdef LFS_YES_SYNC - flags |= LFS_M_SYNC; + #ifdef LFS3_YES_SYNC + flags |= LFS3_M_SYNC; #endif - #ifdef LFS_YES_REVDBG - flags |= LFS_M_REVDBG; + #ifdef LFS3_YES_REVDBG + flags |= LFS3_M_REVDBG; #endif - #ifdef LFS_YES_REVNOISE - flags |= LFS_M_REVNOISE; + #ifdef LFS3_YES_REVNOISE + flags |= LFS3_M_REVNOISE; #endif - #ifdef LFS_YES_CKPROGS - flags |= LFS_M_CKPROGS; + #ifdef LFS3_YES_CKPROGS + flags |= LFS3_M_CKPROGS; #endif - #ifdef LFS_YES_CKFETCHES - flags |= LFS_M_CKFETCHES; + #ifdef LFS3_YES_CKFETCHES + flags |= LFS3_M_CKFETCHES; #endif - #ifdef LFS_YES_CKMETAPARITY - flags |= LFS_M_CKMETAPARITY; + #ifdef LFS3_YES_CKMETAPARITY + flags |= LFS3_M_CKMETAPARITY; #endif - #ifdef LFS_YES_CKDATACKSUMREADS - flags |= LFS_M_CKDATACKSUMREADS; + #ifdef LFS3_YES_CKDATACKSUMREADS + flags |= LFS3_M_CKDATACKSUMREADS; #endif - #ifdef LFS_YES_MKCONSISTENT - flags |= LFS_M_MKCONSISTENT; + #ifdef LFS3_YES_MKCONSISTENT + flags |= LFS3_M_MKCONSISTENT; #endif - #ifdef LFS_YES_LOOKAHEAD - flags |= LFS_M_LOOKAHEAD; + #ifdef LFS3_YES_LOOKAHEAD + flags |= LFS3_M_LOOKAHEAD; #endif - #ifdef LFS_YES_COMPACT - flags |= LFS_M_COMPACT; + #ifdef LFS3_YES_COMPACT + flags |= LFS3_M_COMPACT; #endif - #ifdef LFS_YES_CKMETA - flags |= LFS_M_CKMETA; + #ifdef LFS3_YES_CKMETA + flags |= LFS3_M_CKMETA; #endif - #ifdef LFS_YES_CKDATA - flags |= LFS_M_CKDATA + #ifdef LFS3_YES_CKDATA + flags |= LFS3_M_CKDATA #endif // unknown flags? - LFS_ASSERT((flags & ~( - LFS_M_RDWR - | LFS_M_RDONLY - | LFS_M_FLUSH - | LFS_M_SYNC - | LFS_IFDEF_REVDBG(LFS_M_REVDBG, 0) - | LFS_IFDEF_REVNOISE(LFS_M_REVNOISE, 0) - | LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, 0) - | LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, 0) - | LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, 0) - | LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, 0) - | LFS_M_MKCONSISTENT - | LFS_M_LOOKAHEAD - | LFS_M_COMPACT - | LFS_M_CKMETA - | LFS_M_CKDATA)) == 0); + LFS3_ASSERT((flags & ~( + LFS3_M_RDWR + | LFS3_M_RDONLY + | LFS3_M_FLUSH + | LFS3_M_SYNC + | LFS3_IFDEF_REVDBG(LFS3_M_REVDBG, 0) + | LFS3_IFDEF_REVNOISE(LFS3_M_REVNOISE, 0) + | LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, 0) + | LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, 0) + | LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, 0) + | LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, 0) + | LFS3_M_MKCONSISTENT + | LFS3_M_LOOKAHEAD + | LFS3_M_COMPACT + | LFS3_M_CKMETA + | LFS3_M_CKDATA)) == 0); // these flags require a writable filesystem - LFS_ASSERT(!lfsr_m_isrdonly(flags) || !lfsr_t_ismkconsistent(flags)); - LFS_ASSERT(!lfsr_m_isrdonly(flags) || !lfsr_t_islookahead(flags)); - LFS_ASSERT(!lfsr_m_isrdonly(flags) || !lfsr_t_iscompact(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(flags) || !lfs3_t_ismkconsistent(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(flags) || !lfs3_t_islookahead(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(flags) || !lfs3_t_iscompact(flags)); - int err = lfs_init(lfs, + int err = lfs3_init(lfs3, flags & ( - LFS_M_RDWR - | LFS_M_RDONLY - | LFS_M_FLUSH - | LFS_M_SYNC - | LFS_IFDEF_REVDBG(LFS_M_REVDBG, 0) - | LFS_IFDEF_REVNOISE(LFS_M_REVNOISE, 0) - | LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, 0) - | LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, 0) - | LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, 0) - | LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, 0)), + LFS3_M_RDWR + | LFS3_M_RDONLY + | LFS3_M_FLUSH + | LFS3_M_SYNC + | LFS3_IFDEF_REVDBG(LFS3_M_REVDBG, 0) + | LFS3_IFDEF_REVNOISE(LFS3_M_REVNOISE, 0) + | LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, 0) + | LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, 0) + | LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, 0) + | LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, 0)), cfg); if (err) { return err; } - err = lfsr_mountinited(lfs); + err = lfs3_mountinited(lfs3); if (err) { goto failed; } // run gc if requested if (flags & ( - LFS_M_MKCONSISTENT - | LFS_M_LOOKAHEAD - | LFS_M_COMPACT - | LFS_M_CKMETA - | LFS_M_CKDATA)) { - lfsr_traversal_t t; - err = lfsr_fs_gc_(lfs, &t, + LFS3_M_MKCONSISTENT + | LFS3_M_LOOKAHEAD + | LFS3_M_COMPACT + | LFS3_M_CKMETA + | LFS3_M_CKDATA)) { + lfs3_traversal_t t; + err = lfs3_fs_gc_(lfs3, &t, flags & ( - LFS_M_MKCONSISTENT - | LFS_M_LOOKAHEAD - | LFS_M_COMPACT - | LFS_M_CKMETA - | LFS_M_CKDATA), + LFS3_M_MKCONSISTENT + | LFS3_M_LOOKAHEAD + | LFS3_M_COMPACT + | LFS3_M_CKMETA + | LFS3_M_CKDATA), -1); if (err) { goto failed; @@ -14379,51 +14383,51 @@ int lfsr_mount(lfs_t *lfs, uint32_t flags, } // TODO this should use any configured values - LFS_INFO("Mounted littlefs v%"PRId32".%"PRId32" %"PRId32"x%"PRId32" " + LFS3_INFO("Mounted littlefs v%"PRId32".%"PRId32" %"PRId32"x%"PRId32" " "0x{%"PRIx32",%"PRIx32"}.%"PRIx32" w%"PRId32".%"PRId32", " "cksum %08"PRIx32, - LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR, - lfs->cfg->block_size, - lfs->block_count, - lfs->mroot.rbyd.blocks[0], - lfs->mroot.rbyd.blocks[1], - lfsr_rbyd_trunk(&lfs->mroot.rbyd), - lfs->mtree.weight >> lfs->mbits, - 1 << lfs->mbits, - lfs->gcksum); + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR, + lfs3->cfg->block_size, + lfs3->block_count, + lfs3->mroot.rbyd.blocks[0], + lfs3->mroot.rbyd.blocks[1], + lfs3_rbyd_trunk(&lfs3->mroot.rbyd), + lfs3->mtree.weight >> lfs3->mbits, + 1 << lfs3->mbits, + lfs3->gcksum); return 0; failed:; // make sure we clean up on error - lfs_deinit(lfs); + lfs3_deinit(lfs3); return err; } -int lfsr_unmount(lfs_t *lfs) { - // all files/dirs should be closed before lfsr_unmount - LFS_ASSERT(lfs->omdirs == NULL +int lfs3_unmount(lfs3_t *lfs3) { + // all files/dirs should be closed before lfs3_unmount + LFS3_ASSERT(lfs3->omdirs == NULL // special case for our gc traversal handle - || LFS_IFDEF_GC( - (lfs->omdirs == &lfs->gc.t.b.o - && lfs->gc.t.b.o.next == NULL), + || LFS3_IFDEF_GC( + (lfs3->omdirs == &lfs3->gc.t.b.o + && lfs3->gc.t.b.o.next == NULL), false)); - return lfs_deinit(lfs); + return lfs3_deinit(lfs3); } /// Format /// -static int lfsr_formatinited(lfs_t *lfs) { +static int lfs3_formatinited(lfs3_t *lfs3) { for (int i = 0; i < 2; i++) { // write superblock to both rbyds in the root mroot to hopefully // avoid mounting an older filesystem on disk - lfsr_rbyd_t rbyd = {.blocks[0]=i, .eoff=0, .trunk=0}; + lfs3_rbyd_t rbyd = {.blocks[0]=i, .eoff=0, .trunk=0}; - int err = lfsr_bd_erase(lfs, rbyd.blocks[0]); + int err = lfs3_bd_erase(lfs3, rbyd.blocks[0]); if (err) { return err; } @@ -14433,9 +14437,9 @@ static int lfsr_formatinited(lfs_t *lfs) { // (rev=0), it's also useful for start with -1 and 0 in the upper // bits to help test overflow/sequence comparison uint32_t rev = (((uint32_t)i-1) << 28) - | (((1 << (28-lfs_smax(lfs->recycle_bits, 0)))-1) + | (((1 << (28-lfs3_smax(lfs3->recycle_bits, 0)))-1) & 0x00216968); - err = lfsr_rbyd_appendrev(lfs, &rbyd, rev); + err = lfs3_rbyd_appendrev(lfs3, &rbyd, rev); if (err) { return err; } @@ -14444,34 +14448,34 @@ static int lfsr_formatinited(lfs_t *lfs) { // - our magic string, "littlefs" // - any format-time configuration // - the root's bookmark tag, which reserves did = 0 for the root - err = lfsr_rbyd_appendrattrs(lfs, &rbyd, -1, -1, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MAGIC, 0, + err = lfs3_rbyd_appendrattrs(lfs3, &rbyd, -1, -1, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MAGIC, 0, "littlefs", 8), - LFSR_RATTR_BUF( - LFSR_TAG_VERSION, 0, + LFS3_RATTR_BUF( + LFS3_TAG_VERSION, 0, ((const uint8_t[2]){ - LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR}), 2), - LFSR_RATTR_LE32( - LFSR_TAG_RCOMPAT, 0, - LFSR_RCOMPAT_COMPAT), - LFSR_RATTR_LE32( - LFSR_TAG_WCOMPAT, 0, - LFSR_WCOMPAT_COMPAT), - LFSR_RATTR_GEOMETRY( - LFSR_TAG_GEOMETRY, 0, - (&(lfsr_geometry_t){ - lfs->cfg->block_size, - lfs->cfg->block_count})), - LFSR_RATTR_LLEB128( - LFSR_TAG_NAMELIMIT, 0, - lfs->name_limit), - LFSR_RATTR_LEB128( - LFSR_TAG_FILELIMIT, 0, - lfs->file_limit), - LFSR_RATTR_NAME( - LFSR_TAG_BOOKMARK, +1, + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR}), 2), + LFS3_RATTR_LE32( + LFS3_TAG_RCOMPAT, 0, + LFS3_RCOMPAT_COMPAT), + LFS3_RATTR_LE32( + LFS3_TAG_WCOMPAT, 0, + LFS3_WCOMPAT_COMPAT), + LFS3_RATTR_GEOMETRY( + LFS3_TAG_GEOMETRY, 0, + (&(lfs3_geometry_t){ + lfs3->cfg->block_size, + lfs3->cfg->block_count})), + LFS3_RATTR_LLEB128( + LFS3_TAG_NAMELIMIT, 0, + lfs3->name_limit), + LFS3_RATTR_LEB128( + LFS3_TAG_FILELIMIT, 0, + lfs3->file_limit), + LFS3_RATTR_NAME( + LFS3_TAG_BOOKMARK, +1, 0, NULL, 0))); if (err) { return err; @@ -14479,21 +14483,21 @@ static int lfsr_formatinited(lfs_t *lfs) { // append initial gcksum uint32_t cksum = rbyd.cksum; - err = lfsr_rbyd_appendrattr_(lfs, &rbyd, LFSR_RATTR_LE32( - LFSR_TAG_GCKSUMDELTA, 0, lfs_crc32c_cube(cksum))); + err = lfs3_rbyd_appendrattr_(lfs3, &rbyd, LFS3_RATTR_LE32( + LFS3_TAG_GCKSUMDELTA, 0, lfs3_crc32c_cube(cksum))); if (err) { return err; } // and commit - err = lfsr_rbyd_appendcksum_(lfs, &rbyd, cksum); + err = lfs3_rbyd_appendcksum_(lfs3, &rbyd, cksum); if (err) { return err; } } // sync on-disk state - int err = lfsr_bd_sync(lfs); + int err = lfs3_bd_sync(lfs3); if (err) { return err; } @@ -14501,96 +14505,96 @@ static int lfsr_formatinited(lfs_t *lfs) { return 0; } -int lfsr_format(lfs_t *lfs, uint32_t flags, - const struct lfs_config *cfg) { - #ifdef LFS_YES_REVDBG - flags |= LFS_F_REVDBG; +int lfs3_format(lfs3_t *lfs3, uint32_t flags, + const struct lfs3_config *cfg) { + #ifdef LFS3_YES_REVDBG + flags |= LFS3_F_REVDBG; #endif - #ifdef LFS_YES_REVNOISE - flags |= LFS_F_REVNOISE; + #ifdef LFS3_YES_REVNOISE + flags |= LFS3_F_REVNOISE; #endif - #ifdef LFS_YES_CKPROGS - flags |= LFS_F_CKPROGS; + #ifdef LFS3_YES_CKPROGS + flags |= LFS3_F_CKPROGS; #endif - #ifdef LFS_YES_CKFETCHES - flags |= LFS_F_CKFETCHES; + #ifdef LFS3_YES_CKFETCHES + flags |= LFS3_F_CKFETCHES; #endif - #ifdef LFS_YES_CKMETAPARITY - flags |= LFS_F_CKMETAPARITY; + #ifdef LFS3_YES_CKMETAPARITY + flags |= LFS3_F_CKMETAPARITY; #endif - #ifdef LFS_YES_CKDATACKSUMREADS - flags |= LFS_F_CKDATACKSUMREADS; + #ifdef LFS3_YES_CKDATACKSUMREADS + flags |= LFS3_F_CKDATACKSUMREADS; #endif - #ifdef LFS_YES_CKMETA - flags |= LFS_F_CKMETA; + #ifdef LFS3_YES_CKMETA + flags |= LFS3_F_CKMETA; #endif - #ifdef LFS_YES_CKDATA - flags |= LFS_F_CKDATA + #ifdef LFS3_YES_CKDATA + flags |= LFS3_F_CKDATA #endif // unknown flags? - LFS_ASSERT((flags & ~( - LFS_F_RDWR - | LFS_IFDEF_REVDBG(LFS_F_REVDBG, 0) - | LFS_IFDEF_REVNOISE(LFS_F_REVNOISE, 0) - | LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, 0) - | LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, 0) - | LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, 0) - | LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, 0) - | LFS_F_CKMETA - | LFS_F_CKDATA)) == 0); + LFS3_ASSERT((flags & ~( + LFS3_F_RDWR + | LFS3_IFDEF_REVDBG(LFS3_F_REVDBG, 0) + | LFS3_IFDEF_REVNOISE(LFS3_F_REVNOISE, 0) + | LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, 0) + | LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, 0) + | LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, 0) + | LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, 0) + | LFS3_F_CKMETA + | LFS3_F_CKDATA)) == 0); - int err = lfs_init(lfs, + int err = lfs3_init(lfs3, flags & ( - LFS_F_RDWR - | LFS_IFDEF_REVDBG(LFS_F_REVDBG, 0) - | LFS_IFDEF_REVNOISE(LFS_F_REVNOISE, 0) - | LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, 0) - | LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, 0) - | LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, 0) - | LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, 0)), + LFS3_F_RDWR + | LFS3_IFDEF_REVDBG(LFS3_F_REVDBG, 0) + | LFS3_IFDEF_REVNOISE(LFS3_F_REVNOISE, 0) + | LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, 0) + | LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, 0) + | LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, 0) + | LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, 0)), cfg); if (err) { return err; } - LFS_INFO("Formatting littlefs v%"PRId32".%"PRId32" %"PRId32"x%"PRId32, - LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR, - lfs->cfg->block_size, - lfs->block_count); + LFS3_INFO("Formatting littlefs v%"PRId32".%"PRId32" %"PRId32"x%"PRId32, + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR, + lfs3->cfg->block_size, + lfs3->block_count); - err = lfsr_formatinited(lfs); + err = lfs3_formatinited(lfs3); if (err) { goto failed; } // test that mount works with our formatted disk - err = lfsr_mountinited(lfs); + err = lfs3_mountinited(lfs3); if (err) { goto failed; } // run gc if requested if (flags & ( - LFS_F_CKMETA - | LFS_F_CKDATA)) { - lfsr_traversal_t t; - err = lfsr_fs_gc_(lfs, &t, + LFS3_F_CKMETA + | LFS3_F_CKDATA)) { + lfs3_traversal_t t; + err = lfs3_fs_gc_(lfs3, &t, flags & ( - LFS_F_CKMETA - | LFS_F_CKDATA), + LFS3_F_CKMETA + | LFS3_F_CKDATA), -1); if (err) { goto failed; } } - return lfs_deinit(lfs); + return lfs3_deinit(lfs3); failed:; // make sure we clean up on error - lfs_deinit(lfs); + lfs3_deinit(lfs3); return err; } @@ -14598,63 +14602,63 @@ failed:; /// Other filesystem things /// -int lfsr_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo) { +int lfs3_fs_stat(lfs3_t *lfs3, struct lfs3_fsinfo *fsinfo) { // return various filesystem flags - fsinfo->flags = lfs->flags & ( - LFS_I_RDONLY - | LFS_I_FLUSH - | LFS_I_SYNC - | LFS_IFDEF_REVDBG(LFS_I_REVDBG, 0) - | LFS_IFDEF_REVNOISE(LFS_I_REVNOISE, 0) - | LFS_IFDEF_CKPROGS(LFS_I_CKPROGS, 0) - | LFS_IFDEF_CKFETCHES(LFS_I_CKFETCHES, 0) - | LFS_IFDEF_CKMETAPARITY(LFS_I_CKMETAPARITY, 0) - | LFS_IFDEF_CKDATACKSUMREADS(LFS_I_CKDATACKSUMREADS, 0) - | LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA); + fsinfo->flags = lfs3->flags & ( + LFS3_I_RDONLY + | LFS3_I_FLUSH + | LFS3_I_SYNC + | LFS3_IFDEF_REVDBG(LFS3_I_REVDBG, 0) + | LFS3_IFDEF_REVNOISE(LFS3_I_REVNOISE, 0) + | LFS3_IFDEF_CKPROGS(LFS3_I_CKPROGS, 0) + | LFS3_IFDEF_CKFETCHES(LFS3_I_CKFETCHES, 0) + | LFS3_IFDEF_CKMETAPARITY(LFS3_I_CKMETAPARITY, 0) + | LFS3_IFDEF_CKDATACKSUMREADS(LFS3_I_CKDATACKSUMREADS, 0) + | LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA); // some flags we calculate on demand - fsinfo->flags |= (lfsr_grm_count(lfs) > 0) ? LFS_I_MKCONSISTENT : 0; + fsinfo->flags |= (lfs3_grm_count(lfs3) > 0) ? LFS3_I_MKCONSISTENT : 0; // return filesystem config, this may come from disk - fsinfo->block_size = lfs->cfg->block_size; - fsinfo->block_count = lfs->block_count; - fsinfo->name_limit = lfs->name_limit; - fsinfo->file_limit = lfs->file_limit; + fsinfo->block_size = lfs3->cfg->block_size; + fsinfo->block_count = lfs3->block_count; + fsinfo->name_limit = lfs3->name_limit; + fsinfo->file_limit = lfs3->file_limit; return 0; } -lfs_ssize_t lfsr_fs_usage(lfs_t *lfs) { - lfs_size_t count = 0; - lfsr_traversal_t t; - lfsr_traversal_init(&t, LFS_T_RDONLY); +lfs3_ssize_t lfs3_fs_usage(lfs3_t *lfs3) { + lfs3_size_t count = 0; + lfs3_traversal_t t; + lfs3_traversal_init(&t, LFS3_T_RDONLY); while (true) { - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(lfs3, &t, &tag, &bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; } // count the number of blocks we see, yes this may result in duplicates - if (tag == LFSR_TAG_MDIR) { + if (tag == LFS3_TAG_MDIR) { count += 2; - } else if (tag == LFSR_TAG_BRANCH) { + } else if (tag == LFS3_TAG_BRANCH) { count += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { count += 1; } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } @@ -14664,46 +14668,46 @@ lfs_ssize_t lfsr_fs_usage(lfs_t *lfs) { // consistency stuff -static int lfsr_fs_fixgrm(lfs_t *lfs) { - if (lfsr_grm_count(lfs) == 2) { - LFS_INFO("Fixing grm %"PRId32".%"PRId32" %"PRId32".%"PRId32, - lfsr_dbgmbid(lfs, lfs->grm.queue[0]), - lfsr_dbgmrid(lfs, lfs->grm.queue[0]), - lfsr_dbgmbid(lfs, lfs->grm.queue[1]), - lfsr_dbgmrid(lfs, lfs->grm.queue[1])); - } else if (lfsr_grm_count(lfs) == 1) { - LFS_INFO("Fixing grm %"PRId32".%"PRId32, - lfsr_dbgmbid(lfs, lfs->grm.queue[0]), - lfsr_dbgmrid(lfs, lfs->grm.queue[0])); +static int lfs3_fs_fixgrm(lfs3_t *lfs3) { + if (lfs3_grm_count(lfs3) == 2) { + LFS3_INFO("Fixing grm %"PRId32".%"PRId32" %"PRId32".%"PRId32, + lfs3_dbgmbid(lfs3, lfs3->grm.queue[0]), + lfs3_dbgmrid(lfs3, lfs3->grm.queue[0]), + lfs3_dbgmbid(lfs3, lfs3->grm.queue[1]), + lfs3_dbgmrid(lfs3, lfs3->grm.queue[1])); + } else if (lfs3_grm_count(lfs3) == 1) { + LFS3_INFO("Fixing grm %"PRId32".%"PRId32, + lfs3_dbgmbid(lfs3, lfs3->grm.queue[0]), + lfs3_dbgmrid(lfs3, lfs3->grm.queue[0])); } - while (lfsr_grm_count(lfs) > 0) { - LFS_ASSERT(lfs->grm.queue[0] != -1); + while (lfs3_grm_count(lfs3) > 0) { + LFS3_ASSERT(lfs3->grm.queue[0] != -1); // find our mdir - lfsr_mdir_t mdir; - int err = lfsr_mtree_lookup(lfs, lfs->grm.queue[0], + lfs3_mdir_t mdir; + int err = lfs3_mtree_lookup(lfs3, lfs3->grm.queue[0], &mdir); if (err) { - LFS_ASSERT(err != LFS_ERR_NOENT); + LFS3_ASSERT(err != LFS3_ERR_NOENT); return err; } // we also use grm to track orphans that need to be cleaned up, // which means it may not match the on-disk state, which means // we need to revert manually on error - lfsr_grm_t grm_p = lfs->grm; + lfs3_grm_t grm_p = lfs3->grm; // mark grm as taken care of - lfsr_grm_pop(lfs); + lfs3_grm_pop(lfs3); // checkpoint the allocator - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // remove the rid while atomically updating our grm - err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))); + err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))); if (err) { // revert grm manually - lfs->grm = grm_p; + lfs3->grm = grm_p; return err; } } @@ -14711,30 +14715,30 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { return 0; } -static int lfsr_mdir_mkconsistent(lfs_t *lfs, lfsr_mdir_t *mdir) { +static int lfs3_mdir_mkconsistent(lfs3_t *lfs3, lfs3_mdir_t *mdir) { // save the current mid - lfsr_mid_t mid = mdir->mid; + lfs3_mid_t mid = mdir->mid; // iterate through mids looking for orphans - mdir->mid = LFSR_MID(lfs, mdir->mid, 0); + mdir->mid = LFS3_MID(lfs3, mdir->mid, 0); int err; - while (lfsr_mrid(lfs, mdir->mid) < (lfsr_srid_t)mdir->rbyd.weight) { + while (lfs3_mrid(lfs3, mdir->mid) < (lfs3_srid_t)mdir->rbyd.weight) { // is this mid open? well we're not an orphan then, skip // - // note we can't rely on lfsr_mdir_lookup's internal orphan + // note we can't rely on lfs3_mdir_lookup's internal orphan // checks as we also need to treat desynced/zombied files as // non-orphans - if (lfsr_omdir_ismidopen(lfs, mdir->mid, -1)) { + if (lfs3_omdir_ismidopen(lfs3, mdir->mid, -1)) { mdir->mid += 1; continue; } // is this mid marked as a stickynote? - err = lfsr_rbyd_lookup(lfs, &mdir->rbyd, - lfsr_mrid(lfs, mdir->mid), LFSR_TAG_STICKYNOTE, + err = lfs3_rbyd_lookup(lfs3, &mdir->rbyd, + lfs3_mrid(lfs3, mdir->mid), LFS3_TAG_STICKYNOTE, NULL, NULL); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { mdir->mid += 1; continue; } @@ -14742,13 +14746,13 @@ static int lfsr_mdir_mkconsistent(lfs_t *lfs, lfsr_mdir_t *mdir) { } // we found an orphaned stickynote, remove - LFS_INFO("Fixing orphaned stickynote %"PRId32".%"PRId32, - lfsr_dbgmbid(lfs, mdir->mid), - lfsr_dbgmrid(lfs, mdir->mid)); + LFS3_INFO("Fixing orphaned stickynote %"PRId32".%"PRId32, + lfs3_dbgmbid(lfs3, mdir->mid), + lfs3_dbgmrid(lfs3, mdir->mid)); - lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))); + lfs3_alloc_ckpoint(lfs3); + err = lfs3_mdir_commit(lfs3, mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))); if (err) { goto failed; } @@ -14764,17 +14768,17 @@ failed:; return err; } -static int lfsr_fs_fixorphans(lfs_t *lfs) { - // LFS_T_MKCONSISTENT really just removes orphans - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDWR | LFS_T_MTREEONLY | LFS_T_MKCONSISTENT); +static int lfs3_fs_fixorphans(lfs3_t *lfs3) { + // LFS3_T_MKCONSISTENT really just removes orphans + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDWR | LFS3_T_MTREEONLY | LFS3_T_MKCONSISTENT); while (true) { - lfsr_bptr_t bptr; - int err = lfsr_mtree_gc(lfs, &t, + lfs3_bptr_t bptr; + int err = lfs3_mtree_gc(lfs3, &t, NULL, &bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -14785,13 +14789,13 @@ static int lfsr_fs_fixorphans(lfs_t *lfs) { } // prepare the filesystem for mutation -int lfsr_fs_mkconsistent(lfs_t *lfs) { +int lfs3_fs_mkconsistent(lfs3_t *lfs3) { // filesystem must be writeable - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags)); // fix pending grms - if (lfsr_grm_count(lfs) > 0) { - int err = lfsr_fs_fixgrm(lfs); + if (lfs3_grm_count(lfs3) > 0) { + int err = lfs3_fs_fixgrm(lfs3); if (err) { return err; } @@ -14802,8 +14806,8 @@ int lfsr_fs_mkconsistent(lfs_t *lfs) { // this must happen after fixgrm, since removing orphaned // stickynotes risks outdating the grm // - if (lfsr_t_ismkconsistent(lfs->flags)) { - int err = lfsr_fs_fixorphans(lfs); + if (lfs3_t_ismkconsistent(lfs3->flags)) { + int err = lfs3_fs_fixorphans(lfs3); if (err) { return err; } @@ -14813,16 +14817,16 @@ int lfsr_fs_mkconsistent(lfs_t *lfs) { } // filesystem check functions -static int lfsr_fs_ck(lfs_t *lfs, uint32_t flags) { - // we leave this up to lfsr_mtree_traverse - lfsr_traversal_t t; - lfsr_traversal_init(&t, flags); +static int lfs3_fs_ck(lfs3_t *lfs3, uint32_t flags) { + // we leave this up to lfs3_mtree_traverse + lfs3_traversal_t t; + lfs3_traversal_init(&t, flags); while (true) { - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(lfs, &t, + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(lfs3, &t, NULL, &bptr); if (err) { - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } return err; @@ -14832,17 +14836,17 @@ static int lfsr_fs_ck(lfs_t *lfs, uint32_t flags) { return 0; } -int lfsr_fs_ckmeta(lfs_t *lfs) { - return lfsr_fs_ck(lfs, LFS_T_RDONLY | LFS_T_CKMETA); +int lfs3_fs_ckmeta(lfs3_t *lfs3) { + return lfs3_fs_ck(lfs3, LFS3_T_RDONLY | LFS3_T_CKMETA); } -int lfsr_fs_ckdata(lfs_t *lfs) { - return lfsr_fs_ck(lfs, LFS_T_RDONLY | LFS_T_CKMETA | LFS_T_CKDATA); +int lfs3_fs_ckdata(lfs3_t *lfs3) { + return lfs3_fs_ck(lfs3, LFS3_T_RDONLY | LFS3_T_CKMETA | LFS3_T_CKDATA); } // get the filesystem checksum -int lfsr_fs_cksum(lfs_t *lfs, uint32_t *cksum) { - *cksum = lfs->gcksum; +int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum) { + *cksum = lfs3->gcksum; return 0; } @@ -14850,30 +14854,30 @@ int lfsr_fs_cksum(lfs_t *lfs, uint32_t *cksum) { // // runs the traversal until all work is completed, which may take // multiple passes -static int lfsr_fs_gc_(lfs_t *lfs, lfsr_traversal_t *t, - uint32_t flags, lfs_soff_t steps) { +static int lfs3_fs_gc_(lfs3_t *lfs3, lfs3_traversal_t *t, + uint32_t flags, lfs3_soff_t steps) { // unknown gc flags? // // we should have check these earlier, but it doesn't hurt to // double check - LFS_ASSERT((flags & ~( - LFS_GC_MKCONSISTENT - | LFS_GC_LOOKAHEAD - | LFS_GC_COMPACT - | LFS_GC_CKMETA - | LFS_GC_CKDATA)) == 0); + LFS3_ASSERT((flags & ~( + LFS3_GC_MKCONSISTENT + | LFS3_GC_LOOKAHEAD + | LFS3_GC_COMPACT + | LFS3_GC_CKMETA + | LFS3_GC_CKDATA)) == 0); // these flags require a writable filesystem - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags) || !lfsr_t_ismkconsistent(flags)); - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags) || !lfsr_t_islookahead(flags)); - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags) || !lfsr_t_iscompact(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) || !lfs3_t_ismkconsistent(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) || !lfs3_t_islookahead(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) || !lfs3_t_iscompact(flags)); // some flags don't make sense when only traversing the mtree - LFS_ASSERT(!lfsr_t_ismtreeonly(flags) || !lfsr_t_islookahead(flags)); - LFS_ASSERT(!lfsr_t_ismtreeonly(flags) || !lfsr_t_isckdata(flags)); + LFS3_ASSERT(!lfs3_t_ismtreeonly(flags) || !lfs3_t_islookahead(flags)); + LFS3_ASSERT(!lfs3_t_ismtreeonly(flags) || !lfs3_t_isckdata(flags)); // fix pending grms if requested - if (lfsr_t_ismkconsistent(flags) - && lfsr_grm_count(lfs) > 0) { - int err = lfsr_fs_fixgrm(lfs); + if (lfs3_t_ismkconsistent(flags) + && lfs3_grm_count(lfs3) > 0) { + int err = lfs3_fs_fixgrm(lfs3); if (err) { return err; } @@ -14881,67 +14885,67 @@ static int lfsr_fs_gc_(lfs_t *lfs, lfsr_traversal_t *t, // do we have any pending work? uint32_t pending = flags & ( - (lfs->flags & ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA))); + (lfs3->flags & ( + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA))); - while (pending && (lfs_off_t)steps > 0) { + while (pending && (lfs3_off_t)steps > 0) { // checkpoint the allocator to maximize any lookahead scans - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); // start a new traversal? - if (!lfsr_omdir_isopen(lfs, &t->b.o)) { - lfsr_traversal_init(t, pending); - lfsr_omdir_open(lfs, &t->b.o); + if (!lfs3_omdir_isopen(lfs3, &t->b.o)) { + lfs3_traversal_init(t, pending); + lfs3_omdir_open(lfs3, &t->b.o); } // don't bother with lookahead if we've mutated - if (lfsr_t_isdirty(t->b.o.flags) - || lfsr_t_ismutated(t->b.o.flags)) { - t->b.o.flags &= ~LFS_GC_LOOKAHEAD; + if (lfs3_t_isdirty(t->b.o.flags) + || lfs3_t_ismutated(t->b.o.flags)) { + t->b.o.flags &= ~LFS3_GC_LOOKAHEAD; } // will this traversal still make progress? no? start over if (!(t->b.o.flags & ( - LFS_GC_MKCONSISTENT - | LFS_GC_LOOKAHEAD - | LFS_GC_COMPACT - | LFS_GC_CKMETA - | LFS_GC_CKDATA))) { - lfsr_omdir_close(lfs, &t->b.o); + LFS3_GC_MKCONSISTENT + | LFS3_GC_LOOKAHEAD + | LFS3_GC_COMPACT + | LFS3_GC_CKMETA + | LFS3_GC_CKDATA))) { + lfs3_omdir_close(lfs3, &t->b.o); continue; } // do we really need a full traversal? if (!(t->b.o.flags & ( - LFS_GC_LOOKAHEAD - | LFS_GC_CKMETA - | LFS_GC_CKDATA))) { - t->b.o.flags |= LFS_T_MTREEONLY; + LFS3_GC_LOOKAHEAD + | LFS3_GC_CKMETA + | LFS3_GC_CKDATA))) { + t->b.o.flags |= LFS3_T_MTREEONLY; } // progress gc - lfsr_bptr_t bptr; - int err = lfsr_mtree_gc(lfs, t, + lfs3_bptr_t bptr; + int err = lfs3_mtree_gc(lfs3, t, NULL, &bptr); - if (err && err != LFS_ERR_NOENT) { + if (err && err != LFS3_ERR_NOENT) { return err; } // end of traversal? - if (err == LFS_ERR_NOENT) { - lfsr_omdir_close(lfs, &t->b.o); + if (err == LFS3_ERR_NOENT) { + lfs3_omdir_close(lfs3, &t->b.o); // clear any pending flags we make progress on - pending &= lfs->flags & ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA); + pending &= lfs3->flags & ( + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA); } // decrement steps @@ -14953,38 +14957,38 @@ static int lfsr_fs_gc_(lfs_t *lfs, lfsr_traversal_t *t, return 0; } -#ifdef LFS_GC +#ifdef LFS3_GC // incremental filesystem gc // // perform any pending janitorial work -int lfsr_fs_gc(lfs_t *lfs) { - return lfsr_fs_gc_(lfs, &lfs->gc.t, - lfs->cfg->gc_flags, - (lfs->cfg->gc_steps) - ? lfs->cfg->gc_steps +int lfs3_fs_gc(lfs3_t *lfs3) { + return lfs3_fs_gc_(lfs3, &lfs3->gc.t, + lfs3->cfg->gc_flags, + (lfs3->cfg->gc_steps) + ? lfs3->cfg->gc_steps : 1); } #endif // unperform janitorial work -int lfsr_fs_unck(lfs_t *lfs, uint32_t flags) { +int lfs3_fs_unck(lfs3_t *lfs3, uint32_t flags) { // unknown flags? - LFS_ASSERT((flags & ~( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)) == 0); + LFS3_ASSERT((flags & ~( + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)) == 0); // reset the requested flags - lfs->flags |= flags; + lfs3->flags |= flags; - #ifdef LFS_GC + #ifdef LFS3_GC // and clear from any ongoing traversals // - // lfsr_fs_gc will terminate early if it discovers it can no longer + // lfs3_fs_gc will terminate early if it discovers it can no longer // make progress - lfs->gc.t.b.o.flags &= ~flags; + lfs3->gc.t.b.o.flags &= ~flags; #endif return 0; @@ -14992,46 +14996,46 @@ int lfsr_fs_unck(lfs_t *lfs, uint32_t flags) { // attempt to grow the filesystem -int lfsr_fs_grow(lfs_t *lfs, lfs_size_t block_count_) { +int lfs3_fs_grow(lfs3_t *lfs3, lfs3_size_t block_count_) { // filesystem must be writeable - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags)); // shrinking the filesystem is not supported - LFS_ASSERT(block_count_ >= lfs->block_count); + LFS3_ASSERT(block_count_ >= lfs3->block_count); // do nothing if block_count doesn't change - if (block_count_ == lfs->block_count) { + if (block_count_ == lfs3->block_count) { return 0; } - // Note we do _not_ call lfsr_fs_mkconsistent here. This is a bit scary, - // but we should be ok as long as we patch grms in lfsr_mdir_commit and + // Note we do _not_ call lfs3_fs_mkconsistent here. This is a bit scary, + // but we should be ok as long as we patch grms in lfs3_mdir_commit and // only commit to the mroot. // - // Calling lfsr_fs_mkconsistent risks locking our filesystem up trying + // Calling lfs3_fs_mkconsistent risks locking our filesystem up trying // to fix grms/orphans before we can commit the new filesystem size. If // we don't, we should always be able to recover a stuck filesystem with - // lfsr_fs_grow. + // lfs3_fs_grow. - LFS_INFO("Growing littlefs %"PRId32"x%"PRId32" -> %"PRId32"x%"PRId32, - lfs->cfg->block_size, lfs->block_count, - lfs->cfg->block_size, block_count_); + LFS3_INFO("Growing littlefs %"PRId32"x%"PRId32" -> %"PRId32"x%"PRId32, + lfs3->cfg->block_size, lfs3->block_count, + lfs3->cfg->block_size, block_count_); // keep track of our current block_count in case we fail - lfs_size_t block_count = lfs->block_count; + lfs3_size_t block_count = lfs3->block_count; // we can use the new blocks immediately as long as the commit // with the new block_count is atomic - lfs->block_count = block_count_; + lfs3->block_count = block_count_; // discard stale lookahead buffer - lfs_alloc_discard(lfs); + lfs3_alloc_discard(lfs3); // update our on-disk config - lfs_alloc_ckpoint(lfs); - int err = lfsr_mdir_commit(lfs, &lfs->mroot, LFSR_RATTRS( - LFSR_RATTR_GEOMETRY( - LFSR_TAG_GEOMETRY, 0, - (&(lfsr_geometry_t){ - lfs->cfg->block_size, + lfs3_alloc_ckpoint(lfs3); + int err = lfs3_mdir_commit(lfs3, &lfs3->mroot, LFS3_RATTRS( + LFS3_RATTR_GEOMETRY( + LFS3_TAG_GEOMETRY, 0, + (&(lfs3_geometry_t){ + lfs3->cfg->block_size, block_count_})))); if (err) { goto failed; @@ -15041,9 +15045,9 @@ int lfsr_fs_grow(lfs_t *lfs, lfs_size_t block_count_) { failed:; // restore block_count - lfs->block_count = block_count; + lfs3->block_count = block_count; // discard clobbered lookahead buffer - lfs_alloc_discard(lfs); + lfs3_alloc_discard(lfs3); return err; } @@ -15052,82 +15056,82 @@ failed:; /// High-level filesystem traversal /// -// needed in lfsr_traversal_open -static int lfsr_traversal_rewind_(lfs_t *lfs, lfsr_traversal_t *t); +// needed in lfs3_traversal_open +static int lfs3_traversal_rewind_(lfs3_t *lfs3, lfs3_traversal_t *t); -int lfsr_traversal_open(lfs_t *lfs, lfsr_traversal_t *t, uint32_t flags) { +int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags) { // already open? - LFS_ASSERT(!lfsr_omdir_isopen(lfs, &t->b.o)); + LFS3_ASSERT(!lfs3_omdir_isopen(lfs3, &t->b.o)); // unknown flags? - LFS_ASSERT((flags & ~( - LFS_T_RDONLY - | LFS_T_RDWR - | LFS_T_MTREEONLY - | LFS_T_MKCONSISTENT - | LFS_T_LOOKAHEAD - | LFS_T_COMPACT - | LFS_T_CKMETA - | LFS_T_CKDATA)) == 0); + LFS3_ASSERT((flags & ~( + LFS3_T_RDONLY + | LFS3_T_RDWR + | LFS3_T_MTREEONLY + | LFS3_T_MKCONSISTENT + | LFS3_T_LOOKAHEAD + | LFS3_T_COMPACT + | LFS3_T_CKMETA + | LFS3_T_CKDATA)) == 0); // writeable traversals require a writeable filesystem - LFS_ASSERT(!lfsr_m_isrdonly(lfs->flags) || lfsr_t_isrdonly(flags)); + LFS3_ASSERT(!lfs3_m_isrdonly(lfs3->flags) || lfs3_t_isrdonly(flags)); // these flags require a writable traversal - LFS_ASSERT(!lfsr_t_isrdonly(flags) || !lfsr_t_ismkconsistent(flags)); - LFS_ASSERT(!lfsr_t_isrdonly(flags) || !lfsr_t_islookahead(flags)); - LFS_ASSERT(!lfsr_t_isrdonly(flags) || !lfsr_t_iscompact(flags)); + LFS3_ASSERT(!lfs3_t_isrdonly(flags) || !lfs3_t_ismkconsistent(flags)); + LFS3_ASSERT(!lfs3_t_isrdonly(flags) || !lfs3_t_islookahead(flags)); + LFS3_ASSERT(!lfs3_t_isrdonly(flags) || !lfs3_t_iscompact(flags)); // some flags don't make sense when only traversing the mtree - LFS_ASSERT(!lfsr_t_ismtreeonly(flags) || !lfsr_t_islookahead(flags)); - LFS_ASSERT(!lfsr_t_ismtreeonly(flags) || !lfsr_t_isckdata(flags)); + LFS3_ASSERT(!lfs3_t_ismtreeonly(flags) || !lfs3_t_islookahead(flags)); + LFS3_ASSERT(!lfs3_t_ismtreeonly(flags) || !lfs3_t_isckdata(flags)); // setup traversal state - t->b.o.flags = flags | lfsr_o_typeflags(LFS_type_TRAVERSAL); + t->b.o.flags = flags | lfs3_o_typeflags(LFS3_type_TRAVERSAL); // let rewind initialize/reset things - int err = lfsr_traversal_rewind_(lfs, t); + int err = lfs3_traversal_rewind_(lfs3, t); if (err) { return err; } // add to tracked mdirs - lfsr_omdir_open(lfs, &t->b.o); + lfs3_omdir_open(lfs3, &t->b.o); return 0; } -int lfsr_traversal_close(lfs_t *lfs, lfsr_traversal_t *t) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &t->b.o)); +int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &t->b.o)); // remove from tracked mdirs - lfsr_omdir_close(lfs, &t->b.o); + lfs3_omdir_close(lfs3, &t->b.o); return 0; } -int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t, - struct lfs_tinfo *tinfo) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &t->b.o)); +int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, + struct lfs3_tinfo *tinfo) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &t->b.o)); // check for pending grms every step, just in case some other // operation introduced new grms - if (lfsr_t_ismkconsistent(t->b.o.flags) - && lfsr_grm_count(lfs) > 0) { + if (lfs3_t_ismkconsistent(t->b.o.flags) + && lfs3_grm_count(lfs3) > 0) { // swap dirty/mutated flags while mutating - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); - int err = lfsr_fs_fixgrm(lfs); + int err = lfs3_fs_fixgrm(lfs3); if (err) { - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); return err; } - t->b.o.flags = lfsr_t_swapdirty(t->b.o.flags); + t->b.o.flags = lfs3_t_swapdirty(t->b.o.flags); } // checkpoint the allocator to maximize any lookahead scans - lfs_alloc_ckpoint(lfs); + lfs3_alloc_ckpoint(lfs3); while (true) { // some redund blocks left over? if (t->blocks[0] != -1) { // write our traversal info - tinfo->btype = lfsr_t_btype(t->b.o.flags); + tinfo->btype = lfs3_t_btype(t->b.o.flags); tinfo->block = t->blocks[0]; t->blocks[0] = t->blocks[1]; @@ -15136,61 +15140,61 @@ int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t, } // find next block - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_gc(lfs, t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_gc(lfs3, t, &tag, &bptr); if (err) { return err; } // figure out type/blocks - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; - lfsr_t_setbtype(&t->b.o.flags, LFS_BTYPE_MDIR); + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; + lfs3_t_setbtype(&t->b.o.flags, LFS3_BTYPE_MDIR); t->blocks[0] = mdir->rbyd.blocks[0]; t->blocks[1] = mdir->rbyd.blocks[1]; - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_t_setbtype(&t->b.o.flags, LFS_BTYPE_BTREE); - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_t_setbtype(&t->b.o.flags, LFS3_BTYPE_BTREE); + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; t->blocks[0] = rbyd->blocks[0]; t->blocks[1] = -1; - } else if (tag == LFSR_TAG_BLOCK) { - lfsr_t_setbtype(&t->b.o.flags, LFS_BTYPE_DATA); - t->blocks[0] = lfsr_bptr_block(&bptr); + } else if (tag == LFS3_TAG_BLOCK) { + lfs3_t_setbtype(&t->b.o.flags, LFS3_BTYPE_DATA); + t->blocks[0] = lfs3_bptr_block(&bptr); t->blocks[1] = -1; } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } } } -static void lfsr_traversal_clobber(lfs_t *lfs, lfsr_traversal_t *t) { - (void)lfs; +static void lfs3_traversal_clobber(lfs3_t *lfs3, lfs3_traversal_t *t) { + (void)lfs3; // mroot/mtree? transition to mdir iteration - if (lfsr_t_tstate(t->b.o.flags) < LFSR_TSTATE_MDIRS) { - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIRS); + if (lfs3_t_tstate(t->b.o.flags) < LFS3_TSTATE_MDIRS) { + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIRS); t->b.o.mdir.mid = 0; - lfsr_bshrub_init(&t->b); + lfs3_bshrub_init(&t->b); t->ot = NULL; // in-mtree mdir? increment the mid (to make progress) and reset to // mdir iteration - } else if (lfsr_t_tstate(t->b.o.flags) < LFSR_TSTATE_OMDIRS) { - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_MDIR); + } else if (lfs3_t_tstate(t->b.o.flags) < LFS3_TSTATE_OMDIRS) { + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_MDIR); t->b.o.mdir.mid += 1; - lfsr_bshrub_init(&t->b); + lfs3_bshrub_init(&t->b); t->ot = NULL; // opened mdir? skip to next omdir - } else if (lfsr_t_tstate(t->b.o.flags) < LFSR_TSTATE_DONE) { - lfsr_t_settstate(&t->b.o.flags, LFSR_TSTATE_OMDIRS); - lfsr_bshrub_init(&t->b); + } else if (lfs3_t_tstate(t->b.o.flags) < LFS3_TSTATE_DONE) { + lfs3_t_settstate(&t->b.o.flags, LFS3_TSTATE_OMDIRS); + lfs3_bshrub_init(&t->b); t->ot = (t->ot) ? t->ot->next : NULL; // done traversals should never need clobbering } else { - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } // and clear any pending blocks @@ -15198,15 +15202,15 @@ static void lfsr_traversal_clobber(lfs_t *lfs, lfsr_traversal_t *t) { t->blocks[1] = -1; } -static int lfsr_traversal_rewind_(lfs_t *lfs, lfsr_traversal_t *t) { - (void)lfs; +static int lfs3_traversal_rewind_(lfs3_t *lfs3, lfs3_traversal_t *t) { + (void)lfs3; // reset traversal - lfsr_traversal_init(t, + lfs3_traversal_init(t, t->b.o.flags - & ~LFS_t_DIRTY - & ~LFS_t_MUTATED - & ~LFS_t_TSTATE); + & ~LFS3_t_DIRTY + & ~LFS3_t_MUTATED + & ~LFS3_t_TSTATE); // and clear any pending blocks t->blocks[0] = -1; @@ -15215,10 +15219,10 @@ static int lfsr_traversal_rewind_(lfs_t *lfs, lfsr_traversal_t *t) { return 0; } -int lfsr_traversal_rewind(lfs_t *lfs, lfsr_traversal_t *t) { - LFS_ASSERT(lfsr_omdir_isopen(lfs, &t->b.o)); +int lfs3_traversal_rewind(lfs3_t *lfs3, lfs3_traversal_t *t) { + LFS3_ASSERT(lfs3_omdir_isopen(lfs3, &t->b.o)); - return lfsr_traversal_rewind_(lfs, t); + return lfs3_traversal_rewind_(lfs3, t); } diff --git a/lfs.h b/lfs3.h similarity index 55% rename from lfs.h rename to lfs3.h index 4f39553f..0966ccbf 100644 --- a/lfs.h +++ b/lfs3.h @@ -5,10 +5,10 @@ * Copyright (c) 2017, Arm Limited. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause */ -#ifndef LFS_H -#define LFS_H +#ifndef LFS3_H +#define LFS3_H -#include "lfs_util.h" +#include "lfs3_util.h" /// Version info /// @@ -16,325 +16,332 @@ // Software library version // Major (top-nibble), incremented on backwards incompatible changes // Minor (bottom-nibble), incremented on feature additions -#define LFS_VERSION 0x00000000 -#define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16)) -#define LFS_VERSION_MINOR (0xffff & (LFS_VERSION >> 0)) +#define LFS3_VERSION 0x00000000 +#define LFS3_VERSION_MAJOR (0xffff & (LFS3_VERSION >> 16)) +#define LFS3_VERSION_MINOR (0xffff & (LFS3_VERSION >> 0)) // Version of On-disk data structures // Major (top-nibble), incremented on backwards incompatible changes // Minor (bottom-nibble), incremented on feature additions -#define LFS_DISK_VERSION 0x00000000 -#define LFS_DISK_VERSION_MAJOR (0xffff & (LFS_DISK_VERSION >> 16)) -#define LFS_DISK_VERSION_MINOR (0xffff & (LFS_DISK_VERSION >> 0)) +#define LFS3_DISK_VERSION 0x00000000 +#define LFS3_DISK_VERSION_MAJOR (0xffff & (LFS3_DISK_VERSION >> 16)) +#define LFS3_DISK_VERSION_MINOR (0xffff & (LFS3_DISK_VERSION >> 0)) /// Definitions /// // Type definitions -typedef uint32_t lfs_size_t; -typedef int32_t lfs_ssize_t; +typedef uint32_t lfs3_size_t; +typedef int32_t lfs3_ssize_t; -typedef uint32_t lfs_off_t; -typedef int32_t lfs_soff_t; +typedef uint32_t lfs3_off_t; +typedef int32_t lfs3_soff_t; -typedef uint32_t lfs_block_t; -typedef int32_t lfs_sblock_t; +typedef uint32_t lfs3_block_t; +typedef int32_t lfs3_sblock_t; -typedef uint32_t lfsr_rid_t; -typedef int32_t lfsr_srid_t; +typedef uint32_t lfs3_rid_t; +typedef int32_t lfs3_srid_t; -typedef uint16_t lfsr_tag_t; -typedef int16_t lfsr_stag_t; +typedef uint16_t lfs3_tag_t; +typedef int16_t lfs3_stag_t; -typedef uint32_t lfsr_bid_t; -typedef int32_t lfsr_sbid_t; +typedef uint32_t lfs3_bid_t; +typedef int32_t lfs3_sbid_t; -typedef uint32_t lfsr_mid_t; -typedef int32_t lfsr_smid_t; +typedef uint32_t lfs3_mid_t; +typedef int32_t lfs3_smid_t; -typedef uint32_t lfsr_did_t; -typedef int32_t lfsr_sdid_t; +typedef uint32_t lfs3_did_t; +typedef int32_t lfs3_sdid_t; // Maximum name size in bytes, may be redefined to reduce the size of the // info struct. Limited to <= 1022. Stored in superblock and must be // respected by other littlefs drivers. -#ifndef LFS_NAME_MAX -#define LFS_NAME_MAX 255 +#ifndef LFS3_NAME_MAX +#define LFS3_NAME_MAX 255 #endif // Maximum size of a file in bytes, may be redefined to limit to support other // drivers. Limited on disk to <= 2147483647. Stored in superblock and must be // respected by other littlefs drivers. -#ifndef LFS_FILE_MAX -#define LFS_FILE_MAX 2147483647 +#ifndef LFS3_FILE_MAX +#define LFS3_FILE_MAX 2147483647 #endif // Possible error codes, these are negative to allow // valid positive return values -enum lfs_error { - LFS_ERR_OK = 0, // No error - LFS_ERR_UNKNOWN = -1, // Unknown error - LFS_ERR_INVAL = -22, // Invalid parameter - LFS_ERR_NOTSUP = -95, // Operation not supported - LFS_ERR_IO = -5, // Error during device operation - LFS_ERR_CORRUPT = -84, // Corrupted - LFS_ERR_NOENT = -2, // No directory entry - LFS_ERR_EXIST = -17, // Entry already exists - LFS_ERR_NOTDIR = -20, // Entry is not a dir - LFS_ERR_ISDIR = -21, // Entry is a dir - LFS_ERR_NOTEMPTY = -39, // Dir is not empty - LFS_ERR_FBIG = -27, // File too large - LFS_ERR_NOSPC = -28, // No space left on device - LFS_ERR_NOMEM = -12, // No more memory available - LFS_ERR_NOATTR = -61, // No data/attr available - LFS_ERR_NAMETOOLONG = -36, // File name too long - LFS_ERR_RANGE = -34, // Result out of range +enum lfs3_error { + LFS3_ERR_OK = 0, // No error + LFS3_ERR_UNKNOWN = -1, // Unknown error + LFS3_ERR_INVAL = -22, // Invalid parameter + LFS3_ERR_NOTSUP = -95, // Operation not supported + LFS3_ERR_IO = -5, // Error during device operation + LFS3_ERR_CORRUPT = -84, // Corrupted + LFS3_ERR_NOENT = -2, // No directory entry + LFS3_ERR_EXIST = -17, // Entry already exists + LFS3_ERR_NOTDIR = -20, // Entry is not a dir + LFS3_ERR_ISDIR = -21, // Entry is a dir + LFS3_ERR_NOTEMPTY = -39, // Dir is not empty + LFS3_ERR_FBIG = -27, // File too large + LFS3_ERR_NOSPC = -28, // No space left on device + LFS3_ERR_NOMEM = -12, // No more memory available + LFS3_ERR_NOATTR = -61, // No data/attr available + LFS3_ERR_NAMETOOLONG = -36, // File name too long + LFS3_ERR_RANGE = -34, // Result out of range }; // File types // -// LFS_TYPE_UNKNOWN will always be the largest, including internal +// LFS3_TYPE_UNKNOWN will always be the largest, including internal // types, and can be used to deliminate user defined types at higher // levels // -enum lfs_type { +enum lfs3_type { // file types - LFS_TYPE_REG = 1, // A regular file - LFS_TYPE_DIR = 2, // A directory file - LFS_TYPE_STICKYNOTE = 3, // An uncommitted file - LFS_TYPE_UNKNOWN = 7, // Unknown file type + LFS3_TYPE_REG = 1, // A regular file + LFS3_TYPE_DIR = 2, // A directory file + LFS3_TYPE_STICKYNOTE = 3, // An uncommitted file + LFS3_TYPE_UNKNOWN = 7, // Unknown file type // internally used types, don't use these - LFS_type_BOOKMARK = 4, // Directory bookmark - LFS_type_ORPHAN = 5, // An orphaned stickynote - LFS_type_TRAVERSAL = 6, // An open traversal object + LFS3_type_BOOKMARK = 4, // Directory bookmark + LFS3_type_ORPHAN = 5, // An orphaned stickynote + LFS3_type_TRAVERSAL = 6, // An open traversal object }; // File open flags -#define LFS_O_MODE 3 // The file's access mode -#define LFS_O_RDONLY 0 // Open a file as read only -#define LFS_O_WRONLY 1 // Open a file as write only -#define LFS_O_RDWR 2 // Open a file as read and write -#define LFS_O_CREAT 0x00000004 // Create a file if it does not exist -#define LFS_O_EXCL 0x00000008 // Fail if a file already exists -#define LFS_O_TRUNC 0x00000010 // Truncate the existing file to zero size -#define LFS_O_APPEND 0x00000020 // Move to end of file on every write -#define LFS_O_FLUSH 0x00000040 // Flush data on every write -#define LFS_O_SYNC 0x00000080 // Sync metadata on every write -#define LFS_O_DESYNC 0x04000000 // Do not sync or recieve file updates -#define LFS_O_CKMETA 0x00001000 // Check metadata checksums -#define LFS_O_CKDATA 0x00002000 // Check metadata + data checksums +#define LFS3_O_MODE 3 // The file's access mode +#define LFS3_O_RDONLY 0 // Open a file as read only +#define LFS3_O_WRONLY 1 // Open a file as write only +#define LFS3_O_RDWR 2 // Open a file as read and write +#define LFS3_O_CREAT 0x00000004 // Create a file if it does not exist +#define LFS3_O_EXCL 0x00000008 // Fail if a file already exists +#define LFS3_O_TRUNC 0x00000010 // Truncate the existing file to zero size +#define LFS3_O_APPEND 0x00000020 // Move to end of file on every write +#define LFS3_O_FLUSH 0x00000040 // Flush data on every write +#define LFS3_O_SYNC 0x00000080 // Sync metadata on every write +#define LFS3_O_DESYNC 0x04000000 // Do not sync or recieve file updates +#define LFS3_O_CKMETA 0x00001000 // Check metadata checksums +#define LFS3_O_CKDATA 0x00002000 // Check metadata + data checksums // internally used flags, don't use these -#define LFS_o_TYPE 0xf0000000 // The file's type -#define LFS_o_ZOMBIE 0x08000000 // File has been removed -#define LFS_o_UNCREAT 0x02000000 // File does not exist yet -#define LFS_o_UNSYNC 0x01000000 // File's metadata does not match disk -#define LFS_o_UNCRYST 0x00800000 // File's leaf not fully crystallized -#define LFS_o_UNGRAFT 0x00400000 // File's leaf does not match bshrub/btree -#define LFS_o_UNFLUSH 0x00200000 // File's data does not match disk +#define LFS3_o_TYPE 0xf0000000 // The file's type +#define LFS3_o_ZOMBIE 0x08000000 // File has been removed +#define LFS3_o_UNCREAT 0x02000000 // File does not exist yet +#define LFS3_o_UNSYNC 0x01000000 // File's metadata does not match disk +#define LFS3_o_UNCRYST 0x00800000 // File's leaf not fully crystallized +#define LFS3_o_UNGRAFT 0x00400000 // File's leaf does not match bshrub/btree +#define LFS3_o_UNFLUSH 0x00200000 // File's data does not match disk // File seek flags -#define LFS_SEEK_SET 0 // Seek relative to an absolute position -#define LFS_SEEK_CUR 1 // Seek relative to the current file position -#define LFS_SEEK_END 2 // Seek relative to the end of the file +#define LFS3_SEEK_SET 0 // Seek relative to an absolute position +#define LFS3_SEEK_CUR 1 // Seek relative to the current file position +#define LFS3_SEEK_END 2 // Seek relative to the end of the file // Custom attribute flags -#define LFS_A_MODE 3 // The attr's access mode -#define LFS_A_RDONLY 0 // Open an attr as read only -#define LFS_A_WRONLY 1 // Open an attr as write only -#define LFS_A_RDWR 2 // Open an attr as read and write -#define LFS_A_LAZY 0x04 // Only write attr if file changed +#define LFS3_A_MODE 3 // The attr's access mode +#define LFS3_A_RDONLY 0 // Open an attr as read only +#define LFS3_A_WRONLY 1 // Open an attr as write only +#define LFS3_A_RDWR 2 // Open an attr as read and write +#define LFS3_A_LAZY 0x04 // Only write attr if file changed // Filesystem format flags -#define LFS_F_MODE 1 // Format's access mode -#define LFS_F_RDWR 0 // Format the filesystem as read and write -#ifdef LFS_REVDBG -#define LFS_F_REVDBG 0x00000010 // Add debug info to revision counts +#define LFS3_F_MODE 1 // Format's access mode +#define LFS3_F_RDWR 0 // Format the filesystem as read and write +#ifdef LFS3_REVDBG +#define LFS3_F_REVDBG 0x00000010 // Add debug info to revision counts #endif -#ifdef LFS_REVNOISE -#define LFS_F_REVNOISE 0x00000020 // Add noise to revision counts +#ifdef LFS3_REVNOISE +#define LFS3_F_REVNOISE 0x00000020 // Add noise to revision counts #endif -#ifdef LFS_CKPROGS -#define LFS_F_CKPROGS 0x00080000 // Check progs by reading back progged data +#ifdef LFS3_CKPROGS +#define LFS3_F_CKPROGS 0x00080000 // Check progs by reading back progged data #endif -#ifdef LFS_CKFETCHES -#define LFS_F_CKFETCHES 0x00100000 // Check block checksums before first use +#ifdef LFS3_CKFETCHES +#define LFS3_F_CKFETCHES \ + 0x00100000 // Check block checksums before first use #endif -#ifdef LFS_CKMETAPARITY -#define LFS_F_CKMETAPARITY \ +#ifdef LFS3_CKMETAPARITY +#define LFS3_F_CKMETAPARITY \ 0x00200000 // Check metadata tag parity bits #endif -#ifdef LFS_CKDATACKSUMREADS -#define LFS_F_CKDATACKSUMREADS \ +#ifdef LFS3_CKDATACKSUMREADS +#define LFS3_F_CKDATACKSUMREADS \ 0x00800000 // Check data checksums on reads #endif -#define LFS_F_CKMETA 0x00001000 // Check metadata checksums -#define LFS_F_CKDATA 0x00002000 // Check metadata + data checksums +#define LFS3_F_CKMETA 0x00001000 // Check metadata checksums +#define LFS3_F_CKDATA 0x00002000 // Check metadata + data checksums // Filesystem mount flags -#define LFS_M_MODE 1 // Mount's access mode -#define LFS_M_RDWR 0 // Mount the filesystem as read and write -#define LFS_M_RDONLY 1 // Mount the filesystem as read only -#define LFS_M_FLUSH 0x00000040 // Open all files with LFS_O_FLUSH -#define LFS_M_SYNC 0x00000080 // Open all files with LFS_O_SYNC -#ifdef LFS_REVDBG -#define LFS_M_REVDBG 0x00000010 // Add debug info to revision counts +#define LFS3_M_MODE 1 // Mount's access mode +#define LFS3_M_RDWR 0 // Mount the filesystem as read and write +#define LFS3_M_RDONLY 1 // Mount the filesystem as read only +#define LFS3_M_FLUSH 0x00000040 // Open all files with LFS3_O_FLUSH +#define LFS3_M_SYNC 0x00000080 // Open all files with LFS3_O_SYNC +#ifdef LFS3_REVDBG +#define LFS3_M_REVDBG 0x00000010 // Add debug info to revision counts #endif -#ifdef LFS_REVNOISE -#define LFS_M_REVNOISE 0x00000020 // Add noise to revision counts +#ifdef LFS3_REVNOISE +#define LFS3_M_REVNOISE 0x00000020 // Add noise to revision counts #endif -#ifdef LFS_CKPROGS -#define LFS_M_CKPROGS 0x00080000 // Check progs by reading back progged data +#ifdef LFS3_CKPROGS +#define LFS3_M_CKPROGS 0x00080000 // Check progs by reading back progged data #endif -#ifdef LFS_CKFETCHES -#define LFS_M_CKFETCHES 0x00100000 // Check block checksums before first use +#ifdef LFS3_CKFETCHES +#define LFS3_M_CKFETCHES \ + 0x00100000 // Check block checksums before first use #endif -#ifdef LFS_CKMETAPARITY -#define LFS_M_CKMETAPARITY \ +#ifdef LFS3_CKMETAPARITY +#define LFS3_M_CKMETAPARITY \ 0x00200000 // Check metadata tag parity bits #endif -#ifdef LFS_CKDATACKSUMREADS -#define LFS_M_CKDATACKSUMREADS \ +#ifdef LFS3_CKDATACKSUMREADS +#define LFS3_M_CKDATACKSUMREADS \ 0x00800000 // Check data checksums on reads #endif -#define LFS_M_MKCONSISTENT \ +#define LFS3_M_MKCONSISTENT \ 0x00000100 // Make the filesystem consistent -#define LFS_M_LOOKAHEAD 0x00000200 // Populate lookahead buffer -#define LFS_M_COMPACT 0x00000800 // Compact metadata logs -#define LFS_M_CKMETA 0x00001000 // Check metadata checksums -#define LFS_M_CKDATA 0x00002000 // Check metadata + data checksums +#define LFS3_M_LOOKAHEAD \ + 0x00000200 // Populate lookahead buffer +#define LFS3_M_COMPACT 0x00000800 // Compact metadata logs +#define LFS3_M_CKMETA 0x00001000 // Check metadata checksums +#define LFS3_M_CKDATA 0x00002000 // Check metadata + data checksums // Filesystem info flags -#define LFS_I_RDONLY 0x00000001 // Mounted read only -#define LFS_I_FLUSH 0x00000040 // Mounted with LFS_M_FLUSH -#define LFS_I_SYNC 0x00000080 // Mounted with LFS_M_SYNC -#ifdef LFS_REVDBG -#define LFS_I_REVDBG 0x00000010 // Mounted with LFS_M_REVDBG +#define LFS3_I_RDONLY 0x00000001 // Mounted read only +#define LFS3_I_FLUSH 0x00000040 // Mounted with LFS3_M_FLUSH +#define LFS3_I_SYNC 0x00000080 // Mounted with LFS3_M_SYNC +#ifdef LFS3_REVDBG +#define LFS3_I_REVDBG 0x00000010 // Mounted with LFS3_M_REVDBG #endif -#ifdef LFS_REVNOISE -#define LFS_I_REVNOISE 0x00000020 // Mounted with LFS_M_REVNOISE +#ifdef LFS3_REVNOISE +#define LFS3_I_REVNOISE 0x00000020 // Mounted with LFS3_M_REVNOISE #endif -#ifdef LFS_CKPROGS -#define LFS_I_CKPROGS 0x00080000 // Mounted with LFS_M_CKPROGS +#ifdef LFS3_CKPROGS +#define LFS3_I_CKPROGS 0x00080000 // Mounted with LFS3_M_CKPROGS #endif -#ifdef LFS_CKFETCHES -#define LFS_I_CKFETCHES 0x00100000 // Mounted with LFS_M_CKFETCHES +#ifdef LFS3_CKFETCHES +#define LFS3_I_CKFETCHES \ + 0x00100000 // Mounted with LFS3_M_CKFETCHES #endif -#ifdef LFS_CKMETAPARITY -#define LFS_I_CKMETAPARITY \ - 0x00200000 // Mounted with LFS_M_CKMETAPARITY +#ifdef LFS3_CKMETAPARITY +#define LFS3_I_CKMETAPARITY \ + 0x00200000 // Mounted with LFS3_M_CKMETAPARITY #endif -#ifdef LFS_CKDATACKSUMREADS -#define LFS_I_CKDATACKSUMREADS \ - 0x00800000 // Mounted with LFS_M_CKDATACKSUMREADS +#ifdef LFS3_CKDATACKSUMREADS +#define LFS3_I_CKDATACKSUMREADS \ + 0x00800000 // Mounted with LFS3_M_CKDATACKSUMREADS #endif -#define LFS_I_MKCONSISTENT \ +#define LFS3_I_MKCONSISTENT \ 0x00000100 // Filesystem needs mkconsistent to write -#define LFS_I_LOOKAHEAD 0x00000200 // Lookahead buffer is not full -#define LFS_I_COMPACT 0x00000800 // Filesystem may have uncompacted metadata -#define LFS_I_CKMETA 0x00001000 // Metadata checksums not checked recently -#define LFS_I_CKDATA 0x00002000 // Data checksums not checked recently +#define LFS3_I_LOOKAHEAD \ + 0x00000200 // Lookahead buffer is not full +#define LFS3_I_COMPACT 0x00000800 // Filesystem may have uncompacted metadata +#define LFS3_I_CKMETA 0x00001000 // Metadata checksums not checked recently +#define LFS3_I_CKDATA 0x00002000 // Data checksums not checked recently // internally used flags, don't use these -#ifdef LFS_REVDBG -#define LFS_i_INMTREE 0x08000000 // Committing to mtree +#ifdef LFS3_REVDBG +#define LFS3_i_INMTREE 0x08000000 // Committing to mtree #endif // Block types -enum lfs_btype { - LFS_BTYPE_MDIR = 1, - LFS_BTYPE_BTREE = 2, - LFS_BTYPE_DATA = 3, +enum lfs3_btype { + LFS3_BTYPE_MDIR = 1, + LFS3_BTYPE_BTREE = 2, + LFS3_BTYPE_DATA = 3, }; // Traversal flags -#define LFS_T_MODE 1 // The traversal's access mode -#define LFS_T_RDWR 0 // Open traversal as read and write -#define LFS_T_RDONLY 1 // Open traversal as read only -#define LFS_T_MTREEONLY 0x00000002 // Only traverse the mtree -#define LFS_T_MKCONSISTENT \ +#define LFS3_T_MODE 1 // The traversal's access mode +#define LFS3_T_RDWR 0 // Open traversal as read and write +#define LFS3_T_RDONLY 1 // Open traversal as read only +#define LFS3_T_MTREEONLY \ + 0x00000002 // Only traverse the mtree +#define LFS3_T_MKCONSISTENT \ 0x00000100 // Make the filesystem consistent -#define LFS_T_LOOKAHEAD 0x00000200 // Populate lookahead buffer -#define LFS_T_COMPACT 0x00000800 // Compact metadata logs -#define LFS_T_CKMETA 0x00001000 // Check metadata checksums -#define LFS_T_CKDATA 0x00002000 // Check metadata + data checksums +#define LFS3_T_LOOKAHEAD \ + 0x00000200 // Populate lookahead buffer +#define LFS3_T_COMPACT 0x00000800 // Compact metadata logs +#define LFS3_T_CKMETA 0x00001000 // Check metadata checksums +#define LFS3_T_CKDATA 0x00002000 // Check metadata + data checksums // internally used flags, don't use these -#define LFS_t_TYPE 0xf0000000 // The traversal's type -#define LFS_t_TSTATE 0x000f0000 // The current traversal state -#define LFS_t_BTYPE 0x00f00000 // The current block type -#define LFS_t_ZOMBIE 0x08000000 // File has been removed -#define LFS_t_DIRTY 0x02000000 // Filesystem modified during traversal -#define LFS_t_MUTATED 0x01000000 // Filesystem modified by traversal +#define LFS3_t_TYPE 0xf0000000 // The traversal's type +#define LFS3_t_TSTATE 0x000f0000 // The current traversal state +#define LFS3_t_BTYPE 0x00f00000 // The current block type +#define LFS3_t_ZOMBIE 0x08000000 // File has been removed +#define LFS3_t_DIRTY 0x02000000 // Filesystem modified during traversal +#define LFS3_t_MUTATED 0x01000000 // Filesystem modified by traversal // GC flags -#define LFS_GC_MKCONSISTENT \ +#define LFS3_GC_MKCONSISTENT \ 0x00000100 // Make the filesystem consistent -#define LFS_GC_LOOKAHEAD \ +#define LFS3_GC_LOOKAHEAD \ 0x00000200 // Populate lookahead buffer -#define LFS_GC_COMPACT 0x00000800 // Compact metadata logs -#define LFS_GC_CKMETA 0x00001000 // Check metadata checksums -#define LFS_GC_CKDATA 0x00002000 // Check metadata + data checksums +#define LFS3_GC_COMPACT 0x00000800 // Compact metadata logs +#define LFS3_GC_CKMETA 0x00001000 // Check metadata checksums +#define LFS3_GC_CKDATA 0x00002000 // Check metadata + data checksums // Configuration provided during initialization of the littlefs -struct lfs_config { +struct lfs3_config { // Opaque user provided context that can be used to pass // information to the block device operations void *context; // Read a region in a block. Negative error codes are propagated // to the user. - int (*read)(const struct lfs_config *c, lfs_block_t block, - lfs_off_t off, void *buffer, lfs_size_t size); + int (*read)(const struct lfs3_config *c, lfs3_block_t block, + lfs3_off_t off, void *buffer, lfs3_size_t size); // Program a region in a block. The block must have previously // been erased. Negative error codes are propagated to the user. - // May return LFS_ERR_CORRUPT if the block should be considered bad. - int (*prog)(const struct lfs_config *c, lfs_block_t block, - lfs_off_t off, const void *buffer, lfs_size_t size); + // May return LFS3_ERR_CORRUPT if the block should be considered bad. + int (*prog)(const struct lfs3_config *c, lfs3_block_t block, + lfs3_off_t off, const void *buffer, lfs3_size_t size); // Erase a block. A block must be erased before being programmed. // The state of an erased block is undefined. Negative error codes // are propagated to the user. - // May return LFS_ERR_CORRUPT if the block should be considered bad. - int (*erase)(const struct lfs_config *c, lfs_block_t block); + // May return LFS3_ERR_CORRUPT if the block should be considered bad. + int (*erase)(const struct lfs3_config *c, lfs3_block_t block); // Sync the state of the underlying block device. Negative error codes // are propagated to the user. - int (*sync)(const struct lfs_config *c); + int (*sync)(const struct lfs3_config *c); -#ifdef LFS_THREADSAFE +#ifdef LFS3_THREADSAFE // Lock the underlying block device. Negative error codes // are propagated to the user. - int (*lock)(const struct lfs_config *c); + int (*lock)(const struct lfs3_config *c); // Unlock the underlying block device. Negative error codes // are propagated to the user. - int (*unlock)(const struct lfs_config *c); + int (*unlock)(const struct lfs3_config *c); #endif // Minimum size of a read in bytes. All read operations will be a // multiple of this value. - lfs_size_t read_size; + lfs3_size_t read_size; // Minimum size of a program in bytes. All program operations will be a // multiple of this value. - lfs_size_t prog_size; + lfs3_size_t prog_size; // Size of an erasable block in bytes. This does not impact ram consumption // and may be larger than the physical erase size. Must be a multiple of // the read and program sizes. - lfs_size_t block_size; + lfs3_size_t block_size; // Number of erasable blocks on the device. - lfs_size_t block_count; + lfs3_size_t block_count; // Number of erase cycles before metadata blocks are relocated for // wear-leveling. Suggested values are in the range 16-1024. Larger values @@ -349,31 +356,31 @@ struct lfs_config { // Size of the read cache in bytes. Larger caches can improve // performance by storing more data and reducing the number of disk // accesses. Must be a multiple of the read size. - lfs_size_t rcache_size; + lfs3_size_t rcache_size; // Size of the program cache in bytes. Larger caches can improve // performance by storing more data and reducing the number of disk // accesses. Must be a multiple of the program size. - lfs_size_t pcache_size; + lfs3_size_t pcache_size; // Size of file caches in bytes. In addition to filesystem-wide // read/prog caches, each file gets its own cache to reduce disk // accesses. - lfs_size_t file_cache_size; + lfs3_size_t file_cache_size; // Size of the lookahead buffer in bytes. A larger lookahead buffer // increases the number of blocks found during an allocation pass. The // lookahead buffer is stored as a compact bitmap, so each byte of RAM // can track 8 blocks. - lfs_size_t lookahead_size; + lfs3_size_t lookahead_size; - #ifdef LFS_GC - // Flags indicating what gc work to do during lfsr_gc calls. + #ifdef LFS3_GC + // Flags indicating what gc work to do during lfs3_gc calls. uint32_t gc_flags; #endif - #ifdef LFS_GC - // Number of gc steps to perform in each call to lfsr_gc, with each + #ifdef LFS3_GC + // Number of gc steps to perform in each call to lfs3_gc, with each // step being ~1 block of work. // // More steps per call will make more progress if interleaved with @@ -383,7 +390,7 @@ struct lfs_config { // been completed. // // Defaults to steps=1 when zero. - lfs_soff_t gc_steps; + lfs3_soff_t gc_steps; #endif // Threshold for metadata compaction during gc in bytes. Metadata logs @@ -395,30 +402,30 @@ struct lfs_config { // only compacted when full. // // Set to -1 to disable metadata compaction during gc. - lfs_size_t gc_compact_thresh; + lfs3_size_t gc_compact_thresh; // Optional statically allocated rcache buffer. Must be rcache_size. By - // default lfs_malloc is used to allocate this buffer. + // default lfs3_malloc is used to allocate this buffer. void *rcache_buffer; // Optional statically allocated pcache buffer. Must be pcache_size. By - // default lfs_malloc is used to allocate this buffer. + // default lfs3_malloc is used to allocate this buffer. void *pcache_buffer; // Optional statically allocated lookahead buffer. Must be lookahead_size. - // By default lfs_malloc is used to allocate this buffer. + // By default lfs3_malloc is used to allocate this buffer. void *lookahead_buffer; // Optional upper limit on length of file names in bytes. No downside for // larger names except the size of the info struct which is controlled by - // the LFS_NAME_MAX define. Defaults to LFS_NAME_MAX when zero. Stored in + // the LFS3_NAME_MAX define. Defaults to LFS3_NAME_MAX when zero. Stored in // superblock and must be respected by other littlefs drivers. - lfs_size_t name_limit; + lfs3_size_t name_limit; // Optional upper limit on files in bytes. No downside for larger files - // but must be <= LFS_FILE_MAX. Defaults to LFS_FILE_MAX when zero. Stored + // but must be <= LFS3_FILE_MAX. Defaults to LFS3_FILE_MAX when zero. Stored // in superblock and must be respected by other littlefs drivers. - lfs_size_t file_limit; + lfs3_size_t file_limit; // TODO these are pretty low-level details, should we have reasonable // defaults? need to benchmark. @@ -428,12 +435,12 @@ struct lfs_config { // blocksize/4. // // 0 disables shrubs. - lfs_size_t inline_size; + lfs3_size_t inline_size; // Maximum size of a non-block B-tree leaf in bytes. Smaller values may // make small random-writes cheaper, but increase metadata overhead. Must // be <= block_size/4. - lfs_size_t fragment_size; + lfs3_size_t fragment_size; // Threshold for compacting multiple fragments into a block. Smaller // values will crystallize more eagerly, reducing disk usage, but @@ -441,7 +448,7 @@ struct lfs_config { // // 0 only writes blocks, minimizing disk usage, while -1 or any value > // block_size only writes fragments, minimizing random-write cost. - lfs_size_t crystal_thresh; + lfs3_size_t crystal_thresh; // Threshold for breaking a block into fragments. Smaller values will // fragment more lazily, reducing random-write cost, but risk higher @@ -454,54 +461,54 @@ struct lfs_config { // // 0 will never fragment a block once compacted, while -1 will fragment // as soon as a block drops below crystal_thresh. - lfs_size_t fragment_thresh; + lfs3_size_t fragment_thresh; }; // File info structure -struct lfs_info { - // Type of the file, either LFS_TYPE_REG or LFS_TYPE_DIR +struct lfs3_info { + // Type of the file, either LFS3_TYPE_REG or LFS3_TYPE_DIR uint8_t type; // Size of the file, only valid for REG files. Limited to 32-bits. - lfs_size_t size; + lfs3_size_t size; // Name of the file stored as a null-terminated string. Limited to - // LFS_NAME_MAX+1, which can be changed by redefining LFS_NAME_MAX to - // reduce RAM. LFS_NAME_MAX is stored in superblock and must be + // LFS3_NAME_MAX+1, which can be changed by redefining LFS3_NAME_MAX to + // reduce RAM. LFS3_NAME_MAX is stored in superblock and must be // respected by other littlefs drivers. - char name[LFS_NAME_MAX+1]; + char name[LFS3_NAME_MAX+1]; }; // Filesystem info structure -struct lfs_fsinfo { +struct lfs3_fsinfo { // Filesystem flags uint32_t flags; // Size of a logical block in bytes. - lfs_size_t block_size; + lfs3_size_t block_size; // Number of logical blocks in the filesystem. - lfs_size_t block_count; + lfs3_size_t block_count; // Upper limit on the length of file names in bytes. - lfs_size_t name_limit; + lfs3_size_t name_limit; // Upper limit on the size of files in bytes. - lfs_size_t file_limit; + lfs3_size_t file_limit; }; // Traversal info structure -struct lfs_tinfo { +struct lfs3_tinfo { // Type of the block uint8_t btype; // Block address - lfs_block_t block; + lfs3_block_t block; }; // Custom attribute structure, used to describe custom attributes // committed atomically during file writes. -struct lfs_attr { +struct lfs3_attr { // Type of attribute // // Note some of this range is reserved: @@ -516,35 +523,35 @@ struct lfs_attr { void *buffer; // Size of the attr buffer in bytes, this can be set to - // LFS_ERR_NOATTR to remove the attr - lfs_ssize_t buffer_size; + // LFS3_ERR_NOATTR to remove the attr + lfs3_ssize_t buffer_size; // Optional pointer to a mutable attr size, updated on read/write, - // set to LFS_ERR_NOATTR if attr does not exist + // set to LFS3_ERR_NOATTR if attr does not exist // // Defaults to buffer_size if NULL - lfs_ssize_t *size; + lfs3_ssize_t *size; }; -// Optional configuration provided during lfs_file_opencfg -struct lfs_file_config { +// Optional configuration provided during lfs3_file_opencfg +struct lfs3_file_config { // Optional statically allocated file cache buffer. Must be cache_size. - // By default lfs_malloc is used to allocate this buffer. + // By default lfs3_malloc is used to allocate this buffer. void *cache_buffer; // Size of the file cache in bytes. In addition to filesystem-wide // read/prog caches, each file gets its own cache to reduce disk // accesses. Defaults to file_cache_size. - lfs_size_t cache_size; + lfs3_size_t cache_size; // Optional list of custom attributes attached to the file. If readable, // these attributes will be kept up to date with the attributes on-disk. // If writeable, these attributes will be written to disk atomically on // every file sync or close. - struct lfs_attr *attrs; + struct lfs3_attr *attrs; // Number of custom attributes in the list - lfs_size_t attr_count; + lfs3_size_t attr_count; }; @@ -555,151 +562,151 @@ struct lfs_file_config { // note, it's tempting to make this fancier, but we benefit quite a lot // from the compiler being able to aggresively optimize this struct // -typedef struct lfsr_data { +typedef struct lfs3_data { // sign2(size)=0b00 => in-RAM buffer // sign2(size)=0b10 => on-disk data // sign2(size)=0b11 => on-disk data + cksum - lfs_size_t size; + lfs3_size_t size; union { const uint8_t *buffer; struct { - lfs_block_t block; - lfs_size_t off; - #ifdef LFS_CKDATACKSUMREADS + lfs3_block_t block; + lfs3_size_t off; + #ifdef LFS3_CKDATACKSUMREADS // optional context for validating data // sign(cksize)=0 => block not erased // sign(cksize)=1 => block erased - lfs_size_t cksize; + lfs3_size_t cksize; uint32_t cksum; #endif } disk; } u; -} lfsr_data_t; +} lfs3_data_t; // a possible block pointer -typedef struct lfsr_bptr { +typedef struct lfs3_bptr { // sign2(size)=0b00 => in-RAM buffer // sign2(size)=0b10 => on-disk data // sign2(size)=0b11 => block pointer - lfsr_data_t data; - #ifndef LFS_CKDATACKSUMREADS + lfs3_data_t data; + #ifndef LFS3_CKDATACKSUMREADS // sign(cksize)=0 => block not erased // sign(cksize)=1 => block erased - lfs_size_t cksize; + lfs3_size_t cksize; uint32_t cksum; #endif -} lfsr_bptr_t; +} lfs3_bptr_t; // littlefs's core metadata log type -typedef struct lfsr_rbyd { - lfsr_rid_t weight; - lfs_block_t blocks[2]; +typedef struct lfs3_rbyd { + lfs3_rid_t weight; + lfs3_block_t blocks[2]; // sign(trunk)=0 => normal rbyd // sign(trunk)=1 => shrub rbyd - lfs_size_t trunk; + lfs3_size_t trunk; // sign(eoff) => perturb bit // eoff=0, trunk=0 => not yet committed // eoff=0, trunk>0 => not yet fetched // eoff>=block_size => rbyd not erased/needs compaction - lfs_size_t eoff; + lfs3_size_t eoff; uint32_t cksum; -} lfsr_rbyd_t; +} lfs3_rbyd_t; // a btree is represented by the root rbyd -typedef lfsr_rbyd_t lfsr_btree_t; +typedef lfs3_rbyd_t lfs3_btree_t; // littlefs's atomic metadata log type -typedef struct lfsr_mdir { - lfsr_smid_t mid; - lfsr_rbyd_t rbyd; +typedef struct lfs3_mdir { + lfs3_smid_t mid; + lfs3_rbyd_t rbyd; uint32_t gcksumdelta; -} lfsr_mdir_t; +} lfs3_mdir_t; -typedef struct lfsr_omdir { - struct lfsr_omdir *next; +typedef struct lfs3_omdir { + struct lfs3_omdir *next; uint32_t flags; - lfsr_mdir_t mdir; -} lfsr_omdir_t; + lfs3_mdir_t mdir; +} lfs3_omdir_t; // a shrub is a secondary trunk in an mdir -typedef lfsr_rbyd_t lfsr_shrub_t; +typedef lfs3_rbyd_t lfs3_shrub_t; // a bshrub is like a btree but with a shrub as a root -typedef struct lfsr_bshrub { +typedef struct lfs3_bshrub { // bshrubs need to be tracked for commits to work - lfsr_omdir_t o; + lfs3_omdir_t o; // files contain both an active bshrub and staging bshrub, to allow // staging during mdir compacts // trunk=0 => no bshrub/btree // sign(trunk)=1 => bshrub // sign(trunk)=0 => btree - lfsr_shrub_t shrub; - lfsr_shrub_t shrub_; -} lfsr_bshrub_t; + lfs3_shrub_t shrub; + lfs3_shrub_t shrub_; +} lfs3_bshrub_t; // littlefs file type -typedef struct lfsr_file { +typedef struct lfs3_file { // btree/bshrub stuff is in here - lfsr_bshrub_t b; - const struct lfs_file_config *cfg; + lfs3_bshrub_t b; + const struct lfs3_file_config *cfg; // current file position - lfs_off_t pos; + lfs3_off_t pos; // in-RAM cache // - // note this lines up with lfsr_data_t's buffer representation + // note this lines up with lfs3_data_t's buffer representation struct { - lfs_off_t size; + lfs3_off_t size; uint8_t *buffer; - lfs_off_t pos; + lfs3_off_t pos; } cache; // on-disk leaf bptr struct { - lfs_off_t pos; - lfs_off_t weight; - lfsr_bptr_t bptr; + lfs3_off_t pos; + lfs3_off_t weight; + lfs3_bptr_t bptr; } leaf; -} lfsr_file_t; +} lfs3_file_t; // littlefs directory type -typedef struct lfsr_dir { - lfsr_omdir_t o; - lfsr_did_t did; - lfs_off_t pos; -} lfsr_dir_t; +typedef struct lfs3_dir { + lfs3_omdir_t o; + lfs3_did_t did; + lfs3_off_t pos; +} lfs3_dir_t; -typedef struct lfsr_btraversal { - lfsr_bid_t bid; - const lfsr_rbyd_t *branch; - lfsr_srid_t rid; - lfsr_rbyd_t rbyd; -} lfsr_btraversal_t; +typedef struct lfs3_btraversal { + lfs3_bid_t bid; + const lfs3_rbyd_t *branch; + lfs3_srid_t rid; + lfs3_rbyd_t rbyd; +} lfs3_btraversal_t; // littlefs traversal type -typedef struct lfsr_traversal { +typedef struct lfs3_traversal { // mdir/bshrub/btree state, this also includes our traversal // state machine - lfsr_bshrub_t b; + lfs3_bshrub_t b; // opened file state - lfsr_omdir_t *ot; + lfs3_omdir_t *ot; union { // cycle detection state, only valid when traversing the mroot chain struct { - lfs_block_t blocks[2]; - lfs_block_t step; + lfs3_block_t blocks[2]; + lfs3_block_t step; uint8_t power; } mtortoise; // btree traversal state - lfsr_btraversal_t bt; + lfs3_btraversal_t bt; } u; // recalculate gcksum when traversing with ckmeta uint32_t gcksum; - // pending blocks, only used in lfsr_traversal_read - lfs_sblock_t blocks[2]; -} lfsr_traversal_t; + // pending blocks, only used in lfs3_traversal_read + lfs3_sblock_t blocks[2]; +} lfs3_traversal_t; // grm encoding: // .- -+- -+- -+- -+- -. mids: 2 leb128s <=2x5 bytes @@ -708,20 +715,20 @@ typedef struct lfsr_traversal { // ' ' // '- -+- -+- -+- -+- -' // -#define LFSR_GRM_DSIZE (5+5) +#define LFS3_GRM_DSIZE (5+5) -typedef struct lfsr_grm { - lfsr_smid_t queue[2]; -} lfsr_grm_t; +typedef struct lfs3_grm { + lfs3_smid_t queue[2]; +} lfs3_grm_t; // The littlefs filesystem type -typedef struct lfs { - const struct lfs_config *cfg; +typedef struct lfs3 { + const struct lfs3_config *cfg; uint32_t flags; - lfs_size_t block_count; - lfs_size_t name_limit; - lfs_off_t file_limit; + lfs3_size_t block_count; + lfs3_size_t name_limit; + lfs3_off_t file_limit; int8_t recycle_bits; uint8_t mbits; @@ -729,38 +736,38 @@ typedef struct lfs { uint8_t mattr_estimate; // linked-list of opened mdirs - lfsr_omdir_t *omdirs; + lfs3_omdir_t *omdirs; - lfsr_mdir_t mroot; - lfsr_btree_t mtree; + lfs3_mdir_t mroot; + lfs3_btree_t mtree; - struct lfsr_rcache { - lfs_block_t block; - lfs_size_t off; - lfs_size_t size; + struct lfs3_rcache { + lfs3_block_t block; + lfs3_size_t off; + lfs3_size_t size; uint8_t *buffer; } rcache; - struct lfsr_pcache { - lfs_block_t block; - lfs_size_t off; - lfs_size_t size; + struct lfs3_pcache { + lfs3_block_t block; + lfs3_size_t off; + lfs3_size_t size; uint8_t *buffer; } pcache; - #ifdef LFS_CKMETAPARITY + #ifdef LFS3_CKMETAPARITY struct { - lfs_block_t block; + lfs3_block_t block; // sign(off) => tail parity - lfs_size_t off; + lfs3_size_t off; } ptail; #endif - struct lfs_lookahead { - lfs_block_t window; - lfs_block_t off; - lfs_block_t size; - lfs_block_t ckpoint; + struct lfs3_lookahead { + lfs3_block_t window; + lfs3_block_t off; + lfs3_block_t size; + lfs3_block_t ckpoint; uint8_t *buffer; } lookahead; @@ -769,22 +776,22 @@ typedef struct lfs { uint32_t gcksum_p; uint32_t gcksum_d; - lfsr_grm_t grm; - uint8_t grm_p[LFSR_GRM_DSIZE]; - uint8_t grm_d[LFSR_GRM_DSIZE]; + lfs3_grm_t grm; + uint8_t grm_p[LFS3_GRM_DSIZE]; + uint8_t grm_d[LFS3_GRM_DSIZE]; - #ifdef LFS_GC + #ifdef LFS3_GC // optional incremental gc state struct { - lfsr_traversal_t t; + lfs3_traversal_t t; } gc; #endif -} lfs_t; +} lfs3_t; /// Filesystem functions /// -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Format a block device with the littlefs // // Requires a littlefs object and config struct. This clobbers the littlefs @@ -792,111 +799,111 @@ typedef struct lfs { // be zeroed for defaults and backwards compatibility. // // Returns a negative error code on failure. -int lfsr_format(lfs_t *lfs, uint32_t flags, - const struct lfs_config *cfg); +int lfs3_format(lfs3_t *lfs3, uint32_t flags, + const struct lfs3_config *cfg); #endif // Mounts a littlefs // // Requires a littlefs object and config struct. Multiple filesystems // may be mounted simultaneously with multiple littlefs objects. Both -// lfs and config must be allocated while mounted. The config struct must +// lfs3 and config must be allocated while mounted. The config struct must // be zeroed for defaults and backwards compatibility. // // Returns a negative error code on failure. -int lfsr_mount(lfs_t *lfs, uint32_t flags, - const struct lfs_config *cfg); +int lfs3_mount(lfs3_t *lfs3, uint32_t flags, + const struct lfs3_config *cfg); // Unmounts a littlefs // // Does nothing besides releasing any allocated resources. // Returns a negative error code on failure. -int lfsr_unmount(lfs_t *lfs); +int lfs3_unmount(lfs3_t *lfs3); /// General operations /// -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Removes a file or directory // // If removing a directory, the directory must be empty. // Returns a negative error code on failure. -int lfsr_remove(lfs_t *lfs, const char *path); +int lfs3_remove(lfs3_t *lfs3, const char *path); #endif -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Rename or move a file or directory // // If the destination exists, it must match the source in type. // If the destination is a directory, the directory must be empty. // // Returns a negative error code on failure. -int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path); +int lfs3_rename(lfs3_t *lfs3, const char *old_path, const char *new_path); #endif // Find info about a file or directory // // Fills out the info structure, based on the specified file or directory. // Returns a negative error code on failure. -int lfsr_stat(lfs_t *lfs, const char *path, struct lfs_info *info); +int lfs3_stat(lfs3_t *lfs3, const char *path, struct lfs3_info *info); // Get a custom attribute // // Returns the number of bytes read, or a negative error code on failure. // Note this may be less than the on-disk attr size if the buffer is not // large enough. -lfs_ssize_t lfsr_getattr(lfs_t *lfs, const char *path, uint8_t type, - void *buffer, lfs_size_t size); +lfs3_ssize_t lfs3_getattr(lfs3_t *lfs3, const char *path, uint8_t type, + void *buffer, lfs3_size_t size); // Get a custom attribute's size // // Returns the size of the attribute, or a negative error code on failure. -lfs_ssize_t lfsr_sizeattr(lfs_t *lfs, const char *path, uint8_t type); +lfs3_ssize_t lfs3_sizeattr(lfs3_t *lfs3, const char *path, uint8_t type); -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Set a custom attributes // // Returns a negative error code on failure. -int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type, - const void *buffer, lfs_size_t size); +int lfs3_setattr(lfs3_t *lfs3, const char *path, uint8_t type, + const void *buffer, lfs3_size_t size); #endif -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Removes a custom attribute // // Returns a negative error code on failure. -int lfsr_removeattr(lfs_t *lfs, const char *path, uint8_t type); +int lfs3_removeattr(lfs3_t *lfs3, const char *path, uint8_t type); #endif /// File operations /// -#ifndef LFS_NO_MALLOC +#ifndef LFS3_NO_MALLOC // Open a file // // The mode that the file is opened in is determined by the flags, which -// are values from the enum lfs_open_flags that are bitwise-ored together. +// are values from the enum lfs3_open_flags that are bitwise-ored together. // // Returns a negative error code on failure. -int lfsr_file_open(lfs_t *lfs, lfsr_file_t *file, +int lfs3_file_open(lfs3_t *lfs3, lfs3_file_t *file, const char *path, uint32_t flags); -// if LFS_NO_MALLOC is defined, lfs_file_open() will fail with LFS_ERR_NOMEM -// thus use lfs_file_opencfg() with config.buffer set. +// if LFS3_NO_MALLOC is defined, lfs3_file_open() will fail with LFS3_ERR_NOMEM +// thus use lfs3_file_opencfg() with config.buffer set. #endif // Open a file with extra configuration // // The mode that the file is opened in is determined by the flags, which -// are values from the enum lfs_open_flags that are bitwise-ored together. +// are values from the enum lfs3_open_flags that are bitwise-ored together. // // The config struct provides additional config options per file as described // above. The config struct must remain allocated while the file is open, and // the config struct must be zeroed for defaults and backwards compatibility. // // Returns a negative error code on failure. -int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, +int lfs3_file_opencfg(lfs3_t *lfs3, lfs3_file_t *file, const char *path, uint32_t flags, - const struct lfs_file_config *cfg); + const struct lfs3_file_config *cfg); // Close a file // @@ -909,7 +916,7 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, // return 0. // // Returns a negative error code on failure. -int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_close(lfs3_t *lfs3, lfs3_file_t *file); // Synchronize a file on storage // @@ -919,16 +926,16 @@ int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file); // now recieve file updates and syncs on close. // // Returns a negative error code on failure. -int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_sync(lfs3_t *lfs3, lfs3_file_t *file); // Flush any buffered data // -// This does not update metadata and is called implicitly by lfsr_file_sync. +// This does not update metadata and is called implicitly by lfs3_file_sync. // Calling this explicitly may be useful for preventing write errors in // read operations. // // Returns a negative error code on failure. -int lfsr_file_flush(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_flush(lfs3_t *lfs3, lfs3_file_t *file); // Mark a file as desynchronized // @@ -939,11 +946,11 @@ int lfsr_file_flush(lfs_t *lfs, lfsr_file_t *file); // If an error occurs during a write operation, the file is implicitly marked // as desynchronized. // -// An explicit and successful call to either lfsr_file_sync or -// lfsr_file_resync reverses this, marking the file as synchronized again. +// An explicit and successful call to either lfs3_file_sync or +// lfs3_file_resync reverses this, marking the file as synchronized again. // // Returns a negative error code on failure. -int lfsr_file_desync(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_desync(lfs3_t *lfs3, lfs3_file_t *file); // Discard unsynchronized changes and mark a file as synchronized // @@ -951,111 +958,111 @@ int lfsr_file_desync(lfs_t *lfs, lfsr_file_t *file); // may read from disk to figure out file state. // // Returns a negative error code on failure. -int lfsr_file_resync(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_resync(lfs3_t *lfs3, lfs3_file_t *file); // Read data from file // // Takes a buffer and size indicating where to store the read data. // Returns the number of bytes read, or a negative error code on failure. -lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, - void *buffer, lfs_size_t size); +lfs3_ssize_t lfs3_file_read(lfs3_t *lfs3, lfs3_file_t *file, + void *buffer, lfs3_size_t size); -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Write data to file // // Takes a buffer and size indicating the data to write. The file will not // actually be updated on the storage until either sync or close is called. // // Returns the number of bytes written, or a negative error code on failure. -lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, - const void *buffer, lfs_size_t size); +lfs3_ssize_t lfs3_file_write(lfs3_t *lfs3, lfs3_file_t *file, + const void *buffer, lfs3_size_t size); #endif // Change the position of the file // // The change in position is determined by the offset and whence flag. // Returns the new position of the file, or a negative error code on failure. -lfs_soff_t lfsr_file_seek(lfs_t *lfs, lfsr_file_t *file, - lfs_soff_t off, uint8_t whence); +lfs3_soff_t lfs3_file_seek(lfs3_t *lfs3, lfs3_file_t *file, + lfs3_soff_t off, uint8_t whence); -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Truncate/grow the size of the file to the specified size // // If size is larger than the current file size, a hole is created, appearing // as if the file was filled with zeros. // // Returns a negative error code on failure. -int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size); +int lfs3_file_truncate(lfs3_t *lfs3, lfs3_file_t *file, lfs3_off_t size); #endif -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Truncate/grow the file, but from the front // // If size is larger than the current file size, a hole is created, appearing // as if the file was filled with zeros. // // Returns a negative error code on failure. -int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size); +int lfs3_file_fruncate(lfs3_t *lfs3, lfs3_file_t *file, lfs3_off_t size); #endif // Return the position of the file // -// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_CUR) +// Equivalent to lfs3_file_seek(lfs3, file, 0, LFS3_SEEK_CUR) // Returns the position of the file, or a negative error code on failure. -lfs_soff_t lfsr_file_tell(lfs_t *lfs, lfsr_file_t *file); +lfs3_soff_t lfs3_file_tell(lfs3_t *lfs3, lfs3_file_t *file); // Change the position of the file to the beginning of the file // -// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_SET) +// Equivalent to lfs3_file_seek(lfs3, file, 0, LFS3_SEEK_SET) // Returns a negative error code on failure. -int lfsr_file_rewind(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_rewind(lfs3_t *lfs3, lfs3_file_t *file); // Return the size of the file // -// Similar to lfs_file_seek(lfs, file, 0, LFS_SEEK_END) +// Similar to lfs3_file_seek(lfs3, file, 0, LFS3_SEEK_END) // Returns the size of the file, or a negative error code on failure. -lfs_soff_t lfsr_file_size(lfs_t *lfs, lfsr_file_t *file); +lfs3_soff_t lfs3_file_size(lfs3_t *lfs3, lfs3_file_t *file); // Check a file for metadata errors // -// Returns LFS_ERR_CORRUPT if a checksum mismatch is found, or a negative +// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative // error code on failure. -int lfsr_file_ckmeta(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_ckmeta(lfs3_t *lfs3, lfs3_file_t *file); // Check a file for metadata + data errors // -// Returns LFS_ERR_CORRUPT if a checksum mismatch is found, or a negative +// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative // error code on failure. -int lfsr_file_ckdata(lfs_t *lfs, lfsr_file_t *file); +int lfs3_file_ckdata(lfs3_t *lfs3, lfs3_file_t *file); /// Directory operations /// -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Create a directory // // Returns a negative error code on failure. -int lfsr_mkdir(lfs_t *lfs, const char *path); +int lfs3_mkdir(lfs3_t *lfs3, const char *path); #endif // Open a directory // // Once open a directory can be used with read to iterate over files. // Returns a negative error code on failure. -int lfsr_dir_open(lfs_t *lfs, lfsr_dir_t *dir, const char *path); +int lfs3_dir_open(lfs3_t *lfs3, lfs3_dir_t *dir, const char *path); // Close a directory // // Releases any allocated resources. // Returns a negative error code on failure. -int lfsr_dir_close(lfs_t *lfs, lfsr_dir_t *dir); +int lfs3_dir_close(lfs3_t *lfs3, lfs3_dir_t *dir); // Read an entry in the directory // // Fills out the info structure, based on the specified file or directory. -// Returns 0 on success, LFS_ERR_NOENT at the end of directory, or a +// Returns 0 on success, LFS3_ERR_NOENT at the end of directory, or a // negative error code on failure. -int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info); +int lfs3_dir_read(lfs3_t *lfs3, lfs3_dir_t *dir, struct lfs3_info *info); // Change the position of the directory // @@ -1063,7 +1070,7 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info); // an absolute offset in the directory seek. // // Returns a negative error code on failure. -int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off); +int lfs3_dir_seek(lfs3_t *lfs3, lfs3_dir_t *dir, lfs3_soff_t off); // Return the position of the directory // @@ -1071,12 +1078,12 @@ int lfsr_dir_seek(lfs_t *lfs, lfsr_dir_t *dir, lfs_soff_t off); // sense, but does indicate the current position in the directory iteration. // // Returns the position of the directory, or a negative error code on failure. -lfs_soff_t lfsr_dir_tell(lfs_t *lfs, lfsr_dir_t *dir); +lfs3_soff_t lfs3_dir_tell(lfs3_t *lfs3, lfs3_dir_t *dir); // Change the position of the directory to the beginning of the directory // // Returns a negative error code on failure. -int lfsr_dir_rewind(lfs_t *lfs, lfsr_dir_t *dir); +int lfs3_dir_rewind(lfs3_t *lfs3, lfs3_dir_t *dir); /// Traversal operations /// @@ -1087,27 +1094,27 @@ int lfsr_dir_rewind(lfs_t *lfs, lfsr_dir_t *dir); // the filesystem. // // Returns a negative error code on failure. -int lfsr_traversal_open(lfs_t *lfs, lfsr_traversal_t *t, uint32_t flags); +int lfs3_traversal_open(lfs3_t *lfs3, lfs3_traversal_t *t, uint32_t flags); // Close a traversal // // Releases any allocated resources. // Returns a negative error code on failure. -int lfsr_traversal_close(lfs_t *lfs, lfsr_traversal_t *t); +int lfs3_traversal_close(lfs3_t *lfs3, lfs3_traversal_t *t); // Progress the traversal and read an entry // // Fills out the tinfo structure. // -// Returns 0 on success, LFS_ERR_NOENT at the end of traversal, or a +// Returns 0 on success, LFS3_ERR_NOENT at the end of traversal, or a // negative error code on failure. -int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *t, - struct lfs_tinfo *tinfo); +int lfs3_traversal_read(lfs3_t *lfs3, lfs3_traversal_t *t, + struct lfs3_tinfo *tinfo); // Reset the traversal // // Returns a negative error code on failure. -int lfsr_traversal_rewind(lfs_t *lfs, lfsr_traversal_t *t); +int lfs3_traversal_rewind(lfs3_t *lfs3, lfs3_traversal_t *t); /// Filesystem-level filesystem operations @@ -1116,7 +1123,7 @@ int lfsr_traversal_rewind(lfs_t *lfs, lfsr_traversal_t *t); // // Fills out the fsinfo structure based on the filesystem found on-disk. // Returns a negative error code on failure. -int lfsr_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo); +int lfs3_fs_stat(lfs3_t *lfs3, struct lfs3_fsinfo *fsinfo); // Finds the number of blocks in use by the filesystem // @@ -1124,9 +1131,9 @@ int lfsr_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo); // usage may be larger than the filesystem actually is. // // Returns the number of allocated blocks, or a negative error code on failure. -lfs_ssize_t lfsr_fs_usage(lfs_t *lfs); +lfs3_ssize_t lfs3_fs_usage(lfs3_t *lfs3); -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Attempt to make the filesystem consistent and ready for writing // // Calling this function is not required, consistency will be implicitly @@ -1135,23 +1142,23 @@ lfs_ssize_t lfsr_fs_usage(lfs_t *lfs); // filesystem changes. // // Returns a negative error code on failure. -int lfsr_fs_mkconsistent(lfs_t *lfs); +int lfs3_fs_mkconsistent(lfs3_t *lfs3); #endif -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Check the filesystem for metadata errors // -// Returns LFS_ERR_CORRUPT if a checksum mismatch is found, or a negative +// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative // error code on failure. -int lfsr_fs_ckmeta(lfs_t *lfs); +int lfs3_fs_ckmeta(lfs3_t *lfs3); #endif -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Check the filesystem for metadata + data errors // -// Returns LFS_ERR_CORRUPT if a checksum mismatch is found, or a negative +// Returns LFS3_ERR_CORRUPT if a checksum mismatch is found, or a negative // error code on failure. -int lfsr_fs_ckdata(lfs_t *lfs); +int lfs3_fs_ckdata(lfs3_t *lfs3); #endif // Get the current filesystem checksum @@ -1168,9 +1175,9 @@ int lfsr_fs_ckdata(lfs_t *lfs); // expected. // // Returns a negative error code on failure. -int lfsr_fs_cksum(lfs_t *lfs, uint32_t *cksum); +int lfs3_fs_cksum(lfs3_t *lfs3, uint32_t *cksum); -#ifdef LFS_GC +#ifdef LFS3_GC // Perform any janitorial work that may be pending // // The exact janitorial work depends on the configured flags and steps. @@ -1179,22 +1186,22 @@ int lfsr_fs_cksum(lfs_t *lfs, uint32_t *cksum); // expensive janitorial work to a less time-critical code path. // // Returns a negative error code on failure. -int lfsr_fs_gc(lfs_t *lfs); +int lfs3_fs_gc(lfs3_t *lfs3); #endif // Mark janitorial work as incomplete // -// Any info flags passed to lfsr_gc_unck will be reset internally, +// Any info flags passed to lfs3_gc_unck will be reset internally, // forcing the work to be redone. // // This is most useful for triggering new ckmeta/ckdata scans with -// LFS_I_CANCKMETA and LFS_I_CANCKDATA. Otherwise littlefs will perform +// LFS3_I_CANCKMETA and LFS3_I_CANCKDATA. Otherwise littlefs will perform // only one scan after mount. // // Returns a negative error code on failure. -int lfsr_fs_unck(lfs_t *lfs, uint32_t flags); +int lfs3_fs_unck(lfs3_t *lfs3, uint32_t flags); -#ifndef LFS_READONLY +#ifndef LFS3_READONLY // Change the number of blocks used by the filesystem // // This changes the number of blocks we are currently using and updates @@ -1203,7 +1210,7 @@ int lfsr_fs_unck(lfs_t *lfs, uint32_t flags); // Note: This is irreversible. // // Returns a negative error code on failure. -int lfsr_fs_grow(lfs_t *lfs, lfs_size_t block_count); +int lfs3_fs_grow(lfs3_t *lfs3, lfs3_size_t block_count); #endif diff --git a/lfs_util.c b/lfs3_util.c similarity index 80% rename from lfs_util.c rename to lfs3_util.c index 60abdab6..41160cc8 100644 --- a/lfs_util.c +++ b/lfs3_util.c @@ -1,22 +1,22 @@ /* - * lfs util functions + * lfs3 util functions * * Copyright (c) 2022, The littlefs authors. * Copyright (c) 2017, Arm Limited. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause */ -#include "lfs_util.h" +#include "lfs3_util.h" // Only compile if user does not provide custom config -#ifndef LFS_CONFIG +#ifndef LFS3_CONFIG -// Need lfs.h for error codes -// TODO should we actually move the error codes to lfs_util.h? -#include "lfs.h" +// Need lfs3.h for error codes +// TODO should we actually move the error codes to lfs3_util.h? +#include "lfs3.h" // Convert to/from leb128 encoding -ssize_t lfs_toleb128(uint32_t word, void *buffer, size_t size) { +ssize_t lfs3_toleb128(uint32_t word, void *buffer, size_t size) { uint8_t *data = buffer; for (size_t i = 0; i < size; i++) { @@ -31,10 +31,10 @@ ssize_t lfs_toleb128(uint32_t word, void *buffer, size_t size) { } // buffer overflow? - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); } -ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size) { +ssize_t lfs3_fromleb128(uint32_t *word, const void *buffer, size_t size) { const uint8_t *data = buffer; int32_t word_ = 0; @@ -44,7 +44,7 @@ ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size) { if (!(dat & 0x80)) { // did we overflow? if ((word_ >> 7*i) != dat) { - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } *word = word_; @@ -53,15 +53,15 @@ ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size) { } // truncated? - return LFS_ERR_CORRUPT; + return LFS3_ERR_CORRUPT; } -// crc32c tables (see lfs_crc32c for more info) -#if !defined(LFS_SMALLER_CRC32C) \ - && !defined(LFS_FASTER_CRC32C) \ - && !defined(LFS_PMUL_CRC32C) -static const uint32_t lfs_crc32c_table[16] = { +// crc32c tables (see lfs3_crc32c for more info) +#if !defined(LFS3_SMALLER_CRC32C) \ + && !defined(LFS3_FASTER_CRC32C) \ + && !defined(LFS3_PMUL_CRC32C) +static const uint32_t lfs3_crc32c_table[16] = { 0x00000000, 0x105ec76f, 0x20bd8ede, 0x30e349b1, 0x417b1dbc, 0x5125dad3, 0x61c69362, 0x7198540d, 0x82f63b78, 0x92a8fc17, 0xa24bb5a6, 0xb21572c9, @@ -69,10 +69,10 @@ static const uint32_t lfs_crc32c_table[16] = { }; #endif -#if defined(LFS_FASTER_CRC32C) \ - && !defined(LFS_SMALLER_CRC32C) \ - && !defined(LFS_PMUL_CRC32C) -static const uint32_t lfs_crc32c_table[256] = { +#if defined(LFS3_FASTER_CRC32C) \ + && !defined(LFS3_SMALLER_CRC32C) \ + && !defined(LFS3_PMUL_CRC32C) +static const uint32_t lfs3_crc32c_table[256] = { 0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, @@ -142,7 +142,7 @@ static const uint32_t lfs_crc32c_table[256] = { // Calculate crc32c incrementally -uint32_t lfs_crc32c(uint32_t crc, const void *buffer, size_t size) { +uint32_t lfs3_crc32c(uint32_t crc, const void *buffer, size_t size) { // init with 0xffffffff so prefixed zeros affect the crc const uint8_t *buffer_ = buffer; crc ^= 0xffffffff; @@ -179,7 +179,7 @@ uint32_t lfs_crc32c(uint32_t crc, const void *buffer, size_t size) { // PCLMULQDQ Instruction whitepaper is an excellent resource on this // topic. // - #if defined(LFS_SMALLER_CRC32C) && !defined(LFS_PMUL_CRC32C) + #if defined(LFS3_SMALLER_CRC32C) && !defined(LFS3_PMUL_CRC32C) // naive reduce for (size_t i = 0; i < size; i++) { crc = crc ^ buffer_[i]; @@ -188,36 +188,36 @@ uint32_t lfs_crc32c(uint32_t crc, const void *buffer, size_t size) { } } - #elif !defined(LFS_FASTER_CRC32C) && !defined(LFS_PMUL_CRC32C) + #elif !defined(LFS3_FASTER_CRC32C) && !defined(LFS3_PMUL_CRC32C) // reduce via small table for (size_t i = 0; i < size; i++) { - crc = (crc >> 4) ^ lfs_crc32c_table[0xf & (crc ^ (buffer_[i] >> 0))]; - crc = (crc >> 4) ^ lfs_crc32c_table[0xf & (crc ^ (buffer_[i] >> 4))]; + crc = (crc >> 4) ^ lfs3_crc32c_table[0xf & (crc ^ (buffer_[i] >> 0))]; + crc = (crc >> 4) ^ lfs3_crc32c_table[0xf & (crc ^ (buffer_[i] >> 4))]; } - #elif defined(LFS_FASTER_CRC32C) && !defined(LFS_PMUL_CRC32C) + #elif defined(LFS3_FASTER_CRC32C) && !defined(LFS3_PMUL_CRC32C) // reduce via big table for (size_t i = 0; i < size; i++) { - crc = (crc >> 8) ^ lfs_crc32c_table[0xff & (crc ^ buffer_[i])]; + crc = (crc >> 8) ^ lfs3_crc32c_table[0xff & (crc ^ buffer_[i])]; } - #elif defined(LFS_PMUL_CRC32C) + #elif defined(LFS3_PMUL_CRC32C) // reduce via Barret reduction for (size_t i = 0; i < size;) { // align to 32-bits if ((uintptr_t)&buffer_[i] % sizeof(uint32_t) == 0 && i+sizeof(uint32_t) < size) { - crc = crc ^ lfs_fromle32_(&buffer_[i]); - crc = lfs_pmul( - lfs_pmul(crc, 0xdea713f1), + crc = crc ^ lfs3_fromle32_(&buffer_[i]); + crc = lfs3_pmul( + lfs3_pmul(crc, 0xdea713f1), 0x82f63b78) >> 31; i += 4; } else { crc = crc ^ buffer_[i]; crc = (crc >> 8) - ^ (lfs_pmul( - lfs_pmul(crc << 24, 0xdea713f1), + ^ (lfs3_pmul( + lfs3_pmul(crc << 24, 0xdea713f1), 0x82f63b78) >> 31); i += 1; @@ -232,7 +232,7 @@ uint32_t lfs_crc32c(uint32_t crc, const void *buffer, size_t size) { } // Multiply two crc32cs in the crc32c ring -uint32_t lfs_crc32c_mul(uint32_t a, uint32_t b) { +uint32_t lfs3_crc32c_mul(uint32_t a, uint32_t b) { // Multiplication in a crc32c ring involves polynomial // multiplication modulo the crc32c polynomial to keep things // finite: @@ -247,33 +247,33 @@ uint32_t lfs_crc32c_mul(uint32_t a, uint32_t b) { // This gets a bit funky because crc32cs are little-endian, but // fortunately pmul is symmetric. Though the result is awkwardly // 63-bits, so we need to shift by 1. - uint64_t r = lfs_pmul(a, b) << 1; + uint64_t r = lfs3_pmul(a, b) << 1; // We can accelerate our module with crc32c tables if present, these // loops may look familiar. - #if defined(LFS_SMALLER_CRC32C) && !defined(LFS_PMUL_CRC32C) + #if defined(LFS3_SMALLER_CRC32C) && !defined(LFS3_PMUL_CRC32C) // naive reduce for (int i = 0; i < 32; i++) { r = (r >> 1) ^ ((r & 1) ? 0x82f63b78 : 0); } - #elif !defined(LFS_FASTER_CRC32C) && !defined(LFS_PMUL_CRC32C) + #elif !defined(LFS3_FASTER_CRC32C) && !defined(LFS3_PMUL_CRC32C) // reduce via small table for (int i = 0; i < 8; i++) { - r = (r >> 4) ^ lfs_crc32c_table[0xf & r]; + r = (r >> 4) ^ lfs3_crc32c_table[0xf & r]; } - #elif defined(LFS_FASTER_CRC32C) && !defined(LFS_PMUL_CRC32C) + #elif defined(LFS3_FASTER_CRC32C) && !defined(LFS3_PMUL_CRC32C) // reduce via big table for (int i = 0; i < 4; i++) { - r = (r >> 8) ^ lfs_crc32c_table[0xff & r]; + r = (r >> 8) ^ lfs3_crc32c_table[0xff & r]; } - #elif defined(LFS_PMUL_CRC32C) + #elif defined(LFS3_PMUL_CRC32C) // reduce via Barret reduction r = (r >> 32) - ^ (lfs_pmul( - lfs_pmul(r, 0xdea713f1), + ^ (lfs3_pmul( + lfs3_pmul(r, 0xdea713f1), 0x82f63b78) >> 31); #endif diff --git a/lfs_util.h b/lfs3_util.h similarity index 52% rename from lfs_util.h rename to lfs3_util.h index 49977e27..59ece9d6 100644 --- a/lfs_util.h +++ b/lfs3_util.h @@ -1,93 +1,93 @@ /* - * lfs utility functions + * lfs3 utility functions * * Copyright (c) 2022, The littlefs authors. * Copyright (c) 2017, Arm Limited. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause */ -#ifndef LFS_UTIL_H -#define LFS_UTIL_H +#ifndef LFS3_UTIL_H +#define LFS3_UTIL_H -// Users can override lfs_util.h with their own configuration by defining -// LFS_CONFIG as a header file to include (-DLFS_CONFIG=lfs_config.h). +// Users can override lfs3_util.h with their own configuration by defining +// LFS3_CONFIG as a header file to include (-DLFS_CONFIG=lfs3_config.h). // -// If LFS_CONFIG is used, none of the default utils will be emitted and must be -// provided by the config file. To start, I would suggest copying lfs_util.h +// If LFS3_CONFIG is used, none of the default utils will be emitted and must be +// provided by the config file. To start, I would suggest copying lfs3_util.h // and modifying as needed. -#ifdef LFS_CONFIG -#define LFS_STRINGIZE(x) LFS_STRINGIZE2(x) -#define LFS_STRINGIZE2(x) #x -#include LFS_STRINGIZE(LFS_CONFIG) +#ifdef LFS3_CONFIG +#define LFS3_STRINGIZE(x) LFS3_STRINGIZE2(x) +#define LFS3_STRINGIZE2(x) #x +#include LFS3_STRINGIZE(LFS3_CONFIG) #else // Some convenient macro aliases -// TODO move these to something like lfs_cfg.h? +// TODO move these to something like lfs3_cfg.h? -// LFS_BIGGEST enables all opt-in features -#ifdef LFS_BIGGEST -#ifndef LFS_REVDBG -#define LFS_REVDBG +// LFS3_BIGGEST enables all opt-in features +#ifdef LFS3_BIGGEST +#ifndef LFS3_REVDBG +#define LFS3_REVDBG #endif -#ifndef LFS_REVNOISE -#define LFS_REVNOISE +#ifndef LFS3_REVNOISE +#define LFS3_REVNOISE #endif -#ifndef LFS_CKPROGS -#define LFS_CKPROGS +#ifndef LFS3_CKPROGS +#define LFS3_CKPROGS #endif -#ifndef LFS_CKFETCHES -#define LFS_CKFETCHES +#ifndef LFS3_CKFETCHES +#define LFS3_CKFETCHES #endif -#ifndef LFS_CKMETAPARITY -#define LFS_CKMETAPARITY +#ifndef LFS3_CKMETAPARITY +#define LFS3_CKMETAPARITY #endif -#ifndef LFS_CKDATACKSUMREADS -#define LFS_CKDATACKSUMREADS +#ifndef LFS3_CKDATACKSUMREADS +#define LFS3_CKDATACKSUMREADS #endif -#ifndef LFS_GC -#define LFS_GC +#ifndef LFS3_GC +#define LFS3_GC #endif #endif -// LFS_YES_* variants imply the relevant LFS_* macro -#ifdef LFS_YES_RDONLY -#define LFS_RDONLY +// LFS3_YES_* variants imply the relevant LFS3_* macro +#ifdef LFS3_YES_RDONLY +#define LFS3_RDONLY #endif -#ifdef LFS_YES_REVDBG -#define LFS_REVDBG +#ifdef LFS3_YES_REVDBG +#define LFS3_REVDBG #endif -#ifdef LFS_YES_REVNOISE -#define LFS_REVNOISE +#ifdef LFS3_YES_REVNOISE +#define LFS3_REVNOISE #endif -#ifdef LFS_YES_CKPROGS -#define LFS_CKPROGS +#ifdef LFS3_YES_CKPROGS +#define LFS3_CKPROGS #endif -#ifdef LFS_YES_CKFETCHES -#define LFS_CKFETCHES +#ifdef LFS3_YES_CKFETCHES +#define LFS3_CKFETCHES #endif -#ifdef LFS_YES_CKMETAPARITY -#define LFS_CKMETAPARITY +#ifdef LFS3_YES_CKMETAPARITY +#define LFS3_CKMETAPARITY #endif -#ifdef LFS_YES_CKDATACKSUMREADS -#define LFS_CKDATACKSUMREADS +#ifdef LFS3_YES_CKDATACKSUMREADS +#define LFS3_CKDATACKSUMREADS #endif -#ifdef LFS_YES_GC -#define LFS_GC +#ifdef LFS3_YES_GC +#define LFS3_GC #endif -// LFS_NO_LOG disables all logging macros -#ifdef LFS_NO_LOG -#ifndef LFS_NO_DEBUG -#define LFS_NO_DEBUG +// LFS3_NO_LOG disables all logging macros +#ifdef LFS3_NO_LOG +#ifndef LFS3_NO_DEBUG +#define LFS3_NO_DEBUG #endif -#ifndef LFS_NO_INFO -#define LFS_NO_INFO +#ifndef LFS3_NO_INFO +#define LFS3_NO_INFO #endif -#ifndef LFS_NO_WARN -#define LFS_NO_WARN +#ifndef LFS3_NO_WARN +#define LFS3_NO_WARN #endif -#ifndef LFS_NO_ERROR -#define LFS_NO_ERROR +#ifndef LFS3_NO_ERROR +#define LFS3_NO_ERROR #endif #endif @@ -97,20 +97,20 @@ #include #include #include -#ifndef LFS_NO_STRINGH +#ifndef LFS3_NO_STRINGH #include #endif -#ifndef LFS_NO_MALLOC +#ifndef LFS3_NO_MALLOC #include #endif -#ifndef LFS_NO_ASSERT +#ifndef LFS3_NO_ASSERT #include #endif -#if !defined(LFS_NO_DEBUG) || \ - !defined(LFS_NO_INFO) || \ - !defined(LFS_NO_WARN) || \ - !defined(LFS_NO_ERROR) || \ - defined(LFS_YES_TRACE) +#if !defined(LFS3_NO_DEBUG) || \ + !defined(LFS3_NO_INFO) || \ + !defined(LFS3_NO_WARN) || \ + !defined(LFS3_NO_ERROR) || \ + defined(LFS3_YES_TRACE) #include #endif @@ -120,139 +120,139 @@ // code footprint // Logging functions -#ifndef LFS_TRACE -#ifdef LFS_YES_TRACE -#define LFS_TRACE_(fmt, ...) \ +#ifndef LFS3_TRACE +#ifdef LFS3_YES_TRACE +#define LFS3_TRACE_(fmt, ...) \ printf("%s:%d:trace: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__) -#define LFS_TRACE(...) LFS_TRACE_(__VA_ARGS__, "") +#define LFS3_TRACE(...) LFS3_TRACE_(__VA_ARGS__, "") #else -#define LFS_TRACE(...) +#define LFS3_TRACE(...) #endif #endif -#ifndef LFS_DEBUG -#ifndef LFS_NO_DEBUG -#define LFS_DEBUG_(fmt, ...) \ +#ifndef LFS3_DEBUG +#ifndef LFS3_NO_DEBUG +#define LFS3_DEBUG_(fmt, ...) \ printf("%s:%d:debug: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__) -#define LFS_DEBUG(...) LFS_DEBUG_(__VA_ARGS__, "") +#define LFS3_DEBUG(...) LFS3_DEBUG_(__VA_ARGS__, "") #else -#define LFS_DEBUG(...) +#define LFS3_DEBUG(...) #endif #endif -#ifndef LFS_INFO -#ifndef LFS_NO_INFO -#define LFS_INFO_(fmt, ...) \ +#ifndef LFS3_INFO +#ifndef LFS3_NO_INFO +#define LFS3_INFO_(fmt, ...) \ printf("%s:%d:info: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__) -#define LFS_INFO(...) LFS_INFO_(__VA_ARGS__, "") +#define LFS3_INFO(...) LFS3_INFO_(__VA_ARGS__, "") #else -#define LFS_INFO(...) +#define LFS3_INFO(...) #endif #endif -#ifndef LFS_WARN -#ifndef LFS_NO_WARN -#define LFS_WARN_(fmt, ...) \ +#ifndef LFS3_WARN +#ifndef LFS3_NO_WARN +#define LFS3_WARN_(fmt, ...) \ printf("%s:%d:warn: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__) -#define LFS_WARN(...) LFS_WARN_(__VA_ARGS__, "") +#define LFS3_WARN(...) LFS3_WARN_(__VA_ARGS__, "") #else -#define LFS_WARN(...) +#define LFS3_WARN(...) #endif #endif -#ifndef LFS_ERROR -#ifndef LFS_NO_ERROR -#define LFS_ERROR_(fmt, ...) \ +#ifndef LFS3_ERROR +#ifndef LFS3_NO_ERROR +#define LFS3_ERROR_(fmt, ...) \ printf("%s:%d:error: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__) -#define LFS_ERROR(...) LFS_ERROR_(__VA_ARGS__, "") +#define LFS3_ERROR(...) LFS3_ERROR_(__VA_ARGS__, "") #else -#define LFS_ERROR(...) +#define LFS3_ERROR(...) #endif #endif // Runtime assertions -#ifndef LFS_ASSERT -#ifndef LFS_NO_ASSERT -#define LFS_ASSERT(test) assert(test) +#ifndef LFS3_ASSERT +#ifndef LFS3_NO_ASSERT +#define LFS3_ASSERT(test) assert(test) #else -#define LFS_ASSERT(test) +#define LFS3_ASSERT(test) #endif #endif -#ifndef LFS_UNREACHABLE -#ifndef LFS_NO_ASSERT -#define LFS_UNREACHABLE() LFS_ASSERT(false) -#elif !defined(LFS_NO_BUILTINS) -#define LFS_UNREACHABLE() __builtin_unreachable() +#ifndef LFS3_UNREACHABLE +#ifndef LFS3_NO_ASSERT +#define LFS3_UNREACHABLE() LFS3_ASSERT(false) +#elif !defined(LFS3_NO_BUILTINS) +#define LFS3_UNREACHABLE() __builtin_unreachable() #else -#define LFS_UNREACHABLE() +#define LFS3_UNREACHABLE() #endif #endif // Some ifdef conveniences -#ifdef LFS_REVDBG -#define LFS_IFDEF_REVDBG(a, b) (a) +#ifdef LFS3_REVDBG +#define LFS3_IFDEF_REVDBG(a, b) (a) #else -#define LFS_IFDEF_REVDBG(a, b) (b) +#define LFS3_IFDEF_REVDBG(a, b) (b) #endif -#ifdef LFS_REVNOISE -#define LFS_IFDEF_REVNOISE(a, b) (a) +#ifdef LFS3_REVNOISE +#define LFS3_IFDEF_REVNOISE(a, b) (a) #else -#define LFS_IFDEF_REVNOISE(a, b) (b) +#define LFS3_IFDEF_REVNOISE(a, b) (b) #endif -#ifdef LFS_CKPROGS -#define LFS_IFDEF_CKPROGS(a, b) (a) +#ifdef LFS3_CKPROGS +#define LFS3_IFDEF_CKPROGS(a, b) (a) #else -#define LFS_IFDEF_CKPROGS(a, b) (b) +#define LFS3_IFDEF_CKPROGS(a, b) (b) #endif -#ifdef LFS_CKFETCHES -#define LFS_IFDEF_CKFETCHES(a, b) (a) +#ifdef LFS3_CKFETCHES +#define LFS3_IFDEF_CKFETCHES(a, b) (a) #else -#define LFS_IFDEF_CKFETCHES(a, b) (b) +#define LFS3_IFDEF_CKFETCHES(a, b) (b) #endif -#ifdef LFS_CKMETAPARITY -#define LFS_IFDEF_CKMETAPARITY(a, b) (a) +#ifdef LFS3_CKMETAPARITY +#define LFS3_IFDEF_CKMETAPARITY(a, b) (a) #else -#define LFS_IFDEF_CKMETAPARITY(a, b) (b) +#define LFS3_IFDEF_CKMETAPARITY(a, b) (b) #endif -#ifdef LFS_CKDATACKSUMREADS -#define LFS_IFDEF_CKDATACKSUMREADS(a, b) (a) +#ifdef LFS3_CKDATACKSUMREADS +#define LFS3_IFDEF_CKDATACKSUMREADS(a, b) (a) #else -#define LFS_IFDEF_CKDATACKSUMREADS(a, b) (b) +#define LFS3_IFDEF_CKDATACKSUMREADS(a, b) (b) #endif -#ifdef LFS_GC -#define LFS_IFDEF_GC(a, b) (a) +#ifdef LFS3_GC +#define LFS3_IFDEF_GC(a, b) (a) #else -#define LFS_IFDEF_GC(a, b) (b) +#define LFS3_IFDEF_GC(a, b) (b) #endif // Some function attributes, no way around these // Force a function to be inlined -#if !defined(LFS_NO_BUILTINS) && defined(__GNUC__) -#define LFS_FORCEINLINE __attribute__((always_inline)) +#if !defined(LFS3_NO_BUILTINS) && defined(__GNUC__) +#define LFS3_FORCEINLINE __attribute__((always_inline)) #else -#define LFS_FORCEINLINE +#define LFS3_FORCEINLINE #endif // Force a function to _not_ be inlined -#if !defined(LFS_NO_BUILTINS) && defined(__GNUC__) -#define LFS_NOINLINE __attribute__((noinline)) +#if !defined(LFS3_NO_BUILTINS) && defined(__GNUC__) +#define LFS3_NOINLINE __attribute__((noinline)) #else -#define LFS_NOINLINE +#define LFS3_NOINLINE #endif // Builtin functions, these may be replaced by more efficient -// toolchain-specific implementations. LFS_NO_BUILTINS falls back to a more +// toolchain-specific implementations. LFS3_NO_BUILTINS falls back to a more // expensive basic C implementation for debugging purposes // // Most of the backup implementations are based on the infamous Bit @@ -261,33 +261,33 @@ // // Compile time min/max -#define LFS_MIN(a, b) ((a < b) ? a : b) -#define LFS_MAX(a, b) ((a > b) ? a : b) +#define LFS3_MIN(a, b) ((a < b) ? a : b) +#define LFS3_MAX(a, b) ((a > b) ? a : b) // Min/max functions for unsigned 32-bit numbers -static inline uint32_t lfs_min(uint32_t a, uint32_t b) { +static inline uint32_t lfs3_min(uint32_t a, uint32_t b) { return (a < b) ? a : b; } -static inline uint32_t lfs_max(uint32_t a, uint32_t b) { +static inline uint32_t lfs3_max(uint32_t a, uint32_t b) { return (a > b) ? a : b; } -static inline int32_t lfs_smin(int32_t a, int32_t b) { +static inline int32_t lfs3_smin(int32_t a, int32_t b) { return (a < b) ? a : b; } -static inline int32_t lfs_smax(int32_t a, int32_t b) { +static inline int32_t lfs3_smax(int32_t a, int32_t b) { return (a > b) ? a : b; } // Absolute value of signed numbers -static inline int32_t lfs_abs(int32_t a) { +static inline int32_t lfs3_abs(int32_t a) { return (a < 0) ? -a : a; } // Swap two variables -#define LFS_SWAP(_t, _a, _b) \ +#define LFS3_SWAP(_t, _a, _b) \ do { \ _t *a = _a; \ _t *b = _b; \ @@ -297,22 +297,22 @@ static inline int32_t lfs_abs(int32_t a) { } while (0) // Align to nearest multiple of a size -static inline uint32_t lfs_aligndown(uint32_t a, uint32_t alignment) { +static inline uint32_t lfs3_aligndown(uint32_t a, uint32_t alignment) { return a - (a % alignment); } -static inline uint32_t lfs_alignup(uint32_t a, uint32_t alignment) { - return lfs_aligndown(a + alignment-1, alignment); +static inline uint32_t lfs3_alignup(uint32_t a, uint32_t alignment) { + return lfs3_aligndown(a + alignment-1, alignment); } // Find the smallest power of 2 greater than or equal to a -static inline uint32_t lfs_nlog2(uint32_t a) { +static inline uint32_t lfs3_nlog2(uint32_t a) { // __builtin_clz of zero is undefined, so treat both 0 and 1 specially if (a <= 1) { return a; } -#if !defined(LFS_NO_BUILTINS) && (defined(__GNUC__) || defined(__CC_ARM)) +#if !defined(LFS3_NO_BUILTINS) && (defined(__GNUC__) || defined(__CC_ARM)) return 32 - __builtin_clz(a-1); #else uint32_t r = 0; @@ -327,18 +327,18 @@ static inline uint32_t lfs_nlog2(uint32_t a) { } // Count the number of trailing binary zeros in a -// lfs_ctz(0) may be undefined -static inline uint32_t lfs_ctz(uint32_t a) { -#if !defined(LFS_NO_BUILTINS) && defined(__GNUC__) +// lfs3_ctz(0) may be undefined +static inline uint32_t lfs3_ctz(uint32_t a) { +#if !defined(LFS3_NO_BUILTINS) && defined(__GNUC__) return __builtin_ctz(a); #else - return lfs_nlog2((a & -a) + 1) - 1; + return lfs3_nlog2((a & -a) + 1) - 1; #endif } // Count the number of binary ones in a -static inline uint32_t lfs_popc(uint32_t a) { -#if !defined(LFS_NO_BUILTINS) && (defined(__GNUC__) || defined(__CC_ARM)) +static inline uint32_t lfs3_popc(uint32_t a) { +#if !defined(LFS3_NO_BUILTINS) && (defined(__GNUC__) || defined(__CC_ARM)) return __builtin_popcount(a); #else a = a - ((a >> 1) & 0x55555555); @@ -349,8 +349,8 @@ static inline uint32_t lfs_popc(uint32_t a) { } // Returns true if there is an odd number of binary ones in a -static inline bool lfs_parity(uint32_t a) { -#if !defined(LFS_NO_BUILTINS) && (defined(__GNUC__) || defined(__CC_ARM)) +static inline bool lfs3_parity(uint32_t a) { +#if !defined(LFS3_NO_BUILTINS) && (defined(__GNUC__) || defined(__CC_ARM)) return __builtin_parity(a); #else a ^= a >> 16; @@ -362,7 +362,7 @@ static inline bool lfs_parity(uint32_t a) { // Find the sequence comparison of a and b, this is the distance // between a and b ignoring overflow -static inline int lfs_scmp(uint32_t a, uint32_t b) { +static inline int lfs3_scmp(uint32_t a, uint32_t b) { return (int)(unsigned)(a - b); } @@ -371,7 +371,7 @@ static inline int lfs_scmp(uint32_t a, uint32_t b) { // This is a multiply where all adds are replaced with xors. If we view // a and b as binary polynomials, xor is polynomial addition and pmul is // polynomial multiplication. -static inline uint64_t lfs_pmul(uint32_t a, uint32_t b) { +static inline uint64_t lfs3_pmul(uint32_t a, uint32_t b) { uint64_t r = 0; uint64_t a_ = a; while (b) { @@ -386,14 +386,14 @@ static inline uint64_t lfs_pmul(uint32_t a, uint32_t b) { // Convert to/from 32-bit little-endian -static inline void lfs_tole32(uint32_t word, void *buffer) { +static inline void lfs3_tole32(uint32_t word, void *buffer) { ((uint8_t*)buffer)[0] = word >> 0; ((uint8_t*)buffer)[1] = word >> 8; ((uint8_t*)buffer)[2] = word >> 16; ((uint8_t*)buffer)[3] = word >> 24; } -static inline uint32_t lfs_fromle32(const void *buffer) { +static inline uint32_t lfs3_fromle32(const void *buffer) { return (((uint8_t*)buffer)[0] << 0) | (((uint8_t*)buffer)[1] << 8) | (((uint8_t*)buffer)[2] << 16) @@ -401,19 +401,19 @@ static inline uint32_t lfs_fromle32(const void *buffer) { } // Convert to/from leb128 encoding -// TODO should we really be using ssize_t here and not lfs_ssize_t? -ssize_t lfs_toleb128(uint32_t word, void *buffer, size_t size); +// TODO should we really be using ssize_t here and not lfs3_ssize_t? +ssize_t lfs3_toleb128(uint32_t word, void *buffer, size_t size); -ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size); +ssize_t lfs3_fromleb128(uint32_t *word, const void *buffer, size_t size); // Compare n bytes of memory -#if !defined(LFS_NO_STRINGH) -#define lfs_memcmp memcmp -#elif !defined(LFS_NO_BUILTINS) -#define lfs_memcmp __builtin_memcmp +#if !defined(LFS3_NO_STRINGH) +#define lfs3_memcmp memcmp +#elif !defined(LFS3_NO_BUILTINS) +#define lfs3_memcmp __builtin_memcmp #else -static inline int lfs_memcmp(const void *a, const void *b, size_t size) { +static inline int lfs3_memcmp(const void *a, const void *b, size_t size) { const uint8_t *a_ = a; const uint8_t *b_ = b; for (size_t i = 0; i < size; i++) { @@ -427,12 +427,12 @@ static inline int lfs_memcmp(const void *a, const void *b, size_t size) { #endif // Copy n bytes from src to dst, src and dst must not overlap -#if !defined(LFS_NO_STRINGH) -#define lfs_memcpy memcpy -#elif !defined(LFS_NO_BUILTINS) -#define lfs_memcpy __builtin_memcpy +#if !defined(LFS3_NO_STRINGH) +#define lfs3_memcpy memcpy +#elif !defined(LFS3_NO_BUILTINS) +#define lfs3_memcpy __builtin_memcpy #else -static inline void *lfs_memcpy( +static inline void *lfs3_memcpy( void *restrict dst, const void *restrict src, size_t size) { uint8_t *dst_ = dst; const uint8_t *src_ = src; @@ -445,12 +445,12 @@ static inline void *lfs_memcpy( #endif // Copy n bytes from src to dst, src and dst may overlap -#if !defined(LFS_NO_STRINGH) -#define lfs_memmove memmove -#elif !defined(LFS_NO_BUILTINS) -#define lfs_memmove __builtin_memmove +#if !defined(LFS3_NO_STRINGH) +#define lfs3_memmove memmove +#elif !defined(LFS3_NO_BUILTINS) +#define lfs3_memmove __builtin_memmove #else -static inline void *lfs_memmove(void *dst, const void *src, size_t size) { +static inline void *lfs3_memmove(void *dst, const void *src, size_t size) { uint8_t *dst_ = dst; const uint8_t *src_ = src; if (dst_ < src_) { @@ -468,12 +468,12 @@ static inline void *lfs_memmove(void *dst, const void *src, size_t size) { #endif // Set n bytes to c -#if !defined(LFS_NO_STRINGH) -#define lfs_memset memset -#elif !defined(LFS_NO_BUILTINS) -#define lfs_memset __builtin_memset +#if !defined(LFS3_NO_STRINGH) +#define lfs3_memset memset +#elif !defined(LFS3_NO_BUILTINS) +#define lfs3_memset __builtin_memset #else -static inline void *lfs_memset(void *dst, int c, size_t size) { +static inline void *lfs3_memset(void *dst, int c, size_t size) { uint8_t *dst_ = dst; for (size_t i = 0; i < size; i++) { dst_[i] = c; @@ -484,10 +484,10 @@ static inline void *lfs_memset(void *dst, int c, size_t size) { #endif // Find the first occurrence of c or NULL -#if !defined(LFS_NO_STRINGH) -#define lfs_memchr memchr +#if !defined(LFS3_NO_STRINGH) +#define lfs3_memchr memchr #else -static inline void *lfs_memchr(const void *a, int c, size_t size) { +static inline void *lfs3_memchr(const void *a, int c, size_t size) { const uint8_t *a_ = a; for (size_t i = 0; i < size; i++) { if (a_[i] == c) { @@ -500,7 +500,7 @@ static inline void *lfs_memchr(const void *a, int c, size_t size) { #endif // Find the first occurrence of anything not c or NULL -static inline void *lfs_memcchr(const void *a, int c, size_t size) { +static inline void *lfs3_memcchr(const void *a, int c, size_t size) { const uint8_t *a_ = a; for (size_t i = 0; i < size; i++) { if (a_[i] != c) { @@ -512,7 +512,7 @@ static inline void *lfs_memcchr(const void *a, int c, size_t size) { } // Find the minimum length that includes all non-zero bytes -static inline size_t lfs_memlen(const void *a, size_t size) { +static inline size_t lfs3_memlen(const void *a, size_t size) { const uint8_t *a_ = a; while (size > 0 && a_[size-1] == 0) { size -= 1; @@ -522,7 +522,7 @@ static inline size_t lfs_memlen(const void *a, size_t size) { } // Xor n bytes from b into a -static inline void *lfs_memxor( +static inline void *lfs3_memxor( void *restrict a, const void *restrict b, size_t size) { uint8_t *a_ = a; const uint8_t *b_ = b; @@ -535,10 +535,10 @@ static inline void *lfs_memxor( // Find the length of a null-terminated string -#if !defined(LFS_NO_STRINGH) -#define lfs_strlen strlen +#if !defined(LFS3_NO_STRINGH) +#define lfs3_strlen strlen #else -static inline size_t lfs_strlen(const char *a) { +static inline size_t lfs3_strlen(const char *a) { const char *a_ = a; while (*a_) { a_++; @@ -549,10 +549,10 @@ static inline size_t lfs_strlen(const char *a) { #endif // Compare two null-terminated strings -#if !defined(LFS_NO_STRINGH) -#define lfs_strcmp strcmp +#if !defined(LFS3_NO_STRINGH) +#define lfs3_strcmp strcmp #else -static inline int lfs_strcmp(const char *a, const char *b) { +static inline int lfs3_strcmp(const char *a, const char *b) { while (*a && *a == *b) { a++; b++; @@ -563,10 +563,10 @@ static inline int lfs_strcmp(const char *a, const char *b) { #endif // Copy a null-terminated string from src to dst -#if !defined(LFS_NO_STRINGH) -#define lfs_strcpy strcpy +#if !defined(LFS3_NO_STRINGH) +#define lfs3_strcpy strcpy #else -static inline char *lfs_strcpy( +static inline char *lfs3_strcpy( char *restrict dst, const char *restrict src) { char *dst_ = dst; while (*src) { @@ -581,10 +581,10 @@ static inline char *lfs_strcpy( #endif // Find first occurrence of c or NULL -#ifndef LFS_NO_STRINGH -#define lfs_strchr strchr +#ifndef LFS3_NO_STRINGH +#define lfs3_strchr strchr #else -static inline char *lfs_strchr(const char *a, int c) { +static inline char *lfs3_strchr(const char *a, int c) { while (*a) { if (*a == c) { return (char*)a; @@ -598,7 +598,7 @@ static inline char *lfs_strchr(const char *a, int c) { #endif // Find first occurrence of anything not c or NULL -static inline char *lfs_strcchr(const char *a, int c) { +static inline char *lfs3_strcchr(const char *a, int c) { while (*a) { if (*a != c) { return (char*)a; @@ -611,10 +611,10 @@ static inline char *lfs_strcchr(const char *a, int c) { } // Find length of a that does not contain any char in cs -#ifndef LFS_NO_STRINGH -#define lfs_strspn strspn +#ifndef LFS3_NO_STRINGH +#define lfs3_strspn strspn #else -static inline size_t lfs_strspn(const char *a, const char *cs) { +static inline size_t lfs3_strspn(const char *a, const char *cs) { const char *a_ = a; while (*a_) { const char *cs_ = cs; @@ -633,10 +633,10 @@ static inline size_t lfs_strspn(const char *a, const char *cs) { #endif // Find length of a that only contains chars in cs -#ifndef LFS_NO_STRINGH -#define lfs_strcspn strcspn +#ifndef LFS3_NO_STRINGH +#define lfs3_strcspn strcspn #else -static inline size_t lfs_strcspn(const char *a, const char *cs) { +static inline size_t lfs3_strcspn(const char *a, const char *cs) { const char *a_ = a; while (*a_) { const char *cs_ = cs; @@ -656,8 +656,8 @@ static inline size_t lfs_strcspn(const char *a, const char *cs) { // Odd-parity and even-parity zeros in our crc32c ring -#define LFS_CRC32C_ODDZERO 0xfca42daf -#define LFS_CRC32C_EVENZERO 0x00000000 +#define LFS3_CRC32C_ODDZERO 0xfca42daf +#define LFS3_CRC32C_EVENZERO 0x00000000 // Calculate crc32c incrementally // @@ -665,32 +665,32 @@ static inline size_t lfs_strcspn(const char *a, const char *cs) { // init = 0xffffffff // fini = 0xffffffff // -uint32_t lfs_crc32c(uint32_t crc, const void *buffer, size_t size); +uint32_t lfs3_crc32c(uint32_t crc, const void *buffer, size_t size); // Multiply two crc32cs in the crc32c ring -uint32_t lfs_crc32c_mul(uint32_t a, uint32_t b); +uint32_t lfs3_crc32c_mul(uint32_t a, uint32_t b); // Find the cube of a crc32c in the crc32c ring -static inline uint32_t lfs_crc32c_cube(uint32_t a) { - return lfs_crc32c_mul(lfs_crc32c_mul(a, a), a); +static inline uint32_t lfs3_crc32c_cube(uint32_t a) { + return lfs3_crc32c_mul(lfs3_crc32c_mul(a, a), a); } // Allocate memory, only used if buffers are not provided to littlefs -#ifndef LFS_NO_MALLOC -#define lfs_malloc malloc +#ifndef LFS3_NO_MALLOC +#define lfs3_malloc malloc #else -static inline void *lfs_malloc(size_t size) { +static inline void *lfs3_malloc(size_t size) { (void)size; return NULL; } #endif // Deallocate memory, only used if buffers are not provided to littlefs -#ifndef LFS_NO_MALLOC -#define lfs_free free +#ifndef LFS3_NO_MALLOC +#define lfs3_free free #else -static inline void lfs_free(void *p) { +static inline void lfs3_free(void *p) { (void)p; } #endif diff --git a/runners/bench_runner.c b/runners/bench_runner.c index 0d8f5441..5d210ed4 100644 --- a/runners/bench_runner.c +++ b/runners/bench_runner.c @@ -9,7 +9,7 @@ #endif #include "runners/bench_runner.h" -#include "bd/lfs_emubd.h" +#include "bd/lfs3_emubd.h" #include #include @@ -439,9 +439,9 @@ FILE *bench_trace_file = NULL; uint32_t bench_trace_cycles = 0; uint64_t bench_trace_time = 0; uint64_t bench_trace_open_time = 0; -lfs_emubd_sleep_t bench_read_sleep = 0.0; -lfs_emubd_sleep_t bench_prog_sleep = 0.0; -lfs_emubd_sleep_t bench_erase_sleep = 0.0; +lfs3_emubd_sleep_t bench_read_sleep = 0.0; +lfs3_emubd_sleep_t bench_prog_sleep = 0.0; +lfs3_emubd_sleep_t bench_erase_sleep = 0.0; // this determines both the backtrace buffer and the trace printf buffer, if // trace ends up interleaved or truncated this may need to be increased @@ -607,17 +607,17 @@ void bench_permutation(size_t i, uint32_t *buffer, size_t size) { typedef struct bench_record { const char *m; uintmax_t n; - lfs_emubd_io_t last_readed; - lfs_emubd_io_t last_proged; - lfs_emubd_io_t last_erased; + lfs3_emubd_io_t last_readed; + lfs3_emubd_io_t last_proged; + lfs3_emubd_io_t last_erased; } bench_record_t; -static struct lfs_config *bench_cfg = NULL; +static struct lfs3_config *bench_cfg = NULL; static bench_record_t *bench_records; size_t bench_record_count; size_t bench_record_capacity; -void bench_reset(struct lfs_config *cfg) { +void bench_reset(struct lfs3_config *cfg) { bench_cfg = cfg; bench_record_count = 0; } @@ -625,11 +625,11 @@ void bench_reset(struct lfs_config *cfg) { void bench_start(const char *m, uintmax_t n) { // measure current read/prog/erase assert(bench_cfg); - lfs_emubd_sio_t readed = lfs_emubd_readed(bench_cfg); + lfs3_emubd_sio_t readed = lfs3_emubd_readed(bench_cfg); assert(readed >= 0); - lfs_emubd_sio_t proged = lfs_emubd_proged(bench_cfg); + lfs3_emubd_sio_t proged = lfs3_emubd_proged(bench_cfg); assert(proged >= 0); - lfs_emubd_sio_t erased = lfs_emubd_erased(bench_cfg); + lfs3_emubd_sio_t erased = lfs3_emubd_erased(bench_cfg); assert(erased >= 0); // allocate a new record @@ -648,11 +648,11 @@ void bench_start(const char *m, uintmax_t n) { void bench_stop(const char *m) { // measure current read/prog/erase assert(bench_cfg); - lfs_emubd_sio_t readed = lfs_emubd_readed(bench_cfg); + lfs3_emubd_sio_t readed = lfs3_emubd_readed(bench_cfg); assert(readed >= 0); - lfs_emubd_sio_t proged = lfs_emubd_proged(bench_cfg); + lfs3_emubd_sio_t proged = lfs3_emubd_proged(bench_cfg); assert(proged >= 0); - lfs_emubd_sio_t erased = lfs_emubd_erased(bench_cfg); + lfs3_emubd_sio_t erased = lfs3_emubd_erased(bench_cfg); assert(erased >= 0); // find our record @@ -1335,18 +1335,18 @@ void perm_run( } // create block device and configuration - lfs_emubd_t bd; + lfs3_emubd_t bd; - struct lfs_config cfg = { + struct lfs3_config cfg = { .context = &bd, - .read = lfs_emubd_read, - .prog = lfs_emubd_prog, - .erase = lfs_emubd_erase, - .sync = lfs_emubd_sync, + .read = lfs3_emubd_read, + .prog = lfs3_emubd_prog, + .erase = lfs3_emubd_erase, + .sync = lfs3_emubd_sync, BENCH_CFG }; - struct lfs_emubd_config bdcfg = { + struct lfs3_emubd_config bdcfg = { .disk_path = bench_disk_path, .read_sleep = bench_read_sleep, .prog_sleep = bench_prog_sleep, @@ -1354,7 +1354,7 @@ void perm_run( BENCH_BDCFG }; - int err = lfs_emubd_createcfg(&cfg, bench_disk_path, &bdcfg); + int err = lfs3_emubd_createcfg(&cfg, bench_disk_path, &bdcfg); if (err) { fprintf(stderr, "error: could not create block device: %d\n", err); exit(-1); @@ -1373,7 +1373,7 @@ void perm_run( printf("\n"); // cleanup - err = lfs_emubd_destroy(&cfg); + err = lfs3_emubd_destroy(&cfg); if (err) { fprintf(stderr, "error: could not destroy block device: %d\n", err); exit(-1); @@ -1920,7 +1920,7 @@ getopt_done: ; if (d >= define_count) { // align to power of two to avoid any superlinear growth - size_t ncount = 1 << lfs_nlog2(d+1); + size_t ncount = 1 << lfs3_nlog2(d+1); defines = realloc(defines, ncount*sizeof(bench_define_t)); memset(defines+define_count, 0, diff --git a/runners/bench_runner.h b/runners/bench_runner.h index 37944c2b..eaa9d287 100644 --- a/runners/bench_runner.h +++ b/runners/bench_runner.h @@ -8,16 +8,16 @@ #define BENCH_RUNNER_H -// override LFS_TRACE +// override LFS3_TRACE void bench_trace(const char *fmt, ...); -#define LFS_TRACE_(fmt, ...) \ +#define LFS3_TRACE_(fmt, ...) \ bench_trace("%s:%d:trace: " fmt "%s\n", \ __FILE__, \ __LINE__, \ __VA_ARGS__) -#define LFS_TRACE(...) LFS_TRACE_(__VA_ARGS__, "") -#define LFS_EMUBD_TRACE(...) LFS_TRACE_(__VA_ARGS__, "") +#define LFS3_TRACE(...) LFS3_TRACE_(__VA_ARGS__, "") +#define LFS3_EMUBD_TRACE(...) LFS3_TRACE_(__VA_ARGS__, "") // BENCH_START/BENCH_STOP macros measure readed/proged/erased bytes // through emubd @@ -36,7 +36,7 @@ void bench_fresult(const char *m, uintmax_t n, double result); // note these are indirectly included in any generated files -#include "bd/lfs_emubd.h" +#include "bd/lfs3_emubd.h" #include // give source a chance to define feature macros @@ -45,7 +45,7 @@ void bench_fresult(const char *m, uintmax_t n, double result); // generated bench configurations -struct lfs_config; +struct lfs3_config; enum bench_flags { BENCH_INTERNAL = 0x1, @@ -69,7 +69,7 @@ struct bench_case { size_t permutations; bool (*if_)(void); - void (*run)(struct lfs_config *cfg); + void (*run)(struct lfs3_config *cfg); }; struct bench_suite { @@ -110,21 +110,21 @@ void bench_permutation(size_t i, uint32_t *buffer, size_t size); BENCH_DEFINE(BLOCK_COUNT, DISK_SIZE/BLOCK_SIZE ) \ BENCH_DEFINE(DISK_SIZE, 1024*1024 ) \ BENCH_DEFINE(BLOCK_RECYCLES, -1 ) \ - BENCH_DEFINE(RCACHE_SIZE, LFS_MAX(16, READ_SIZE) ) \ - BENCH_DEFINE(PCACHE_SIZE, LFS_MAX(16, PROG_SIZE) ) \ + BENCH_DEFINE(RCACHE_SIZE, LFS3_MAX(16, READ_SIZE) ) \ + BENCH_DEFINE(PCACHE_SIZE, LFS3_MAX(16, PROG_SIZE) ) \ BENCH_DEFINE(FILE_CACHE_SIZE, 16 ) \ BENCH_DEFINE(LOOKAHEAD_SIZE, 16 ) \ BENCH_DEFINE(GC_FLAGS, 0 ) \ BENCH_DEFINE(GC_STEPS, 0 ) \ BENCH_DEFINE(GC_COMPACT_THRESH, 0 ) \ BENCH_DEFINE(INLINE_SIZE, BLOCK_SIZE/4 ) \ - BENCH_DEFINE(FRAGMENT_SIZE, LFS_MIN(BLOCK_SIZE/8, 512) ) \ + BENCH_DEFINE(FRAGMENT_SIZE, LFS3_MIN(BLOCK_SIZE/8, 512) ) \ BENCH_DEFINE(CRYSTAL_THRESH, BLOCK_SIZE/8 ) \ BENCH_DEFINE(FRAGMENT_THRESH, -1 ) \ BENCH_DEFINE(ERASE_VALUE, 0xff ) \ BENCH_DEFINE(ERASE_CYCLES, 0 ) \ - BENCH_DEFINE(BADBLOCK_BEHAVIOR, LFS_EMUBD_BADBLOCK_PROGERROR ) \ - BENCH_DEFINE(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_ATOMIC ) \ + BENCH_DEFINE(BADBLOCK_BEHAVIOR, LFS3_EMUBD_BADBLOCK_PROGERROR ) \ + BENCH_DEFINE(POWERLOSS_BEHAVIOR, LFS3_EMUBD_POWERLOSS_ATOMIC ) \ BENCH_DEFINE(EMUBD_SEED, 0 ) // declare defines as global intmax_ts @@ -152,7 +152,7 @@ void bench_permutation(size_t i, uint32_t *buffer, size_t size); .crystal_thresh = CRYSTAL_THRESH, \ .fragment_thresh = FRAGMENT_THRESH, -#ifdef LFS_GC +#ifdef LFS3_GC #define BENCH_GC_CFG \ .gc_flags = GC_FLAGS, \ .gc_steps = GC_STEPS, diff --git a/runners/test_runner.c b/runners/test_runner.c index 1050ef85..56938d1a 100644 --- a/runners/test_runner.c +++ b/runners/test_runner.c @@ -9,7 +9,7 @@ #endif #include "runners/test_runner.h" -#include "bd/lfs_emubd.h" +#include "bd/lfs3_emubd.h" #include #include @@ -117,7 +117,7 @@ typedef struct test_powerloss { const struct test_powerloss *powerloss, const struct test_suite *suite, const struct test_case *case_); - const lfs_emubd_powercycles_t *cycles; + const lfs3_emubd_powercycles_t *cycles; size_t cycle_count; } test_powerloss_t; @@ -450,9 +450,9 @@ FILE *test_trace_file = NULL; uint32_t test_trace_cycles = 0; uint64_t test_trace_time = 0; uint64_t test_trace_open_time = 0; -lfs_emubd_sleep_t test_read_sleep = 0.0; -lfs_emubd_sleep_t test_prog_sleep = 0.0; -lfs_emubd_sleep_t test_erase_sleep = 0.0; +lfs3_emubd_sleep_t test_read_sleep = 0.0; +lfs3_emubd_sleep_t test_prog_sleep = 0.0; +lfs3_emubd_sleep_t test_erase_sleep = 0.0; volatile size_t TEST_PLS = 0; @@ -623,7 +623,7 @@ void test_permutation(size_t i, uint32_t *buffer, size_t size) { static void perm_printid( const struct test_suite *suite, const struct test_case *case_, - const lfs_emubd_powercycles_t *cycles, + const lfs3_emubd_powercycles_t *cycles, size_t cycle_count) { (void)suite; // case[:permutation[:powercycles]] @@ -1299,18 +1299,18 @@ static void run_powerloss_none( (void)powerloss; // create block device and configuration - lfs_emubd_t bd; + lfs3_emubd_t bd; - struct lfs_config cfg = { + struct lfs3_config cfg = { .context = &bd, - .read = lfs_emubd_read, - .prog = lfs_emubd_prog, - .erase = lfs_emubd_erase, - .sync = lfs_emubd_sync, + .read = lfs3_emubd_read, + .prog = lfs3_emubd_prog, + .erase = lfs3_emubd_erase, + .sync = lfs3_emubd_sync, TEST_CFG }; - struct lfs_emubd_config bdcfg = { + struct lfs3_emubd_config bdcfg = { .disk_path = test_disk_path, .read_sleep = test_read_sleep, .prog_sleep = test_prog_sleep, @@ -1318,7 +1318,7 @@ static void run_powerloss_none( TEST_BDCFG }; - int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg); + int err = lfs3_emubd_createcfg(&cfg, test_disk_path, &bdcfg); if (err) { fprintf(stderr, "error: could not create block device: %d\n", err); exit(-1); @@ -1339,7 +1339,7 @@ static void run_powerloss_none( printf("\n"); // cleanup - err = lfs_emubd_destroy(&cfg); + err = lfs3_emubd_destroy(&cfg); if (err) { fprintf(stderr, "error: could not destroy block device: %d\n", err); exit(-1); @@ -1359,19 +1359,19 @@ static void run_powerloss_linear( TEST_PLS = 0; // create block device and configuration - lfs_emubd_t bd; + lfs3_emubd_t bd; jmp_buf powerloss_jmp; - struct lfs_config cfg = { + struct lfs3_config cfg = { .context = &bd, - .read = lfs_emubd_read, - .prog = lfs_emubd_prog, - .erase = lfs_emubd_erase, - .sync = lfs_emubd_sync, + .read = lfs3_emubd_read, + .prog = lfs3_emubd_prog, + .erase = lfs3_emubd_erase, + .sync = lfs3_emubd_sync, TEST_CFG }; - struct lfs_emubd_config bdcfg = { + struct lfs3_emubd_config bdcfg = { .disk_path = test_disk_path, .read_sleep = test_read_sleep, .prog_sleep = test_prog_sleep, @@ -1384,7 +1384,7 @@ static void run_powerloss_linear( TEST_BDCFG }; - int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg); + int err = lfs3_emubd_createcfg(&cfg, test_disk_path, &bdcfg); if (err) { fprintf(stderr, "error: could not create block device: %d\n", err); exit(-1); @@ -1411,7 +1411,7 @@ static void run_powerloss_linear( // increment pls TEST_PLS += 1; - lfs_emubd_setpowercycles(&cfg, (TEST_PLS < powerloss->cycle_count) + lfs3_emubd_setpowercycles(&cfg, (TEST_PLS < powerloss->cycle_count) ? TEST_PLS+1 : 0); } @@ -1421,7 +1421,7 @@ static void run_powerloss_linear( printf("\n"); // cleanup - err = lfs_emubd_destroy(&cfg); + err = lfs3_emubd_destroy(&cfg); if (err) { fprintf(stderr, "error: could not destroy block device: %d\n", err); exit(-1); @@ -1436,19 +1436,19 @@ static void run_powerloss_log( TEST_PLS = 0; // create block device and configuration - lfs_emubd_t bd; + lfs3_emubd_t bd; jmp_buf powerloss_jmp; - struct lfs_config cfg = { + struct lfs3_config cfg = { .context = &bd, - .read = lfs_emubd_read, - .prog = lfs_emubd_prog, - .erase = lfs_emubd_erase, - .sync = lfs_emubd_sync, + .read = lfs3_emubd_read, + .prog = lfs3_emubd_prog, + .erase = lfs3_emubd_erase, + .sync = lfs3_emubd_sync, TEST_CFG }; - struct lfs_emubd_config bdcfg = { + struct lfs3_emubd_config bdcfg = { .disk_path = test_disk_path, .read_sleep = test_read_sleep, .prog_sleep = test_prog_sleep, @@ -1461,7 +1461,7 @@ static void run_powerloss_log( TEST_BDCFG }; - int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg); + int err = lfs3_emubd_createcfg(&cfg, test_disk_path, &bdcfg); if (err) { fprintf(stderr, "error: could not create block device: %d\n", err); exit(-1); @@ -1488,7 +1488,7 @@ static void run_powerloss_log( // increment pls TEST_PLS += 1; - lfs_emubd_setpowercycles(&cfg, (TEST_PLS < powerloss->cycle_count) + lfs3_emubd_setpowercycles(&cfg, (TEST_PLS < powerloss->cycle_count) ? 1 << TEST_PLS : 0); } @@ -1498,7 +1498,7 @@ static void run_powerloss_log( printf("\n"); // cleanup - err = lfs_emubd_destroy(&cfg); + err = lfs3_emubd_destroy(&cfg); if (err) { fprintf(stderr, "error: could not destroy block device: %d\n", err); exit(-1); @@ -1513,19 +1513,19 @@ static void run_powerloss_cycles( TEST_PLS = 0; // create block device and configuration - lfs_emubd_t bd; + lfs3_emubd_t bd; jmp_buf powerloss_jmp; - struct lfs_config cfg = { + struct lfs3_config cfg = { .context = &bd, - .read = lfs_emubd_read, - .prog = lfs_emubd_prog, - .erase = lfs_emubd_erase, - .sync = lfs_emubd_sync, + .read = lfs3_emubd_read, + .prog = lfs3_emubd_prog, + .erase = lfs3_emubd_erase, + .sync = lfs3_emubd_sync, TEST_CFG }; - struct lfs_emubd_config bdcfg = { + struct lfs3_emubd_config bdcfg = { .disk_path = test_disk_path, .read_sleep = test_read_sleep, .prog_sleep = test_prog_sleep, @@ -1538,7 +1538,7 @@ static void run_powerloss_cycles( TEST_BDCFG }; - int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg); + int err = lfs3_emubd_createcfg(&cfg, test_disk_path, &bdcfg); if (err) { fprintf(stderr, "error: could not create block device: %d\n", err); exit(-1); @@ -1564,7 +1564,7 @@ static void run_powerloss_cycles( // increment pls TEST_PLS += 1; - lfs_emubd_setpowercycles(&cfg, (TEST_PLS < powerloss->cycle_count) + lfs3_emubd_setpowercycles(&cfg, (TEST_PLS < powerloss->cycle_count) ? powerloss->cycles[TEST_PLS] : 0); } @@ -1574,7 +1574,7 @@ static void run_powerloss_cycles( printf("\n"); // cleanup - err = lfs_emubd_destroy(&cfg); + err = lfs3_emubd_destroy(&cfg); if (err) { fprintf(stderr, "error: could not destroy block device: %d\n", err); exit(-1); @@ -1582,15 +1582,15 @@ static void run_powerloss_cycles( } struct powerloss_exhaustive_state { - struct lfs_config *cfg; + struct lfs3_config *cfg; - lfs_emubd_t *branches; + lfs3_emubd_t *branches; size_t branch_count; size_t branch_capacity; }; struct powerloss_exhaustive_cycles { - lfs_emubd_powercycles_t *cycles; + lfs3_emubd_powercycles_t *cycles; size_t cycle_count; size_t cycle_capacity; }; @@ -1598,9 +1598,9 @@ struct powerloss_exhaustive_cycles { static void powerloss_exhaustive_branch(void *c) { struct powerloss_exhaustive_state *state = c; // append to branches - lfs_emubd_t *branch = mappend( + lfs3_emubd_t *branch = mappend( (void**)&state->branches, - sizeof(lfs_emubd_t), + sizeof(lfs3_emubd_t), &state->branch_count, &state->branch_capacity); if (!branch) { @@ -1609,22 +1609,22 @@ static void powerloss_exhaustive_branch(void *c) { } // create copy-on-write copy - int err = lfs_emubd_cpy(state->cfg, branch); + int err = lfs3_emubd_cpy(state->cfg, branch); if (err) { fprintf(stderr, "error: exhaustive: could not create bd copy\n"); exit(-1); } // also trigger on next power cycle - lfs_emubd_setpowercycles(state->cfg, 1); + lfs3_emubd_setpowercycles(state->cfg, 1); } static void run_powerloss_exhaustive_layer( struct powerloss_exhaustive_cycles *cycles, const struct test_suite *suite, const struct test_case *case_, - struct lfs_config *cfg, - struct lfs_emubd_config *bdcfg, + struct lfs3_config *cfg, + struct lfs3_emubd_config *bdcfg, size_t depth, size_t pls) { struct powerloss_exhaustive_state state = { @@ -1639,14 +1639,14 @@ static void run_powerloss_exhaustive_layer( // run through the test without additional powerlosses, collecting possible // branches as we do so - lfs_emubd_setpowercycles(state.cfg, (depth > 0) ? 1 : 0); + lfs3_emubd_setpowercycles(state.cfg, (depth > 0) ? 1 : 0); bdcfg->powerloss_data = &state; // run the tests case_->run(cfg); // aggressively clean up memory here to try to keep our memory usage low - int err = lfs_emubd_destroy(cfg); + int err = lfs3_emubd_destroy(cfg); if (err) { fprintf(stderr, "error: could not destroy block device: %d\n", err); exit(-1); @@ -1655,9 +1655,9 @@ static void run_powerloss_exhaustive_layer( // recurse into each branch for (size_t i = 0; i < state.branch_count; i++) { // first push and print the branch - lfs_emubd_powercycles_t *cycle = mappend( + lfs3_emubd_powercycles_t *cycle = mappend( (void**)&cycles->cycles, - sizeof(lfs_emubd_powercycles_t), + sizeof(lfs3_emubd_powercycles_t), &cycles->cycle_count, &cycles->cycle_capacity); if (!cycle) { @@ -1689,18 +1689,18 @@ static void run_powerloss_exhaustive( const struct test_suite *suite, const struct test_case *case_) { // create block device and configuration - lfs_emubd_t bd; + lfs3_emubd_t bd; - struct lfs_config cfg = { + struct lfs3_config cfg = { .context = &bd, - .read = lfs_emubd_read, - .prog = lfs_emubd_prog, - .erase = lfs_emubd_erase, - .sync = lfs_emubd_sync, + .read = lfs3_emubd_read, + .prog = lfs3_emubd_prog, + .erase = lfs3_emubd_erase, + .sync = lfs3_emubd_sync, TEST_CFG }; - struct lfs_emubd_config bdcfg = { + struct lfs3_emubd_config bdcfg = { .disk_path = test_disk_path, .read_sleep = test_read_sleep, .prog_sleep = test_prog_sleep, @@ -1710,7 +1710,7 @@ static void run_powerloss_exhaustive( TEST_BDCFG }; - int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg); + int err = lfs3_emubd_createcfg(&cfg, test_disk_path, &bdcfg); if (err) { fprintf(stderr, "error: could not create block device: %d\n", err); exit(-1); @@ -2234,16 +2234,16 @@ int main(int argc, char **argv) { // comma-separated permutation if (*optarg == '{') { - lfs_emubd_powercycles_t *cycles = NULL; + lfs3_emubd_powercycles_t *cycles = NULL; size_t cycle_count = 0; size_t cycle_capacity = 0; char *s = optarg + 1; while (true) { parsed = NULL; - *(lfs_emubd_powercycles_t*)mappend( + *(lfs3_emubd_powercycles_t*)mappend( (void**)&cycles, - sizeof(lfs_emubd_powercycles_t), + sizeof(lfs3_emubd_powercycles_t), &cycle_count, &cycle_capacity) = strtoumax(s, &parsed, 0); @@ -2295,7 +2295,7 @@ int main(int argc, char **argv) { // otherwise explicit power cycles } else { - lfs_emubd_powercycles_t *cycles = NULL; + lfs3_emubd_powercycles_t *cycles = NULL; size_t cycle_count = 0; size_t cycle_capacity = 0; @@ -2307,9 +2307,9 @@ int main(int argc, char **argv) { break; } - *(lfs_emubd_powercycles_t*)mappend( + *(lfs3_emubd_powercycles_t*)mappend( (void**)&cycles, - sizeof(lfs_emubd_powercycles_t), + sizeof(lfs3_emubd_powercycles_t), &cycle_count, &cycle_capacity) = x; s = parsed; @@ -2538,7 +2538,7 @@ getopt_done:; if (d >= define_count) { // align to power of two to avoid any superlinear growth - size_t ncount = 1 << lfs_nlog2(d+1); + size_t ncount = 1 << lfs3_nlog2(d+1); defines = realloc(defines, ncount*sizeof(test_define_t)); memset(defines+define_count, 0, @@ -2588,14 +2588,14 @@ getopt_done:; // otherwise explicit power cycles } else if (cycles_) { // parse power cycles - lfs_emubd_powercycles_t *cycles = NULL; + lfs3_emubd_powercycles_t *cycles = NULL; size_t cycle_count = 0; size_t cycle_capacity = 0; while (*cycles_ != '\0') { char *parsed = NULL; - *(lfs_emubd_powercycles_t*)mappend( + *(lfs3_emubd_powercycles_t*)mappend( (void**)&cycles, - sizeof(lfs_emubd_powercycles_t), + sizeof(lfs3_emubd_powercycles_t), &cycle_count, &cycle_capacity) = leb16_parse(cycles_, &parsed); diff --git a/runners/test_runner.h b/runners/test_runner.h index 4054043c..3bb9e0bb 100644 --- a/runners/test_runner.h +++ b/runners/test_runner.h @@ -8,20 +8,20 @@ #define TEST_RUNNER_H -// override LFS_TRACE +// override LFS3_TRACE void test_trace(const char *fmt, ...); -#define LFS_TRACE_(fmt, ...) \ +#define LFS3_TRACE_(fmt, ...) \ test_trace("%s:%d:trace: " fmt "%s\n", \ __FILE__, \ __LINE__, \ __VA_ARGS__) -#define LFS_TRACE(...) LFS_TRACE_(__VA_ARGS__, "") -#define LFS_EMUBD_TRACE(...) LFS_TRACE_(__VA_ARGS__, "") +#define LFS3_TRACE(...) LFS3_TRACE_(__VA_ARGS__, "") +#define LFS3_EMUBD_TRACE(...) LFS3_TRACE_(__VA_ARGS__, "") // note these are indirectly included in any generated files -#include "bd/lfs_emubd.h" +#include "bd/lfs3_emubd.h" #include // give source a chance to define feature macros @@ -30,7 +30,7 @@ void test_trace(const char *fmt, ...); // generated test configurations -struct lfs_config; +struct lfs3_config; enum test_flags { TEST_INTERNAL = 0x1, @@ -56,7 +56,7 @@ struct test_case { size_t permutations; bool (*if_)(void); - void (*run)(struct lfs_config *cfg); + void (*run)(struct lfs3_config *cfg); }; struct test_suite { @@ -101,21 +101,21 @@ void test_permutation(size_t i, uint32_t *buffer, size_t size); TEST_DEFINE(BLOCK_COUNT, DISK_SIZE/BLOCK_SIZE ) \ TEST_DEFINE(DISK_SIZE, 1024*1024 ) \ TEST_DEFINE(BLOCK_RECYCLES, -1 ) \ - TEST_DEFINE(RCACHE_SIZE, LFS_MAX(16, READ_SIZE) ) \ - TEST_DEFINE(PCACHE_SIZE, LFS_MAX(16, PROG_SIZE) ) \ + TEST_DEFINE(RCACHE_SIZE, LFS3_MAX(16, READ_SIZE) ) \ + TEST_DEFINE(PCACHE_SIZE, LFS3_MAX(16, PROG_SIZE) ) \ TEST_DEFINE(FILE_CACHE_SIZE, 16 ) \ TEST_DEFINE(LOOKAHEAD_SIZE, 16 ) \ TEST_DEFINE(GC_FLAGS, 0 ) \ TEST_DEFINE(GC_STEPS, 0 ) \ TEST_DEFINE(GC_COMPACT_THRESH, 0 ) \ TEST_DEFINE(INLINE_SIZE, BLOCK_SIZE/4 ) \ - TEST_DEFINE(FRAGMENT_SIZE, LFS_MIN(BLOCK_SIZE/8, 512) ) \ + TEST_DEFINE(FRAGMENT_SIZE, LFS3_MIN(BLOCK_SIZE/8, 512) ) \ TEST_DEFINE(CRYSTAL_THRESH, BLOCK_SIZE/8 ) \ TEST_DEFINE(FRAGMENT_THRESH, -1 ) \ TEST_DEFINE(ERASE_VALUE, 0xff ) \ TEST_DEFINE(ERASE_CYCLES, 0 ) \ - TEST_DEFINE(BADBLOCK_BEHAVIOR, LFS_EMUBD_BADBLOCK_PROGERROR ) \ - TEST_DEFINE(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_ATOMIC ) \ + TEST_DEFINE(BADBLOCK_BEHAVIOR, LFS3_EMUBD_BADBLOCK_PROGERROR ) \ + TEST_DEFINE(POWERLOSS_BEHAVIOR, LFS3_EMUBD_POWERLOSS_ATOMIC ) \ TEST_DEFINE(EMUBD_SEED, 0 ) // declare defines as global intmax_ts @@ -143,7 +143,7 @@ void test_permutation(size_t i, uint32_t *buffer, size_t size); .crystal_thresh = CRYSTAL_THRESH, \ .fragment_thresh = FRAGMENT_THRESH, -#ifdef LFS_GC +#ifdef LFS3_GC #define TEST_GC_CFG \ .gc_flags = GC_FLAGS, \ .gc_steps = GC_STEPS, diff --git a/scripts/bench.py b/scripts/bench.py index e7f643c7..8c5fd356 100755 --- a/scripts/bench.py +++ b/scripts/bench.py @@ -432,7 +432,7 @@ def compile(bench_paths, **args): # create case run function f.writeln('void __bench__%s__run(' '__attribute__((unused)) ' - 'struct lfs_config *CFG) {' % ( + 'struct lfs3_config *CFG) {' % ( case.name)) f.writeln(4*' '+'// bench case %s' % case.name) if case.code_lineno is not None: @@ -491,7 +491,7 @@ def compile(bench_paths, **args): 'void);' % ( case.name)) f.writeln('extern void __bench__%s__run(' - 'struct lfs_config *CFG);' % ( + 'struct lfs3_config *CFG);' % ( case.name)) f.writeln() diff --git a/scripts/dbgbmap.py b/scripts/dbgbmap.py index ceaea35b..78f873b5 100755 --- a/scripts/dbgbmap.py +++ b/scripts/dbgbmap.py @@ -2769,7 +2769,7 @@ class Gstate: # high-level littlefs representation -class Lfs: +class Lfs3: def __init__(self, bd, mtree, config=None, gstate=None, cksum=None, *, corrupt=False): self.bd = bd @@ -3018,7 +3018,7 @@ class Lfs: # empty path? if path_ == b'': - raise Lfs.PathError("invalid path: %r" % path) + raise Lfs3.PathError("invalid path: %r" % path) path__ = [] for p in path_.split(b'/'): @@ -3039,7 +3039,7 @@ class Lfs: else: path__.append(p) if dotdots: - raise Lfs.PathError("invalid path: %r" % path) + raise Lfs3.PathError("invalid path: %r" % path) path__.reverse() path_ = path__ @@ -3570,7 +3570,7 @@ class Lfs: super().__init__(lfs, mid, mdir, tag, name) # we're recursable if we're a non-grmed directory with a did - if (isinstance(self, Lfs.Dir) + if (isinstance(self, Lfs3.Dir) and not self.grmed and self.did is not None): self.recursable = True @@ -4507,7 +4507,7 @@ def main_(ring, disk, mroots=None, *, # fetch the filesystem bd = Bd(f, block_size, block_count) - lfs = Lfs.fetch(bd, mroots, trunk, + lfs = Lfs3.fetch(bd, mroots, trunk, # don't bother to check things if we're not reporting errors no_ck=not args.get('error_on_corrupt')) corrupted = not bool(lfs) diff --git a/scripts/dbgbmapsvg.py b/scripts/dbgbmapsvg.py index fd74029f..ffca45d1 100755 --- a/scripts/dbgbmapsvg.py +++ b/scripts/dbgbmapsvg.py @@ -2799,7 +2799,7 @@ class Gstate: # high-level littlefs representation -class Lfs: +class Lfs3: def __init__(self, bd, mtree, config=None, gstate=None, cksum=None, *, corrupt=False): self.bd = bd @@ -3048,7 +3048,7 @@ class Lfs: # empty path? if path_ == b'': - raise Lfs.PathError("invalid path: %r" % path) + raise Lfs3.PathError("invalid path: %r" % path) path__ = [] for p in path_.split(b'/'): @@ -3069,7 +3069,7 @@ class Lfs: else: path__.append(p) if dotdots: - raise Lfs.PathError("invalid path: %r" % path) + raise Lfs3.PathError("invalid path: %r" % path) path__.reverse() path_ = path__ @@ -3600,7 +3600,7 @@ class Lfs: super().__init__(lfs, mid, mdir, tag, name) # we're recursable if we're a non-grmed directory with a did - if (isinstance(self, Lfs.Dir) + if (isinstance(self, Lfs3.Dir) and not self.grmed and self.did is not None): self.recursable = True @@ -4227,7 +4227,7 @@ def main(disk, output, mroots=None, *, # fetch the filesystem bd = Bd(f, block_size, block_count) - lfs = Lfs.fetch(bd, mroots, trunk) + lfs = Lfs3.fetch(bd, mroots, trunk) corrupted = not bool(lfs) # if we can't figure out the block_count, guess diff --git a/scripts/dbgerr.py b/scripts/dbgerr.py index 67e355bd..aa9d7f3a 100755 --- a/scripts/dbgerr.py +++ b/scripts/dbgerr.py @@ -35,14 +35,14 @@ def main(errs, *, # list all known error codes if list_: for n, e, h in ERRS: - lines.append(('LFS_ERR_'+n, str(e), h)) + lines.append(('LFS3_ERR_'+n, str(e), h)) # find these errors else: def find_err(err): - # find by LFS_ERR_+name + # find by LFS3_ERR_+name for n, e, h in ERRS: - if 'LFS_ERR_'+n == err.upper(): + if 'LFS3_ERR_'+n == err.upper(): return n, e, h # find by ERR_+name for n, e, h in ERRS: @@ -73,7 +73,7 @@ def main(errs, *, for err in errs: try: n, e, h = find_err(err) - lines.append(('LFS_ERR_'+n, str(e), h)) + lines.append(('LFS3_ERR_'+n, str(e), h)) except KeyError: lines.append(('?', err, 'Unknown err code')) diff --git a/scripts/dbgflags.py b/scripts/dbgflags.py index 7f514ed1..41457810 100755 --- a/scripts/dbgflags.py +++ b/scripts/dbgflags.py @@ -77,8 +77,8 @@ FLAGS = [ ('M', 'MODE', 1, "Mount's access mode" ), ('^', 'RDWR', 0, "Mount the filesystem as read and write" ), ('^', 'RDONLY', 1, "Mount the filesystem as read only" ), - ('M', 'FLUSH', 0x00000040, "Open all files with LFS_O_FLUSH" ), - ('M', 'SYNC', 0x00000080, "Open all files with LFS_O_SYNC" ), + ('M', 'FLUSH', 0x00000040, "Open all files with LFS3_O_FLUSH" ), + ('M', 'SYNC', 0x00000080, "Open all files with LFS3_O_SYNC" ), ('M', 'REVDBG', 0x00000010, "Add debug info to revision counts" ), ('M', 'REVNOISE', 0x00000020, "Add noise to revision counts" ), ('M', 'CKPROGS', 0x00080000, "Check progs by reading back progged data" ), @@ -105,16 +105,16 @@ FLAGS = [ # Filesystem info flags ('I', 'RDONLY', 0x00000001, "Mounted read only" ), - ('I', 'FLUSH', 0x00000040, "Mounted with LFS_M_FLUSH" ), - ('I', 'SYNC', 0x00000080, "Mounted with LFS_M_SYNC" ), - ('I', 'REVDBG', 0x00000010, "Mounted with LFS_M_REVDBG" ), - ('I', 'REVNOISE', 0x00000020, "Mounted with LFS_M_REVNOISE" ), - ('I', 'CKPROGS', 0x00080000, "Mounted with LFS_M_CKPROGS" ), - ('I', 'CKFETCHES', 0x00100000, "Mounted with LFS_M_CKFETCHES" ), + ('I', 'FLUSH', 0x00000040, "Mounted with LFS3_M_FLUSH" ), + ('I', 'SYNC', 0x00000080, "Mounted with LFS3_M_SYNC" ), + ('I', 'REVDBG', 0x00000010, "Mounted with LFS3_M_REVDBG" ), + ('I', 'REVNOISE', 0x00000020, "Mounted with LFS3_M_REVNOISE" ), + ('I', 'CKPROGS', 0x00080000, "Mounted with LFS3_M_CKPROGS" ), + ('I', 'CKFETCHES', 0x00100000, "Mounted with LFS3_M_CKFETCHES" ), ('I', 'CKMETAPARITY', - 0x00200000, "Mounted with LFS_M_CKMETAPARITY" ), + 0x00200000, "Mounted with LFS3_M_CKMETAPARITY" ), ('I', 'CKDATACKSUMREADS', - 0x00800000, "Mounted with LFS_M_CKDATACKSUMREADS" ), + 0x00800000, "Mounted with LFS3_M_CKDATACKSUMREADS" ), ('I', 'MKCONSISTENT', 0x00000100, "Filesystem needs mkconsistent to write" ), @@ -233,10 +233,10 @@ def main(flags, *, # accept prefix prefix if f.upper() in prefixes: prefix.update(prefixes[f.upper()]) - # accept LFS_+prefix prefix - elif (f.upper().startswith('LFS_') - and f.upper()[len('LFS_'):] in prefixes): - prefix.update(prefixes[f.upper()[len('LFS_'):]]) + # accept LFS3_+prefix prefix + elif (f.upper().startswith('LFS3_') + and f.upper()[len('LFS3_'):] in prefixes): + prefix.update(prefixes[f.upper()[len('LFS3_'):]]) else: flags_.append(f) @@ -261,30 +261,30 @@ def main(flags, *, for p, t, n, f, h in flags__: if not all_ and (t is not None or p[0].islower()): continue - lines.append(('LFS_%s_%s' % (p, n), '0x%08x' % f, h)) + lines.append(('LFS3_%s_%s' % (p, n), '0x%08x' % f, h)) # find flags by name or value else: for f_ in flags_: found = False - # find by LFS_+prefix+_+name + # find by LFS3_+prefix+_+name for p, t, n, f, h in flags__: - if 'LFS_%s_%s' % (p, n) == f_.upper(): - lines.append(('LFS_%s_%s' % (p, n), '0x%08x' % f, h)) + if 'LFS3_%s_%s' % (p, n) == f_.upper(): + lines.append(('LFS3_%s_%s' % (p, n), '0x%08x' % f, h)) found = True if found: continue # find by prefix+_+name for p, t, n, f, h in flags__: if '%s_%s' % (p, n) == f_.upper(): - lines.append(('LFS_%s_%s' % (p, n), '0x%08x' % f, h)) + lines.append(('LFS3_%s_%s' % (p, n), '0x%08x' % f, h)) found = True if found: continue # find by name for p, t, n, f, h in flags__: if n == f_.upper(): - lines.append(('LFS_%s_%s' % (p, n), '0x%08x' % f, h)) + lines.append(('LFS3_%s_%s' % (p, n), '0x%08x' % f, h)) found = True if found: continue @@ -298,11 +298,11 @@ def main(flags, *, continue # matches flag? if t is None and (f__ & f) == f: - lines.append(('LFS_%s_%s' % (p, n), '0x%08x' % f, h)) + lines.append(('LFS3_%s_%s' % (p, n), '0x%08x' % f, h)) f___ &= ~f # matches type? elif t is not None and (f__ & t) == f: - lines.append(('LFS_%s_%s' % (p, n), '0x%08x' % f, h)) + lines.append(('LFS3_%s_%s' % (p, n), '0x%08x' % f, h)) f___ &= ~t if f___: lines.append(('?', '0x%08x' % f___, 'Unknown flags')) diff --git a/scripts/dbglfs.py b/scripts/dbglfs3.py similarity index 99% rename from scripts/dbglfs.py rename to scripts/dbglfs3.py index acca4001..ccabf933 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs3.py @@ -2726,7 +2726,7 @@ class Gstate: # high-level littlefs representation -class Lfs: +class Lfs3: def __init__(self, bd, mtree, config=None, gstate=None, cksum=None, *, corrupt=False): self.bd = bd @@ -2975,7 +2975,7 @@ class Lfs: # empty path? if path_ == b'': - raise Lfs.PathError("invalid path: %r" % path) + raise Lfs3.PathError("invalid path: %r" % path) path__ = [] for p in path_.split(b'/'): @@ -2996,7 +2996,7 @@ class Lfs: else: path__.append(p) if dotdots: - raise Lfs.PathError("invalid path: %r" % path) + raise Lfs3.PathError("invalid path: %r" % path) path__.reverse() path_ = path__ @@ -3527,7 +3527,7 @@ class Lfs: super().__init__(lfs, mid, mdir, tag, name) # we're recursable if we're a non-grmed directory with a did - if (isinstance(self, Lfs.Dir) + if (isinstance(self, Lfs3.Dir) and not self.grmed and self.did is not None): self.recursable = True @@ -4157,7 +4157,7 @@ def dbg_files(lfs, paths, *, try: dir = lfs.pathlookup(path, all=args.get('all')) - except Lfs.PathError as e: + except Lfs3.PathError as e: print("error: %s" % e, file=sys.stderr) sys.exit(-1) @@ -4178,7 +4178,7 @@ def dbg_files(lfs, paths, *, # include any orphaned entries in the root directory to help # debugging (these don't actually live in the root directory) - if not no_orphans and isinstance(dir, Lfs.Root): + if not no_orphans and isinstance(dir, Lfs3.Root): # finding orphans is expensive, so cache this if not hasattr(iter_dir, 'orphans'): iter_dir.orphans = dir.lfs.orphans() @@ -4224,7 +4224,7 @@ def dbg_files(lfs, paths, *, if file.orphaned: notes.append('orphaned') # missing bookmark/did? - if isinstance(file, Lfs.Dir): + if isinstance(file, Lfs3.Dir): if file.did is None: notes.append('missing did') elif lfs.namelookup(file.did, b'') is None: @@ -4582,7 +4582,7 @@ def main(disk, mroots=None, paths=None, *, # fetch the filesystem bd = Bd(f, block_size, block_count) - lfs = Lfs.fetch(bd, mroots, trunk) + lfs = Lfs3.fetch(bd, mroots, trunk) # print some information about the filesystem if not quiet: diff --git a/scripts/test.py b/scripts/test.py index abf2ba92..6238ddfd 100755 --- a/scripts/test.py +++ b/scripts/test.py @@ -444,7 +444,7 @@ def compile(test_paths, **args): # create case run function f.writeln('void __test__%s__run(' '__attribute__((unused)) ' - 'struct lfs_config *CFG) {' % ( + 'struct lfs3_config *CFG) {' % ( case.name)) f.writeln(4*' '+'// test case %s' % case.name) if case.code_lineno is not None: @@ -503,7 +503,7 @@ def compile(test_paths, **args): 'void);' % ( case.name)) f.writeln('extern void __test__%s__run(' - 'struct lfs_config *CFG);' % ( + 'struct lfs3_config *CFG);' % ( case.name)) f.writeln() diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml index 363dbde8..ce9b264d 100644 --- a/tests/test_alloc.toml +++ b/tests/test_alloc.toml @@ -20,23 +20,23 @@ defines.COUNT = [ '2', ] defines.ERASE = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // test various block counts - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // start allocating - lfs_alloc_ckpoint(&lfs); - lfs_size_t alloced = 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_size_t alloced = 0; while (true) { - lfs_sblock_t block = lfs_alloc(&lfs, ERASE); - assert(block >= 0 || block == LFS_ERR_NOSPC); + lfs3_sblock_t block = lfs3_alloc(&lfs3, ERASE); + assert(block >= 0 || block == LFS3_ERR_NOSPC); - if (block == LFS_ERR_NOSPC) { + if (block == LFS3_ERR_NOSPC) { break; } alloced += 1; @@ -47,10 +47,10 @@ code = ''' // excluding our mroot, we should have allocated exactly // block_count-2 blocks - printf("alloced %d/%d blocks\n", alloced, (lfs_block_t)COUNT); + printf("alloced %d/%d blocks\n", alloced, (lfs3_block_t)COUNT); assert(alloced == COUNT-2); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we can realloc after an ack @@ -64,23 +64,23 @@ defines.COUNT = [ '2', ] defines.ERASE = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // test various block counts - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // start allocating - lfs_alloc_ckpoint(&lfs); - lfs_size_t alloced = 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_size_t alloced = 0; while (true) { - lfs_sblock_t block = lfs_alloc(&lfs, ERASE); - assert(block >= 0 || block == LFS_ERR_NOSPC); + lfs3_sblock_t block = lfs3_alloc(&lfs3, ERASE); + assert(block >= 0 || block == LFS3_ERR_NOSPC); - if (block == LFS_ERR_NOSPC) { + if (block == LFS3_ERR_NOSPC) { break; } alloced += 1; @@ -91,17 +91,17 @@ code = ''' // excluding our mroot, we should have allocated exactly // block_count-2 blocks - printf("alloced %d/%d blocks\n", alloced, (lfs_block_t)COUNT); + printf("alloced %d/%d blocks\n", alloced, (lfs3_block_t)COUNT); assert(alloced == COUNT-2); // ack again, effectively releasing all the previously alloced blocks - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); alloced = 0; while (true) { - lfs_sblock_t block = lfs_alloc(&lfs, ERASE); - assert(block >= 0 || block == LFS_ERR_NOSPC); + lfs3_sblock_t block = lfs3_alloc(&lfs3, ERASE); + assert(block >= 0 || block == LFS3_ERR_NOSPC); - if (block == LFS_ERR_NOSPC) { + if (block == LFS3_ERR_NOSPC) { break; } alloced += 1; @@ -112,10 +112,10 @@ code = ''' // excluding our mroot, we should have allocated exactly // block_count-2 blocks - printf("alloced %d/%d blocks\n", alloced, (lfs_block_t)COUNT); + printf("alloced %d/%d blocks\n", alloced, (lfs3_block_t)COUNT); assert(alloced == COUNT-2); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -124,81 +124,81 @@ code = ''' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.CKMETA = [false, true] defines.REMOUNT = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // first traverse the tree to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -208,8 +208,8 @@ code = ''' seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8); seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -227,7 +227,7 @@ code = ''' // then clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -239,42 +239,42 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_alloc_clobber_files] @@ -290,86 +290,86 @@ defines.SIZE = [ ] defines.CKMETA = [false, true] defines.REMOUNT = [false, true] -in = 'lfs.c' +in = 'lfs3.c' if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // first traverse the tree to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -379,8 +379,8 @@ code = ''' seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8); seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -388,7 +388,7 @@ code = ''' // keep track of seen blocks seen[rbyd->blocks[0] / 8] |= 1 << (rbyd->blocks[0] % 8); - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: 0x%x block 0x%x\n", tag, bptr.data.u.disk.block); @@ -407,7 +407,7 @@ code = ''' // then clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -419,37 +419,37 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # open files need to be tracked internally to make sure this doesn't break @@ -465,42 +465,42 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] defines.CKMETA = [false, true] -in = 'lfs.c' +in = 'lfs3.c' if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files - lfsr_file_t files[N]; + lfs3_file_t files[N]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_open(&lfs, &files[i], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } @@ -508,25 +508,25 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -538,8 +538,8 @@ code = ''' seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -548,7 +548,7 @@ code = ''' seen[rbyd->blocks[0] / 8] |= 1 << (rbyd->blocks[0] % 8); - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: 0x%x block 0x%x\n", tag, bptr.data.u.disk.block); @@ -567,7 +567,7 @@ code = ''' // then clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -577,58 +577,58 @@ code = ''' // then check that reading our files still works after clobbering prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // and everything is fine after saving the files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -647,20 +647,20 @@ defines.COUNT = [ ] code = ''' // test various block counts - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // create directories until we run out of space - lfs_size_t n = 0; + lfs3_size_t n = 0; for (;; n++) { char name[256]; sprintf(name, "dir%08d", n); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { break; } } @@ -668,45 +668,45 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; } // check that our mkdir worked until we ran out of space - for (lfs_size_t i = 0; i < n; i++) { + for (lfs3_size_t i = 0; i < n; i++) { char name[256]; sprintf(name, "dir%08d", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < n; i++) { + for (lfs3_size_t i = 0; i < n; i++) { char name[256]; sprintf(name, "dir%08d", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_alloc_nospc_files] @@ -729,42 +729,42 @@ defines.SIZE = [ ] code = ''' // test various block counts - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // create files until we run out of space uint32_t prng = 42; - lfs_size_t n = 0; + lfs3_size_t n = 0; for (;; n++) { char name[256]; sprintf(name, "file%08d", n); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - int err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + lfs3_file_t file; + int err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { break; } - lfs_ssize_t size = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(size == SIZE || size == LFS_ERR_NOSPC); - if (size == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t size = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(size == SIZE || size == LFS3_ERR_NOSPC); + if (size == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; break; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { break; } } @@ -772,37 +772,37 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; } // check that our file writes worked until we ran out of space prng = 42; - for (lfs_size_t i = 0; i < n; i++) { + for (lfs3_size_t i = 0; i < n; i++) { // check with stat char name[256]; sprintf(name, "file%08d", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_attrs.toml b/tests/test_attrs.toml index 95f19c77..c059f1a6 100644 --- a/tests/test_attrs.toml +++ b/tests/test_attrs.toml @@ -13,30 +13,30 @@ after = ['test_files', 'test_fsync', 'test_stickynotes'] # FILETYPE=3 => root defines.FILETYPE = [0, 1, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -45,38 +45,38 @@ code = ''' // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, path, 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, path, 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, path, 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, path, 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, path, 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, path, 'c', c, strlen(c)) => 0; if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => strlen(a); - lfsr_sizeattr(&lfs, path, 'b') => strlen(b); - lfsr_sizeattr(&lfs, path, 'c') => strlen(c); + lfs3_sizeattr(&lfs3, path, 'a') => strlen(a); + lfs3_sizeattr(&lfs3, path, 'b') => strlen(b); + lfs3_sizeattr(&lfs3, path, 'c') => strlen(c); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test truncated getattr calls still work @@ -89,30 +89,30 @@ code = ''' defines.FILETYPE = [0, 1, 2, 3] defines.BUFSIZE = [1, 4, 7] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -121,52 +121,52 @@ code = ''' // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, path, 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, path, 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, path, 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, path, 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, path, 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, path, 'c', c, strlen(c)) => 0; if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => strlen(a); - lfsr_sizeattr(&lfs, path, 'b') => strlen(b); - lfsr_sizeattr(&lfs, path, 'c') => strlen(c); + lfs3_sizeattr(&lfs3, path, 'a') => strlen(a); + lfs3_sizeattr(&lfs3, path, 'b') => strlen(b); + lfs3_sizeattr(&lfs3, path, 'c') => strlen(c); // mark rbuf so we can detect overflow uint8_t rbuf[256]; rbuf[BUFSIZE] = '!'; // try reading truncated attrs - lfsr_getattr(&lfs, path, 'a', rbuf, BUFSIZE) => BUFSIZE; + lfs3_getattr(&lfs3, path, 'a', rbuf, BUFSIZE) => BUFSIZE; assert(memcmp(rbuf, a, BUFSIZE) == 0); assert(rbuf[BUFSIZE] == '!'); - lfsr_getattr(&lfs, path, 'b', rbuf, BUFSIZE) => BUFSIZE; + lfs3_getattr(&lfs3, path, 'b', rbuf, BUFSIZE) => BUFSIZE; assert(memcmp(rbuf, b, BUFSIZE) == 0); assert(rbuf[BUFSIZE] == '!'); - lfsr_getattr(&lfs, path, 'c', rbuf, BUFSIZE) => BUFSIZE; + lfs3_getattr(&lfs3, path, 'c', rbuf, BUFSIZE) => BUFSIZE; assert(memcmp(rbuf, c, BUFSIZE) == 0); assert(rbuf[BUFSIZE] == '!'); // try reading the full attrs - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test ENOATTR works @@ -178,72 +178,72 @@ code = ''' # FILETYPE=3 => root defines.FILETYPE = [0, 1, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { path = "/"; } // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'b') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'c') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'a') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'b') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'c') => LFS3_ERR_NOATTR; // try reading attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make sure setattr didn't quietly create attrs // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'b') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'c') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'a') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'b') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'c') => LFS3_ERR_NOATTR; // try reading attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that updating attrs works @@ -257,30 +257,30 @@ defines.FILETYPE = [0, 1, 2, 3] # update based on this mask defines.MASK = 'range(0x8)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -289,80 +289,80 @@ code = ''' // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, path, 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, path, 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, path, 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, path, 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, path, 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, path, 'c', c, strlen(c)) => 0; // rewrite some attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; if (MASK & 0x1) { - lfsr_setattr(&lfs, path, 'a', a_, strlen(a_)) => 0; + lfs3_setattr(&lfs3, path, 'a', a_, strlen(a_)) => 0; } const char *b_ = "Three slash four cup butter or margarine."; if (MASK & 0x2) { - lfsr_setattr(&lfs, path, 'b', b_, strlen(b_)) => 0; + lfs3_setattr(&lfs3, path, 'b', b_, strlen(b_)) => 0; } const char *c_ = "One and two third cups granulated sugar."; if (MASK & 0x4) { - lfsr_setattr(&lfs, path, 'c', c_, strlen(c_)) => 0; + lfs3_setattr(&lfs3, path, 'c', c_, strlen(c_)) => 0; } if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes if (MASK & 0x1) { - lfsr_sizeattr(&lfs, path, 'a') => strlen(a_); + lfs3_sizeattr(&lfs3, path, 'a') => strlen(a_); } else { - lfsr_sizeattr(&lfs, path, 'a') => strlen(a); + lfs3_sizeattr(&lfs3, path, 'a') => strlen(a); } if (MASK & 0x2) { - lfsr_sizeattr(&lfs, path, 'b') => strlen(b_); + lfs3_sizeattr(&lfs3, path, 'b') => strlen(b_); } else { - lfsr_sizeattr(&lfs, path, 'b') => strlen(b); + lfs3_sizeattr(&lfs3, path, 'b') => strlen(b); } if (MASK & 0x4) { - lfsr_sizeattr(&lfs, path, 'c') => strlen(c_); + lfs3_sizeattr(&lfs3, path, 'c') => strlen(c_); } else { - lfsr_sizeattr(&lfs, path, 'c') => strlen(c); + lfs3_sizeattr(&lfs3, path, 'c') => strlen(c); } // try reading attrs uint8_t rbuf[256]; if (MASK & 0x1) { - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => strlen(a_); + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => strlen(a_); assert(memcmp(rbuf, a_, strlen(a_)) == 0); } else { - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); } if (MASK & 0x2) { - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => strlen(b_); + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => strlen(b_); assert(memcmp(rbuf, b_, strlen(b_)) == 0); } else { - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); } if (MASK & 0x4) { - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => strlen(c_); + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => strlen(c_); assert(memcmp(rbuf, c_, strlen(c_)) == 0); } else { - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test removing attrs @@ -376,30 +376,30 @@ defines.FILETYPE = [0, 1, 2, 3] # remove based on this mask defines.MASK = 'range(0x8)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -408,80 +408,80 @@ code = ''' // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, path, 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, path, 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, path, 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, path, 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, path, 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, path, 'c', c, strlen(c)) => 0; // remove some attrs if (MASK & 0x1) { - lfsr_removeattr(&lfs, path, 'a') => 0; + lfs3_removeattr(&lfs3, path, 'a') => 0; } if (MASK & 0x2) { - lfsr_removeattr(&lfs, path, 'b') => 0; + lfs3_removeattr(&lfs3, path, 'b') => 0; } if (MASK & 0x4) { - lfsr_removeattr(&lfs, path, 'c') => 0; + lfs3_removeattr(&lfs3, path, 'c') => 0; } if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes if (MASK & 0x1) { - lfsr_sizeattr(&lfs, path, 'a') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'a') => LFS3_ERR_NOATTR; } else { - lfsr_sizeattr(&lfs, path, 'a') => strlen(a); + lfs3_sizeattr(&lfs3, path, 'a') => strlen(a); } if (MASK & 0x2) { - lfsr_sizeattr(&lfs, path, 'b') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'b') => LFS3_ERR_NOATTR; } else { - lfsr_sizeattr(&lfs, path, 'b') => strlen(b); + lfs3_sizeattr(&lfs3, path, 'b') => strlen(b); } if (MASK & 0x4) { - lfsr_sizeattr(&lfs, path, 'c') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'c') => LFS3_ERR_NOATTR; } else { - lfsr_sizeattr(&lfs, path, 'c') => strlen(c); + lfs3_sizeattr(&lfs3, path, 'c') => strlen(c); } // try reading the full attrs uint8_t rbuf[256]; if (MASK & 0x1) { - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) - => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) + => LFS3_ERR_NOATTR; } else { - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); } if (MASK & 0x2) { - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) - => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) + => LFS3_ERR_NOATTR; } else { - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); } if (MASK & 0x4) { - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) - => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) + => LFS3_ERR_NOATTR; } else { - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -495,30 +495,30 @@ code = ''' defines.FILETYPE = [0, 1, 2, 3] defines.SIZE = 4 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -530,26 +530,26 @@ code = ''' for (uint16_t a = 0; a < 0x100; a++) { // create the attr uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_setattr(&lfs, path, a, wbuf, SIZE) => 0; + lfs3_setattr(&lfs3, path, a, wbuf, SIZE) => 0; // try getting the attr size - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; // try reading the attr uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // remove the attr - lfsr_removeattr(&lfs, path, a) => 0; + lfs3_removeattr(&lfs3, path, a) => 0; } if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test creating a bunch of attrs @@ -563,35 +563,35 @@ defines.FILETYPE = [0, 1, 2, 3] defines.M = 40 defines.SIZE = 4 defines.COMPACT = [false, true] -defines.GC_FLAGS = 'LFS_GC_COMPACT' +defines.GC_FLAGS = 'LFS3_GC_COMPACT' defines.GC_STEPS = -1 defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' -if = 'LFS_IFDEF_GC(true, !COMPACT)' +if = 'LFS3_IFDEF_GC(true, !COMPACT)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -602,48 +602,48 @@ code = ''' uint32_t prng = 42; for (uint16_t a = 0; a < M; a++) { uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_setattr(&lfs, path, a, wbuf, SIZE) => 0; + lfs3_setattr(&lfs3, path, a, wbuf, SIZE) => 0; } // try compacting? - #ifdef LFS_GC + #ifdef LFS3_GC if (COMPACT) { - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } #endif if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes for (uint16_t a = 0; a < M; a++) { - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; } // try reading the attrs prng = 42; for (uint16_t a = 0; a < M; a++) { uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test creating a bunch of attrs on a bunch of files @@ -657,75 +657,76 @@ defines.N = 64 defines.M = 4 defines.SIZE = 4 defines.COMPACT = [false, true] -defines.GC_FLAGS = 'LFS_GC_COMPACT' +defines.GC_FLAGS = 'LFS3_GC_COMPACT' defines.GC_STEPS = -1 defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' -if = 'LFS_IFDEF_GC(true, !COMPACT)' +if = 'LFS3_IFDEF_GC(true, !COMPACT)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create N files uint32_t prng = 42; - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; // create a file? if (FILETYPE == 0) { sprintf(path, "cat%03x", i); - lfsr_file_open(&lfs, &files[i], path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &files[i], "meow", strlen("meow")) + lfs3_file_open(&lfs3, &files[i], path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &files[i], "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; // create a stickynote? } else if (FILETYPE == 1) { sprintf(path, "snail%03x", i); - lfsr_file_open(&lfs, &files[i], path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &files[i], "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &files[i], path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &files[i], + "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else { sprintf(path, "armadillo%03x", i); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // create M attrs for (uint16_t a = 0; a < M; a++) { uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_setattr(&lfs, path, a, wbuf, SIZE) => 0; + lfs3_setattr(&lfs3, path, a, wbuf, SIZE) => 0; } } // try compacting? - #ifdef LFS_GC + #ifdef LFS3_GC if (COMPACT) { - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } #endif if (FILETYPE == 1) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; // file? if (FILETYPE == 0) { @@ -740,22 +741,22 @@ code = ''' // try getting the attr sizes for (uint16_t a = 0; a < M; a++) { - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; } // try reading the attrs for (uint16_t a = 0; a < M; a++) { uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz attrs @@ -772,30 +773,30 @@ defines.OPS = '4*M' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else if (FILETYPE == 2) { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; // do nothing for root } else { @@ -807,7 +808,7 @@ code = ''' memset(sim_prngs, 0, M*sizeof(uint32_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 2; @@ -821,10 +822,10 @@ code = ''' // create the attr uint32_t wprng_ = wprng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_setattr(&lfs, path, a, wbuf, SIZE) => 0; + lfs3_setattr(&lfs3, path, a, wbuf, SIZE) => 0; // update our sim sim_prngs[a] = wprng; @@ -836,9 +837,9 @@ code = ''' // remove the attr if (sim_prngs[a]) { - lfsr_removeattr(&lfs, path, a) => 0; + lfs3_removeattr(&lfs3, path, a) => 0; } else { - lfsr_removeattr(&lfs, path, a) => LFS_ERR_NOATTR; + lfs3_removeattr(&lfs3, path, a) => LFS3_ERR_NOATTR; } // update our sim @@ -847,22 +848,22 @@ code = ''' } if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting each attr size for (uint16_t a = 0; a < M; a++) { if (sim_prngs[a]) { - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; } else { - lfsr_sizeattr(&lfs, path, a) => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, a) => LFS3_ERR_NOATTR; } } // try reading each attr @@ -870,23 +871,23 @@ code = ''' if (sim_prngs[a]) { uint32_t wprng_ = sim_prngs[a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } else { uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) - => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) + => LFS3_ERR_NOATTR; } } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz attrs on multiple files @@ -903,35 +904,36 @@ defines.OPS = '4*N*M' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create N files - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; // create a file? if (FILETYPE == 0) { sprintf(path, "cat%03x", i); - lfsr_file_open(&lfs, &files[i], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], "meow", strlen("meow")) + lfs3_file_open(&lfs3, &files[i], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; // create a stickynote? } else if (FILETYPE == 1) { sprintf(path, "snail%03x", i); - lfsr_file_open(&lfs, &files[i], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &files[i], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], + "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else { sprintf(path, "armadillo%03x", i); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } } @@ -940,14 +942,14 @@ code = ''' memset(sim_prngs, 0, N*M*sizeof(uint32_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 2; // create an attr? if (op == 0) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char path[256]; // file? if (FILETYPE == 0) { @@ -967,10 +969,10 @@ code = ''' // create the attr uint32_t wprng_ = wprng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_setattr(&lfs, path, a, wbuf, SIZE) => 0; + lfs3_setattr(&lfs3, path, a, wbuf, SIZE) => 0; // update our sim sim_prngs[x*M+a] = wprng; @@ -978,7 +980,7 @@ code = ''' // remove an attr? } else if (op == 1) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char path[256]; // file? if (FILETYPE == 0) { @@ -995,9 +997,9 @@ code = ''' // remove the attr if (sim_prngs[x*M+a]) { - lfsr_removeattr(&lfs, path, a) => 0; + lfs3_removeattr(&lfs3, path, a) => 0; } else { - lfsr_removeattr(&lfs, path, a) => LFS_ERR_NOATTR; + lfs3_removeattr(&lfs3, path, a) => LFS3_ERR_NOATTR; } // update our sim @@ -1006,19 +1008,19 @@ code = ''' } if (FILETYPE == 1) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; // file? if (FILETYPE == 0) { @@ -1034,9 +1036,9 @@ code = ''' // try getting each attr size for (uint16_t a = 0; a < M; a++) { if (sim_prngs[x*M+a]) { - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; } else { - lfsr_sizeattr(&lfs, path, a) => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, a) => LFS3_ERR_NOATTR; } } // try reading each attr @@ -1044,24 +1046,24 @@ code = ''' if (sim_prngs[x*M+a]) { uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } else { uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) - => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) + => LFS3_ERR_NOATTR; } } } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1073,89 +1075,90 @@ code = ''' # FILETYPE=2 => directory defines.FILETYPE = [0, 1, 2] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, path, 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, path, 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, path, 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, path, 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, path, 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, path, 'c', c, strlen(c)) => 0; // remove the file - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; // create the file again // file? if (FILETYPE == 0) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "miao", strlen("miao")) + => strlen("miao"); + lfs3_file_close(&lfs3, &file_) => 0; // stickynote? } else if (FILETYPE == 1) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "bruit d'escargot", strlen("bruit d'escargot")) => strlen("bruit d'escargot"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // dir? } else { - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'b') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'c') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'a') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'b') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'c') => LFS3_ERR_NOATTR; // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that moving onto a file removes all attrs @@ -1166,88 +1169,91 @@ code = ''' # FILETYPE=2 => directory defines.FILETYPE = [0, 1, 2] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; - lfsr_file_t file; + lfs3_file_t file; // create a file? if (FILETYPE == 0) { path = "cat"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create a stickynote? } else if (FILETYPE == 1) { path = "snail"; - lfsr_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "snailnoise", strlen("snailnoise")) + lfs3_file_open(&lfs3, &file, path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "snailnoise", strlen("snailnoise")) => strlen("snailnoise"); // create a dir? } else { path = "armadillo"; - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, path, 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, path, 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, path, 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, path, 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, path, 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, path, 'c', c, strlen(c)) => 0; // create another file and move it onto our file // file? if (FILETYPE == 0) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "beaver", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, + "beaver", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "miao", strlen("miao")) + => strlen("miao"); + lfs3_file_close(&lfs3, &file_) => 0; // stickynote? } else if (FILETYPE == 1) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "beaver", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, + "beaver", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "bruit d'escargot", strlen("bruit d'escargot")) => strlen("bruit d'escargot"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // dir? } else { - lfsr_mkdir(&lfs, "beaver") => 0; + lfs3_mkdir(&lfs3, "beaver") => 0; } - lfsr_rename(&lfs, "beaver", path) => 0; + lfs3_rename(&lfs3, "beaver", path) => 0; if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'b') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, path, 'c') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'a') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'b') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, 'c') => LFS3_ERR_NOATTR; // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that moves bring over all attrs @@ -1259,9 +1265,9 @@ code = ''' defines.FILETYPE = [0, 1, 2] defines.REPLACE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path; // file? @@ -1279,84 +1285,87 @@ code = ''' if (REPLACE) { // from file? if (FILETYPE == 0) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, + path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // from stickynote? } else if (FILETYPE == 1) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "snail noise", strlen("snail noise")) + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, + path, LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "snail noise", strlen("snail noise")) => strlen("snail noise"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // from dir? } else { - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } } // create a file? - lfsr_file_t file; + lfs3_file_t file; if (FILETYPE == 0) { - lfsr_file_open(&lfs, &file, "beaver", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) + lfs3_file_open(&lfs3, &file, "beaver", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // stickynote? } else if (FILETYPE == 1) { - lfsr_file_open(&lfs, &file, "beaver", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_open(&lfs3, &file, + "beaver", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "bruit d'escargot", strlen("bruit d'escargot")) => strlen("bruit d'escargot"); // create a dir? } else { - lfsr_mkdir(&lfs, "beaver") => 0; + lfs3_mkdir(&lfs3, "beaver") => 0; } // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "beaver", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "beaver", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "beaver", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "beaver", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "beaver", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "beaver", 'c', c, strlen(c)) => 0; // move file - lfsr_rename(&lfs, "beaver", path) => 0; + lfs3_rename(&lfs3, "beaver", path) => 0; if (FILETYPE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, path, 'a') => strlen(a); - lfsr_sizeattr(&lfs, path, 'b') => strlen(b); - lfsr_sizeattr(&lfs, path, 'c') => strlen(c); + lfs3_sizeattr(&lfs3, path, 'a') => strlen(a); + lfs3_sizeattr(&lfs3, path, 'b') => strlen(b); + lfs3_sizeattr(&lfs3, path, 'c') => strlen(c); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, path, 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); - lfsr_getattr(&lfs, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, path, 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); - lfsr_getattr(&lfs, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, path, 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz attrs mixed with file moves and removes @@ -1373,36 +1382,36 @@ defines.OPS = '4*N*M' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create N files - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; // create a file? if (FILETYPE == 0) { sprintf(path, "cat%03x", i); - lfsr_file_open(&lfs, &files[i], path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &files[i], "meow", strlen("meow")) + lfs3_file_open(&lfs3, &files[i], path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &files[i], "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; // create a stickynote? } else if (FILETYPE == 1) { sprintf(path, "snail%03x", i); - lfsr_file_open(&lfs, &files[i], path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &files[i], + lfs3_file_open(&lfs3, &files[i], path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &files[i], "snail noise", strlen("snail noise")) => strlen("snail noise"); // create a dir? } else { sprintf(path, "armadillo%03x", i); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } } @@ -1411,14 +1420,14 @@ code = ''' memset(sim_prngs, 0, N*M*sizeof(uint32_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 4; // create an attr? if (op == 0) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char path[256]; // file? if (FILETYPE == 0) { @@ -1438,10 +1447,10 @@ code = ''' // create the attr uint32_t wprng_ = wprng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_setattr(&lfs, path, a, wbuf, SIZE) => 0; + lfs3_setattr(&lfs3, path, a, wbuf, SIZE) => 0; // update our sim sim_prngs[x*M+a] = wprng; @@ -1449,7 +1458,7 @@ code = ''' // remove an attr? } else if (op == 1) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char path[256]; // file? if (FILETYPE == 0) { @@ -1466,9 +1475,9 @@ code = ''' // remove the attr if (sim_prngs[x*M+a]) { - lfsr_removeattr(&lfs, path, a) => 0; + lfs3_removeattr(&lfs3, path, a) => 0; } else { - lfsr_removeattr(&lfs, path, a) => LFS_ERR_NOATTR; + lfs3_removeattr(&lfs3, path, a) => LFS3_ERR_NOATTR; } // update our sim @@ -1477,7 +1486,7 @@ code = ''' // remove a file? } else if (op == 2) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char path[256]; // file? if (FILETYPE == 0) { @@ -1491,10 +1500,10 @@ code = ''' } // remove the file - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; if (FILETYPE == 1) { - lfsr_file_close(&lfs, &files[x]) => 0; + lfs3_file_close(&lfs3, &files[x]) => 0; } // but recreate the file so we always have something to @@ -1503,25 +1512,25 @@ code = ''' // create a file? if (FILETYPE == 0) { sprintf(path, "cat%03x", x); - lfsr_file_open(&lfs, &files[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[x], "miao", strlen("miao")) + lfs3_file_open(&lfs3, &files[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[x], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &files[x]) => 0; + lfs3_file_close(&lfs3, &files[x]) => 0; // create a stickynote? } else if (FILETYPE == 1) { sprintf(path, "snail%03x", x); - lfsr_file_open(&lfs, &files[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[x], + lfs3_file_open(&lfs3, &files[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[x], "bruit d'escargot", strlen("bruit d'escargot")) => strlen("bruit d'escargot"); // create a dir? } else { sprintf(path, "armadillo%03x", x); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // update our sim @@ -1530,8 +1539,8 @@ code = ''' // rename a file? } else if (op == 3) { // choose two files - lfs_size_t x = TEST_PRNG(&prng) % N; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t y = TEST_PRNG(&prng) % N; char path[256]; char path_[256]; // file? @@ -1549,20 +1558,20 @@ code = ''' } // rename the file - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; if (x != y) { if (FILETYPE == 1) { - lfsr_file_t wait; - lfsr_file_open(&lfs, &wait, path_, - LFS_O_WRONLY) => 0; - lfsr_file_desync(&lfs, &files[x]) => 0; - lfsr_file_close(&lfs, &files[x]) => 0; - lfsr_file_close(&lfs, &files[y]) => 0; - lfsr_file_open(&lfs, &files[y], path_, - LFS_O_WRONLY) => 0; - lfsr_file_desync(&lfs, &wait) => 0; - lfsr_file_close(&lfs, &wait) => 0; + lfs3_file_t wait; + lfs3_file_open(&lfs3, &wait, path_, + LFS3_O_WRONLY) => 0; + lfs3_file_desync(&lfs3, &files[x]) => 0; + lfs3_file_close(&lfs3, &files[x]) => 0; + lfs3_file_close(&lfs3, &files[y]) => 0; + lfs3_file_open(&lfs3, &files[y], path_, + LFS3_O_WRONLY) => 0; + lfs3_file_desync(&lfs3, &wait) => 0; + lfs3_file_close(&lfs3, &wait) => 0; } // but recreate the file so we always have something to @@ -1571,25 +1580,25 @@ code = ''' // create a file? if (FILETYPE == 0) { sprintf(path, "cat%03x", x); - lfsr_file_open(&lfs, &files[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[x], "nyan", strlen("nyan")) + lfs3_file_open(&lfs3, &files[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[x], "nyan", strlen("nyan")) => strlen("nyan"); - lfsr_file_close(&lfs, &files[x]) => 0; + lfs3_file_close(&lfs3, &files[x]) => 0; // create a stickynote? } else if (FILETYPE == 1) { sprintf(path, "snail%03x", x); - lfsr_file_open(&lfs, &files[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[x], + lfs3_file_open(&lfs3, &files[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[x], "swara keong", strlen("swara keong")) => strlen("swara keong"); // create a dir? } else { sprintf(path, "armadillo%03x", x); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // update our sim @@ -1600,19 +1609,19 @@ code = ''' } if (FILETYPE == 1) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; // file? if (FILETYPE == 0) { @@ -1628,9 +1637,9 @@ code = ''' // try getting each attr size for (uint16_t a = 0; a < M; a++) { if (sim_prngs[x*M+a]) { - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; } else { - lfsr_sizeattr(&lfs, path, a) => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, path, a) => LFS3_ERR_NOATTR; } } // try reading each attr @@ -1638,24 +1647,24 @@ code = ''' if (sim_prngs[x*M+a]) { uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } else { uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) - => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) + => LFS3_ERR_NOATTR; } } } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1663,35 +1672,35 @@ code = ''' # test that file-attached attrs are read correctly [cases.test_attrs_fattr_get] -defines.MODE = ['LFS_A_RDONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with these attrs uint8_t a_buf[256]; - lfs_ssize_t a_size = -1; + lfs3_ssize_t a_size = -1; uint8_t b_buf[256]; - lfs_ssize_t b_size = -1; + lfs3_ssize_t b_size = -1; uint8_t c_buf[256]; - lfs_ssize_t c_size = -1; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size = -1; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -1714,11 +1723,11 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -1734,46 +1743,46 @@ code = ''' } assert(memcmp(c_buf, c, strlen(c)) == 0); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that truncate attrs will work [cases.test_attrs_fattr_trunc] -defines.MODE = ['LFS_A_RDONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] defines.BUFSIZE = [1, 4, 7] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with these attrs, marking bufs so we can // detect overflow uint8_t a_buf[256]; a_buf[BUFSIZE] = '!'; - lfs_ssize_t a_size = -1; + lfs3_ssize_t a_size = -1; uint8_t b_buf[256]; b_buf[BUFSIZE] = '!'; - lfs_ssize_t b_size = -1; + lfs3_ssize_t b_size = -1; uint8_t c_buf[256]; c_buf[BUFSIZE] = '!'; - lfs_ssize_t c_size = -1; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size = -1; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -1796,11 +1805,11 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; // did we read the attrs correctly? no overflow? if (MUTSIZE) { @@ -1819,33 +1828,33 @@ code = ''' assert(memcmp(c_buf, c, BUFSIZE) == 0); assert(a_buf[BUFSIZE] == '!'); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that missing attrs are read correctly [cases.test_attrs_fattr_noattr] -defines.MODE = ['LFS_A_RDONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // try opening a file with missing attrs uint8_t a_buf[256]; - lfs_ssize_t a_size = -1; + lfs3_ssize_t a_size = -1; uint8_t b_buf[256]; - lfs_ssize_t b_size = -1; + lfs3_ssize_t b_size = -1; uint8_t c_buf[256]; - lfs_ssize_t c_size = -1; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size = -1; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -1868,58 +1877,58 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; // did we read the attrs correctly? if (MUTSIZE) { - assert(a_size == LFS_ERR_NOATTR); + assert(a_size == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(b_size == LFS_ERR_NOATTR); + assert(b_size == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(c_size == LFS_ERR_NOATTR); + assert(c_size == LFS3_ERR_NOATTR); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# catch LFS_O_TRUNC mistakes, this has created issues before +# catch LFS3_O_TRUNC mistakes, this has created issues before [cases.test_attrs_fattr_otrunc] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with these attrs uint8_t a_buf[256]; - lfs_ssize_t a_size = -1; + lfs3_ssize_t a_size = -1; uint8_t b_buf[256]; - lfs_ssize_t b_size = -1; + lfs3_ssize_t b_size = -1; uint8_t c_buf[256]; - lfs_ssize_t c_size = -1; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size = -1; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -1942,12 +1951,12 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", - MODE | LFS_O_TRUNC, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", + MODE | LFS3_O_TRUNC, &filecfg) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -1963,29 +1972,29 @@ code = ''' } assert(memcmp(c_buf, c, strlen(c)) == 0); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # uncreat files should zero attributes [cases.test_attrs_fattr_uncreat] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // _don't_ create a file // try opening a file with these attrs uint8_t a_buf[256]; - lfs_ssize_t a_size = -1; + lfs3_ssize_t a_size = -1; uint8_t b_buf[256]; - lfs_ssize_t b_size = -1; + lfs3_ssize_t b_size = -1; uint8_t c_buf[256]; - lfs_ssize_t c_size = -1; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size = -1; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -2008,43 +2017,43 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_t file; - lfsr_file_opencfg(&lfs, &file, "cat", - MODE | LFS_O_CREAT, &filecfg) => 0; + lfs3_file_t file; + lfs3_file_opencfg(&lfs3, &file, "cat", + MODE | LFS3_O_CREAT, &filecfg) => 0; // did we read the attrs correctly? if (MUTSIZE) { - assert(a_size == LFS_ERR_NOATTR); + assert(a_size == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(b_size == LFS_ERR_NOATTR); + assert(b_size == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(c_size == LFS_ERR_NOATTR); + assert(c_size == LFS3_ERR_NOATTR); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that file-attached attrs are written correctly [cases.test_attrs_fattr_set] -defines.MODE = ['LFS_A_WRONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_WRONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; @@ -2053,12 +2062,12 @@ code = ''' // try opening a file with attrs uint8_t a_buf[256]; - lfs_ssize_t a_size; + lfs3_ssize_t a_size; uint8_t b_buf[256]; - lfs_ssize_t b_size; + lfs3_ssize_t b_size; uint8_t c_buf[256]; - lfs_ssize_t c_size; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -2081,11 +2090,11 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; // set the attrs memcpy(a_buf, a, strlen(a)); @@ -2096,67 +2105,67 @@ code = ''' c_size = strlen(c); // write and close our file to write the attrs out to disk - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we can update existing attrs [cases.test_attrs_fattr_update] -defines.MODE = ['LFS_A_WRONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_WRONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; const char *b_ = "Three slash four cup butter or margarine."; const char *c_ = "One and two third cups granulated sugar."; uint8_t a_buf[256]; - lfs_ssize_t a_size; + lfs3_ssize_t a_size; uint8_t b_buf[256]; - lfs_ssize_t b_size; + lfs3_ssize_t b_size; uint8_t c_buf[256]; - lfs_ssize_t c_size; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -2179,13 +2188,13 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; - if (MODE == LFS_A_RDWR && MUTSIZE) { + if (MODE == LFS3_A_RDWR && MUTSIZE) { // did we read the attrs correctly? assert(a_size == strlen(a)); assert(memcmp(a_buf, a, strlen(a)) == 0); @@ -2204,71 +2213,71 @@ code = ''' c_size = strlen(c_); // write and close our file to write the attrs out to disk - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a_); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b_); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c_); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a_); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b_); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c_); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); assert(memcmp(rbuf, a_, strlen(a_)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); assert(memcmp(rbuf, b_, strlen(b_)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); assert(memcmp(rbuf, c_, strlen(c_)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we can remove attrs [cases.test_attrs_fattr_remove] -defines.MODE = ['LFS_A_WRONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_WRONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with attrs uint8_t a_buf[256]; - lfs_ssize_t a_size; + lfs3_ssize_t a_size; uint8_t b_buf[256]; - lfs_ssize_t b_size; + lfs3_ssize_t b_size; uint8_t c_buf[256]; - lfs_ssize_t c_size; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, .buffer = a_buf, .buffer_size = (MUTSIZE) - ? (lfs_ssize_t)sizeof(a_buf) - : LFS_ERR_NOATTR, + ? (lfs3_ssize_t)sizeof(a_buf) + : LFS3_ERR_NOATTR, .size = (MUTSIZE) ? &a_size : NULL, }, { @@ -2276,8 +2285,8 @@ code = ''' .flags = MODE, .buffer = b_buf, .buffer_size = (MUTSIZE) - ? (lfs_ssize_t)sizeof(b_buf) - : LFS_ERR_NOATTR, + ? (lfs3_ssize_t)sizeof(b_buf) + : LFS3_ERR_NOATTR, .size = (MUTSIZE) ? &b_size : NULL, }, { @@ -2285,18 +2294,18 @@ code = ''' .flags = MODE, .buffer = c_buf, .buffer_size = (MUTSIZE) - ? (lfs_ssize_t)sizeof(c_buf) - : LFS_ERR_NOATTR, + ? (lfs3_ssize_t)sizeof(c_buf) + : LFS3_ERR_NOATTR, .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; - if (MODE == LFS_A_RDWR && MUTSIZE) { + if (MODE == LFS3_A_RDWR && MUTSIZE) { // did we read the attrs correctly? assert(a_size == strlen(a)); assert(memcmp(a_buf, a, strlen(a)) == 0); @@ -2307,57 +2316,57 @@ code = ''' } // mark the attrs as removed - a_size = LFS_ERR_NOATTR; - b_size = LFS_ERR_NOATTR; - c_size = LFS_ERR_NOATTR; + a_size = LFS3_ERR_NOATTR; + b_size = LFS3_ERR_NOATTR; + c_size = LFS3_ERR_NOATTR; // write and close our file to write the attrs out to disk - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, "cat", 'b') => LFS_ERR_NOATTR; - lfsr_sizeattr(&lfs, "cat", 'c') => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, "cat", 'a') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, "cat", 'b') => LFS3_ERR_NOATTR; + lfs3_sizeattr(&lfs3, "cat", 'c') => LFS3_ERR_NOATTR; // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => LFS_ERR_NOATTR; + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => LFS3_ERR_NOATTR; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that wronly attrs are not read from disk [cases.test_attrs_fattr_wronly] -defines.MODE = ['LFS_A_WRONLY'] +defines.MODE = ['LFS3_A_WRONLY'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with new wronly attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; @@ -2365,14 +2374,14 @@ code = ''' const char *c_ = "One and two third cups granulated sugar."; uint8_t a_buf[256]; memcpy(a_buf, a_, strlen(a_)); - lfs_ssize_t a_size = strlen(a_); + lfs3_ssize_t a_size = strlen(a_); uint8_t b_buf[256]; memcpy(b_buf, b_, strlen(b_)); - lfs_ssize_t b_size = strlen(b_); + lfs3_ssize_t b_size = strlen(b_); uint8_t c_buf[256]; memcpy(c_buf, c_, strlen(c_)); - lfs_ssize_t c_size = strlen(c_); - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size = strlen(c_); + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -2395,11 +2404,11 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", LFS_O_RDWR, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", LFS3_O_RDWR, &filecfg) => 0; // open should have had no effect on our wronly attrs assert(a_size == strlen(a_)); @@ -2410,67 +2419,67 @@ code = ''' assert(memcmp(c_buf, c_, strlen(c_)) == 0); // write and close our file to write the attrs out to disk - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a_); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b_); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c_); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a_); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b_); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c_); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); assert(memcmp(rbuf, a_, strlen(a_)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); assert(memcmp(rbuf, b_, strlen(b_)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); assert(memcmp(rbuf, c_, strlen(c_)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that rdonly attrs have no effect on disk [cases.test_attrs_fattr_rdonly] -defines.MODE = ['LFS_A_RDONLY'] +defines.MODE = ['LFS3_A_RDONLY'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with rdonly attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; const char *b_ = "Three slash four cup butter or margarine."; const char *c_ = "One and two third cups granulated sugar."; uint8_t a_buf[256]; - lfs_ssize_t a_size; + lfs3_ssize_t a_size; uint8_t b_buf[256]; - lfs_ssize_t b_size; + lfs3_ssize_t b_size; uint8_t c_buf[256]; - lfs_ssize_t c_size; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -2493,11 +2502,11 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", LFS_O_RDWR, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", LFS3_O_RDWR, &filecfg) => 0; if (MUTSIZE) { // did we read the attrs correctly? @@ -2518,67 +2527,67 @@ code = ''' c_size = strlen(c_); // write and close our file, this should have no effect on attrs - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that attrs are written correctly even if there are no file changes [cases.test_attrs_fattr_noop] -defines.MODE = ['LFS_A_WRONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_WRONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; const char *b_ = "Three slash four cup butter or margarine."; const char *c_ = "One and two third cups granulated sugar."; uint8_t a_buf[256]; - lfs_ssize_t a_size; + lfs3_ssize_t a_size; uint8_t b_buf[256]; - lfs_ssize_t b_size; + lfs3_ssize_t b_size; uint8_t c_buf[256]; - lfs_ssize_t c_size; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size; + struct lfs3_attr attrs[] = { { .type = 'a', .flags = MODE, @@ -2601,13 +2610,13 @@ code = ''' .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; - if (MODE == LFS_A_RDWR && MUTSIZE) { + if (MODE == LFS3_A_RDWR && MUTSIZE) { // did we read the attrs correctly? assert(a_size == strlen(a)); assert(memcmp(a_buf, a, strlen(a)) == 0); @@ -2627,95 +2636,95 @@ code = ''' // close our file without any data changes, this should still update // our attrs! - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a_); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b_); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c_); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a_); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b_); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c_); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); assert(memcmp(rbuf, a_, strlen(a_)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); assert(memcmp(rbuf, b_, strlen(b_)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); assert(memcmp(rbuf, c_, strlen(c_)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that lazy attrs aren't written _until_ there are file changes [cases.test_attrs_fattr_lazy] -defines.MODE = ['LFS_A_WRONLY', 'LFS_A_RDWR'] +defines.MODE = ['LFS3_A_WRONLY', 'LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // try opening a file with attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; const char *b_ = "Three slash four cup butter or margarine."; const char *c_ = "One and two third cups granulated sugar."; uint8_t a_buf[256]; - lfs_ssize_t a_size; + lfs3_ssize_t a_size; uint8_t b_buf[256]; - lfs_ssize_t b_size; + lfs3_ssize_t b_size; uint8_t c_buf[256]; - lfs_ssize_t c_size; - struct lfs_attr attrs[] = { + lfs3_ssize_t c_size; + struct lfs3_attr attrs[] = { { .type = 'a', - .flags = MODE | LFS_A_LAZY, + .flags = MODE | LFS3_A_LAZY, .buffer = a_buf, .buffer_size = (MUTSIZE) ? sizeof(a_buf) : strlen(a_), .size = (MUTSIZE) ? &a_size : NULL, }, { .type = 'b', - .flags = MODE | LFS_A_LAZY, + .flags = MODE | LFS3_A_LAZY, .buffer = b_buf, .buffer_size = (MUTSIZE) ? sizeof(b_buf) : strlen(b_), .size = (MUTSIZE) ? &b_size : NULL, }, { .type = 'c', - .flags = MODE | LFS_A_LAZY, + .flags = MODE | LFS3_A_LAZY, .buffer = c_buf, .buffer_size = (MUTSIZE) ? sizeof(c_buf) : strlen(c_), .size = (MUTSIZE) ? &c_size : NULL, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file, "cat", MODE, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", MODE, &filecfg) => 0; - if (MODE == LFS_A_RDWR && MUTSIZE) { + if (MODE == LFS3_A_RDWR && MUTSIZE) { // did we read the attrs correctly? assert(a_size == strlen(a)); assert(memcmp(a_buf, a, strlen(a)) == 0); @@ -2735,111 +2744,111 @@ code = ''' // sync our file without any data changes, this should have no // effect because our attrs are lazy - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a); assert(memcmp(rbuf, a, strlen(a)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b); assert(memcmp(rbuf, b, strlen(b)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c); assert(memcmp(rbuf, c, strlen(c)) == 0); // now write some data and close our file, this should update // the attrs now - lfsr_file_write(&lfs, &file, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try getting the attr sizes - lfsr_sizeattr(&lfs, "cat", 'a') => strlen(a_); - lfsr_sizeattr(&lfs, "cat", 'b') => strlen(b_); - lfsr_sizeattr(&lfs, "cat", 'c') => strlen(c_); + lfs3_sizeattr(&lfs3, "cat", 'a') => strlen(a_); + lfs3_sizeattr(&lfs3, "cat", 'b') => strlen(b_); + lfs3_sizeattr(&lfs3, "cat", 'c') => strlen(c_); // try reading the attrs uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); + lfs3_getattr(&lfs3, "cat", 'a', rbuf, sizeof(rbuf)) => strlen(a_); assert(memcmp(rbuf, a_, strlen(a_)) == 0); - lfsr_getattr(&lfs, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); + lfs3_getattr(&lfs3, "cat", 'b', rbuf, sizeof(rbuf)) => strlen(b_); assert(memcmp(rbuf, b_, strlen(b_)) == 0); - lfsr_getattr(&lfs, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); + lfs3_getattr(&lfs3, "cat", 'c', rbuf, sizeof(rbuf)) => strlen(c_); assert(memcmp(rbuf, c_, strlen(c_)) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that attr updates are broadcast to other file handles [cases.test_attrs_fattr_broadcast] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -2868,11 +2877,11 @@ code = ''' c_size[1] = strlen(c_); // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[1], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[1]) => 0; + lfs3_file_write(&lfs3, &file[1], "miao", strlen("miao")) => strlen("miao"); + lfs3_file_sync(&lfs3, &file[1]) => 0; // were attrs broadcasted to the other files? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { // did we read the attrs correctly? if (MUTSIZE) { assert(a_size[i] == strlen(a_)); @@ -2888,72 +2897,72 @@ code = ''' assert(memcmp(c_buf[i], c_, strlen(c_)) == 0); } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that attr removes are broadcast to other file handles [cases.test_attrs_fattr_remove_broadcast] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -2971,94 +2980,94 @@ code = ''' } // remove _one_ file's attrs - a_size[1] = LFS_ERR_NOATTR; - b_size[1] = LFS_ERR_NOATTR; - c_size[1] = LFS_ERR_NOATTR; + a_size[1] = LFS3_ERR_NOATTR; + b_size[1] = LFS3_ERR_NOATTR; + c_size[1] = LFS3_ERR_NOATTR; // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[1], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[1]) => 0; + lfs3_file_write(&lfs3, &file[1], "miao", strlen("miao")) => strlen("miao"); + lfs3_file_sync(&lfs3, &file[1]) => 0; // were attrs broadcasted to the other files? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { // did we read the attrs correctly? if (MUTSIZE) { - assert(a_size[i] == LFS_ERR_NOATTR); + assert(a_size[i] == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(b_size[i] == LFS_ERR_NOATTR); + assert(b_size[i] == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(c_size[i] == LFS_ERR_NOATTR); + assert(c_size[i] == LFS3_ERR_NOATTR); } } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that setattr can also broadcast [cases.test_attrs_fattr_setattr_broadcast] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3077,14 +3086,14 @@ code = ''' // update attrs with setattr const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; - lfsr_setattr(&lfs, "cat", 'a', a_, strlen(a_)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a_, strlen(a_)) => 0; const char *b_ = "Three slash four cup butter or margarine."; - lfsr_setattr(&lfs, "cat", 'b', b_, strlen(b_)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b_, strlen(b_)) => 0; const char *c_ = "One and two third cups granulated sugar."; - lfsr_setattr(&lfs, "cat", 'c', c_, strlen(c_)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c_, strlen(c_)) => 0; // were attrs broadcasted to the other files? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { // did we read the attrs correctly? if (MUTSIZE) { assert(a_size[i] == strlen(a_)); @@ -3100,72 +3109,72 @@ code = ''' assert(memcmp(c_buf[i], c_, strlen(c_)) == 0); } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that attr removes are broadcast to other file handles [cases.test_attrs_fattr_removeattr_broadcast] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3182,91 +3191,91 @@ code = ''' assert(memcmp(c_buf[i], c, strlen(c)) == 0); } - // remove attrs with lfsr_removeattr - lfsr_removeattr(&lfs, "cat", 'a') => 0; - lfsr_removeattr(&lfs, "cat", 'b') => 0; - lfsr_removeattr(&lfs, "cat", 'c') => 0; + // remove attrs with lfs3_removeattr + lfs3_removeattr(&lfs3, "cat", 'a') => 0; + lfs3_removeattr(&lfs3, "cat", 'b') => 0; + lfs3_removeattr(&lfs3, "cat", 'c') => 0; // were attrs broadcasted to the other files? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { // did we read the attrs correctly? if (MUTSIZE) { - assert(a_size[i] == LFS_ERR_NOATTR); + assert(a_size[i] == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(b_size[i] == LFS_ERR_NOATTR); + assert(b_size[i] == LFS3_ERR_NOATTR); } if (MUTSIZE) { - assert(c_size[i] == LFS_ERR_NOATTR); + assert(c_size[i] == LFS3_ERR_NOATTR); } } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that attr broadcasts do _not_ update wronly attrs [cases.test_attrs_fattr_wronly_no_receive] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3284,9 +3293,9 @@ code = ''' } // make one attr set wronly - attrs[0][0].flags = LFS_A_WRONLY; - attrs[0][1].flags = LFS_A_WRONLY; - attrs[0][2].flags = LFS_A_WRONLY; + attrs[0][0].flags = LFS3_A_WRONLY; + attrs[0][1].flags = LFS3_A_WRONLY; + attrs[0][2].flags = LFS3_A_WRONLY; // update another file's attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; @@ -3300,11 +3309,11 @@ code = ''' c_size[2] = strlen(c_); // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[2], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[2]) => 0; + lfs3_file_write(&lfs3, &file[2], "miao", strlen("miao")) => strlen("miao"); + lfs3_file_sync(&lfs3, &file[2]) => 0; // were attrs broadcasted to the other files? but not our wronly attrs? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -3336,14 +3345,14 @@ code = ''' // update attrs with setattr const char *a__ = "Two cups all-purpose flower."; - lfsr_setattr(&lfs, "cat", 'a', a__, strlen(a__)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a__, strlen(a__)) => 0; const char *b__ = "Dont forget garnishes such as:"; - lfsr_setattr(&lfs, "cat", 'b', b__, strlen(b__)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b__, strlen(b__)) => 0; const char *c__ = "Fish-shaped crackers."; - lfsr_setattr(&lfs, "cat", 'c', c__, strlen(c__)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c__, strlen(c__)) => 0; // were attrs broadcasted to the other files? but not our wronly attrs? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -3374,10 +3383,10 @@ code = ''' } // if we sync our wronly file we should get the original attrs back - lfsr_file_sync(&lfs, &file[0]) => 0; + lfs3_file_sync(&lfs3, &file[0]) => 0; // were attrs broadcasted to the other files? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); } @@ -3392,72 +3401,72 @@ code = ''' assert(memcmp(c_buf[i], c, strlen(c)) == 0); } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that attr broadcasts do _not_ broadcast rdonly attrs [cases.test_attrs_fattr_rdonly_no_broadcast] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3475,9 +3484,9 @@ code = ''' } // make one attr set rdonly - attrs[0][0].flags = LFS_A_RDONLY; - attrs[0][1].flags = LFS_A_RDONLY; - attrs[0][2].flags = LFS_A_RDONLY; + attrs[0][0].flags = LFS3_A_RDONLY; + attrs[0][1].flags = LFS3_A_RDONLY; + attrs[0][2].flags = LFS3_A_RDONLY; // change the rdonly file's attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; @@ -3491,11 +3500,11 @@ code = ''' c_size[0] = strlen(c_); // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[0], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[0]) => 0; + lfs3_file_write(&lfs3, &file[0], "miao", strlen("miao")) => strlen("miao"); + lfs3_file_sync(&lfs3, &file[0]) => 0; // rdonly attrs should not have been broadcasted - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a_)); @@ -3526,10 +3535,10 @@ code = ''' } // sync any file to update our rdonly attrs - lfsr_file_sync(&lfs, &file[2]) => 0; + lfs3_file_sync(&lfs3, &file[2]) => 0; // reset attrs? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); } @@ -3544,72 +3553,72 @@ code = ''' assert(memcmp(c_buf[i], c, strlen(c)) == 0); } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that desync files do _not_ receive attr broadcasts [cases.test_attrs_fattr_desync_no_receive] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3627,7 +3636,7 @@ code = ''' } // make one file desync - lfsr_file_desync(&lfs, &file[0]) => 0; + lfs3_file_desync(&lfs3, &file[0]) => 0; // update another file's attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; @@ -3641,11 +3650,11 @@ code = ''' c_size[2] = strlen(c_); // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[2], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[2]) => 0; + lfs3_file_write(&lfs3, &file[2], "miao", strlen("miao")) => strlen("miao"); + lfs3_file_sync(&lfs3, &file[2]) => 0; // were attrs broadcasted to the other files? but not our desync file? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -3677,14 +3686,14 @@ code = ''' // update attrs with setattr const char *a__ = "Two cups all-purpose flower."; - lfsr_setattr(&lfs, "cat", 'a', a__, strlen(a__)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a__, strlen(a__)) => 0; const char *b__ = "Dont forget garnishes such as:"; - lfsr_setattr(&lfs, "cat", 'b', b__, strlen(b__)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b__, strlen(b__)) => 0; const char *c__ = "Fish-shaped crackers."; - lfsr_setattr(&lfs, "cat", 'c', c__, strlen(c__)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c__, strlen(c__)) => 0; // were attrs broadcasted to the other files? but not our desync file? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -3715,10 +3724,10 @@ code = ''' } // syncing the desync file should broadcast the original attrs - lfsr_file_sync(&lfs, &file[0]) => 0; + lfs3_file_sync(&lfs3, &file[0]) => 0; // were attrs broadcasted to the other files? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); } @@ -3733,72 +3742,72 @@ code = ''' assert(memcmp(c_buf[i], c, strlen(c)) == 0); } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that resync files will reread attrs [cases.test_attrs_fattr_resync_receive] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3816,7 +3825,7 @@ code = ''' } // make one file desync - lfsr_file_desync(&lfs, &file[0]) => 0; + lfs3_file_desync(&lfs3, &file[0]) => 0; // update another file's attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; @@ -3830,11 +3839,11 @@ code = ''' c_size[2] = strlen(c_); // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[2], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[2]) => 0; + lfs3_file_write(&lfs3, &file[2], "miao", strlen("miao")) => strlen("miao"); + lfs3_file_sync(&lfs3, &file[2]) => 0; // were attrs broadcasted to the other files? but not our desync file? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -3865,10 +3874,10 @@ code = ''' } // resync the desync file - lfsr_file_resync(&lfs, &file[0]) => 0; + lfs3_file_resync(&lfs3, &file[0]) => 0; // reread attrs? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (MUTSIZE) { assert(a_size[i] == strlen(a_)); } @@ -3883,72 +3892,72 @@ code = ''' assert(memcmp(c_buf[i], c_, strlen(c_)) == 0); } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that zombie files do _not_ broadcast attrs [cases.test_attrs_fattr_zombie_no_broadcast] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -3966,7 +3975,7 @@ code = ''' } // remove the file - lfsr_remove(&lfs, "cat") => 0; + lfs3_remove(&lfs3, "cat") => 0; // update one file's attrs const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; @@ -3980,13 +3989,13 @@ code = ''' c_size[1] = strlen(c_); // attempting to sync the zombie file is a noop - lfsr_file_sync(&lfs, &file[1]) => 0; + lfs3_file_sync(&lfs3, &file[1]) => 0; // attempting to resync the zombie file should error - lfsr_file_resync(&lfs, &file[1]) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file[1]) => LFS3_ERR_NOENT; // other file unaffected? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 1) { if (MUTSIZE) { assert(a_size[i] == strlen(a_)); @@ -4016,72 +4025,72 @@ code = ''' } } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that zombie files do _not_ receive attr broadcasts [cases.test_attrs_fattr_zombie_no_receive] -defines.MODE = ['LFS_A_RDWR'] +defines.MODE = ['LFS3_A_RDWR'] defines.MUTSIZE = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file_) => 0; // create some attrs const char *a = "One 18.25 ounce package chocolate cake mix."; - lfsr_setattr(&lfs, "cat", 'a', a, strlen(a)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a, strlen(a)) => 0; const char *b = "One can prepared coconut pecan frosting."; - lfsr_setattr(&lfs, "cat", 'b', b, strlen(b)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b, strlen(b)) => 0; const char *c = "Three slash four cup vegetable oil."; - lfsr_setattr(&lfs, "cat", 'c', c, strlen(c)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c, strlen(c)) => 0; // open a couple files with these attrs uint8_t a_buf[3][256]; - lfs_ssize_t a_size[3]; + lfs3_ssize_t a_size[3]; uint8_t b_buf[3][256]; - lfs_ssize_t b_size[3]; + lfs3_ssize_t b_size[3]; uint8_t c_buf[3][256]; - lfs_ssize_t c_size[3]; - struct lfs_attr attrs[3][3]; - struct lfs_file_config filecfg[3]; - lfsr_file_t file[3]; - for (lfs_size_t i = 0; i < 3; i++) { - attrs[i][0] = (struct lfs_attr){ + lfs3_ssize_t c_size[3]; + struct lfs3_attr attrs[3][3]; + struct lfs3_file_config filecfg[3]; + lfs3_file_t file[3]; + for (lfs3_size_t i = 0; i < 3; i++) { + attrs[i][0] = (struct lfs3_attr){ .type = 'a', .flags = MODE, .buffer = a_buf[i], .buffer_size = sizeof(a_buf[i]), .size = (MUTSIZE) ? &a_size[i] : NULL, }; - attrs[i][1] = (struct lfs_attr){ + attrs[i][1] = (struct lfs3_attr){ .type = 'b', .flags = MODE, .buffer = b_buf[i], .buffer_size = sizeof(b_buf[i]), .size = (MUTSIZE) ? &b_size[i] : NULL, }; - attrs[i][2] = (struct lfs_attr){ + attrs[i][2] = (struct lfs3_attr){ .type = 'c', .flags = MODE, .buffer = c_buf[i], .buffer_size = sizeof(c_buf[i]), .size = (MUTSIZE) ? &c_size[i] : NULL, }; - filecfg[i] = (struct lfs_file_config){ + filecfg[i] = (struct lfs3_file_config){ .attrs = attrs[i], .attr_count = 3, }; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -4099,22 +4108,22 @@ code = ''' } // remove the file - lfsr_remove(&lfs, "cat") => 0; + lfs3_remove(&lfs3, "cat") => 0; // recreate the file - lfsr_file_open(&lfs, &file_, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file_, "miao", strlen("miao")) => strlen("miao"); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file_, "miao", strlen("miao")) => strlen("miao"); + lfs3_file_close(&lfs3, &file_) => 0; const char *a_ = "Four large eggs. One cup semi-sweet chocolate chips."; - lfsr_setattr(&lfs, "cat", 'a', a_, strlen(a_)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a_, strlen(a_)) => 0; const char *b_ = "Three slash four cup butter or margarine."; - lfsr_setattr(&lfs, "cat", 'b', b_, strlen(b_)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b_, strlen(b_)) => 0; const char *c_ = "One and two third cups granulated sugar."; - lfsr_setattr(&lfs, "cat", 'c', c_, strlen(c_)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c_, strlen(c_)) => 0; // make sure no attrs were broadcasted to our zombies - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); } @@ -4130,14 +4139,14 @@ code = ''' } // reopen a couple files with these attrs - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { // leave one file a zombie if (i == 0) { continue; } - lfsr_file_close(&lfs, &file[i]) => 0; - lfsr_file_opencfg(&lfs, &file[i], "cat", MODE, &filecfg[i]) => 0; + lfs3_file_close(&lfs3, &file[i]) => 0; + lfs3_file_opencfg(&lfs3, &file[i], "cat", MODE, &filecfg[i]) => 0; // did we read the attrs correctly? if (MUTSIZE) { @@ -4166,11 +4175,11 @@ code = ''' c_size[2] = strlen(c__); // write and sync our file to write the attrs out to disk - lfsr_file_write(&lfs, &file[2], "nyan", strlen("nyan")) => strlen("nyan"); - lfsr_file_sync(&lfs, &file[2]) => 0; + lfs3_file_write(&lfs3, &file[2], "nyan", strlen("nyan")) => strlen("nyan"); + lfs3_file_sync(&lfs3, &file[2]) => 0; // were attrs broadcasted to the other files? but not our zombie file? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -4202,14 +4211,14 @@ code = ''' // update attrs with setattr const char *a___ = "Fish-shaped candies."; - lfsr_setattr(&lfs, "cat", 'a', a___, strlen(a___)) => 0; + lfs3_setattr(&lfs3, "cat", 'a', a___, strlen(a___)) => 0; const char *b___ = "Fish-shaped solid waste."; - lfsr_setattr(&lfs, "cat", 'b', b___, strlen(b___)) => 0; + lfs3_setattr(&lfs3, "cat", 'b', b___, strlen(b___)) => 0; const char *c___ = "Fish-shaped dirt."; - lfsr_setattr(&lfs, "cat", 'c', c___, strlen(c___)) => 0; + lfs3_setattr(&lfs3, "cat", 'c', c___, strlen(c___)) => 0; // were attrs broadcasted to the other files? but not our zombie file? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i == 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a)); @@ -4240,13 +4249,13 @@ code = ''' } // attempting to sync the zombie file is a noop - lfsr_file_sync(&lfs, &file[0]) => 0; + lfs3_file_sync(&lfs3, &file[0]) => 0; // attempting to resync the zombie file should error - lfsr_file_resync(&lfs, &file[0]) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file[0]) => LFS3_ERR_NOENT; // other file unaffected? - for (lfs_size_t i = 0; i < 3; i++) { + for (lfs3_size_t i = 0; i < 3; i++) { if (i != 0) { if (MUTSIZE) { assert(a_size[i] == strlen(a___)); @@ -4263,10 +4272,10 @@ code = ''' } } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &file[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &file[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4274,28 +4283,28 @@ code = ''' [cases.test_attrs_fattr_all] defines.SIZE = 4 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cat", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cat", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); + lfs3_file_close(&lfs3, &file) => 0; // setup our attr uint8_t a_buf[SIZE]; - lfs_ssize_t a_size = -1; - struct lfs_attr attrs[] = { + lfs3_ssize_t a_size = -1; + struct lfs3_attr attrs[] = { { - .flags = LFS_A_RDWR, + .flags = LFS3_A_RDWR, .buffer = a_buf, .buffer_size = sizeof(a_buf), .size = &a_size, } }; - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = 1, }; @@ -4307,36 +4316,36 @@ code = ''' // create the attr via open uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_opencfg(&lfs, &file, "cat", LFS_A_RDWR, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", LFS3_A_RDWR, &filecfg) => 0; memcpy(a_buf, wbuf, SIZE); a_size = SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // try getting the attr size - lfsr_sizeattr(&lfs, "cat", a) => SIZE; + lfs3_sizeattr(&lfs3, "cat", a) => SIZE; // try reading the attr uint8_t rbuf[256]; - lfsr_getattr(&lfs, "cat", a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, "cat", a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // clobber our in-RAM attr and try reading via open memset(a_buf, 0xcc, sizeof(a_buf)); - lfsr_file_opencfg(&lfs, &file, "cat", LFS_A_RDWR, &filecfg) => 0; + lfs3_file_opencfg(&lfs3, &file, "cat", LFS3_A_RDWR, &filecfg) => 0; assert(a_size == SIZE); assert(memcmp(a_buf, wbuf, SIZE) == 0); // remove the attr - a_size = LFS_ERR_NOATTR; - lfsr_file_close(&lfs, &file) => 0; + a_size = LFS3_ERR_NOATTR; + lfs3_file_close(&lfs3, &file) => 0; // make sure attr is removed - lfsr_sizeattr(&lfs, "cat", a) => LFS_ERR_NOATTR; + lfs3_sizeattr(&lfs3, "cat", a) => LFS3_ERR_NOATTR; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test creating a bunch of attrs on a bunch of files @@ -4345,82 +4354,82 @@ defines.N = 64 defines.M = 4 defines.SIZE = 4 defines.COMPACT = [false, true] -defines.GC_FLAGS = 'LFS_GC_COMPACT' +defines.GC_FLAGS = 'LFS3_GC_COMPACT' defines.GC_STEPS = -1 defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' -if = 'LFS_IFDEF_GC(true, !COMPACT)' +if = 'LFS3_IFDEF_GC(true, !COMPACT)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create N files with M attrs uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; sprintf(path, "cat%03x", i); uint8_t a_buf[M][SIZE]; - struct lfs_attr attrs[M]; - for (lfs_size_t j = 0; j < M; j++) { - for (lfs_size_t k = 0; k < SIZE; k++) { + struct lfs3_attr attrs[M]; + for (lfs3_size_t j = 0; j < M; j++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { a_buf[j][k] = 'a' + (TEST_PRNG(&prng) % 26); } - attrs[j] = (struct lfs_attr){ + attrs[j] = (struct lfs3_attr){ .type = j, - .flags = LFS_A_WRONLY, + .flags = LFS3_A_WRONLY, .buffer = a_buf[j], .buffer_size = SIZE, }; } - struct lfs_file_config filecfg = { + struct lfs3_file_config filecfg = { .attrs = attrs, .attr_count = M, }; - lfsr_file_t file; - lfsr_file_opencfg(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT, &filecfg) => 0; - lfsr_file_write(&lfs, &file, "meow", strlen("meow")) + lfs3_file_t file; + lfs3_file_opencfg(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT, &filecfg) => 0; + lfs3_file_write(&lfs3, &file, "meow", strlen("meow")) => strlen("meow"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // try compacting? - #ifdef LFS_GC + #ifdef LFS3_GC if (COMPACT) { - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } #endif for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; sprintf(path, "cat%03x", x); // try getting the attr sizes for (uint16_t a = 0; a < M; a++) { - lfsr_sizeattr(&lfs, path, a) => SIZE; + lfs3_sizeattr(&lfs3, path, a) => SIZE; } // try reading the attrs for (uint16_t a = 0; a < M; a++) { uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[256]; - lfsr_getattr(&lfs, path, a, rbuf, sizeof(rbuf)) => SIZE; + lfs3_getattr(&lfs3, path, a, rbuf, sizeof(rbuf)) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz attrs on multiple files @@ -4432,40 +4441,40 @@ defines.OPS = '4*N*M' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint8_t a_buf[N][M][SIZE]; - lfs_ssize_t a_size[N][M]; - struct lfs_attr attrs[N][M]; - struct lfs_file_config filecfg[N]; - lfsr_file_t file[N]; + lfs3_ssize_t a_size[N][M]; + struct lfs3_attr attrs[N][M]; + struct lfs3_file_config filecfg[N]; + lfs3_file_t file[N]; // create N files - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; sprintf(path, "cat%03x", x); - for (lfs_size_t a = 0; a < M; a++) { - attrs[x][a] = (struct lfs_attr){ + for (lfs3_size_t a = 0; a < M; a++) { + attrs[x][a] = (struct lfs3_attr){ .type = a, - .flags = LFS_A_RDWR, + .flags = LFS3_A_RDWR, .buffer = a_buf[x][a], .buffer_size = SIZE, .size = &a_size[x][a], }; } - filecfg[x] = (struct lfs_file_config){ + filecfg[x] = (struct lfs3_file_config){ .attrs = attrs[x], .attr_count = M, }; - lfsr_file_opencfg(&lfs, &file[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL, + lfs3_file_opencfg(&lfs3, &file[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL, &filecfg[x]) => 0; - lfsr_file_write(&lfs, &file[x], "meow", strlen("meow")) + lfs3_file_write(&lfs3, &file[x], "meow", strlen("meow")) => strlen("meow"); - lfsr_file_sync(&lfs, &file[x]) => 0; + lfs3_file_sync(&lfs3, &file[x]) => 0; } // set up a simulation to compare against @@ -4473,14 +4482,14 @@ code = ''' memset(sim_prngs, 0, N*M*sizeof(uint32_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 2; // create an attr? if (op == 0) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // choose an attr uint8_t a = TEST_PRNG(&prng) % M; // choose a prng @@ -4489,12 +4498,12 @@ code = ''' // update the attr uint32_t wprng_ = wprng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } memcpy(a_buf[x][a], wbuf, SIZE); a_size[x][a] = SIZE; - lfsr_file_sync(&lfs, &file[x]) => 0; + lfs3_file_sync(&lfs3, &file[x]) => 0; // update our sim sim_prngs[x*M+a] = wprng; @@ -4502,13 +4511,13 @@ code = ''' // remove an attr? } else if (op == 1) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // choose an attr uint8_t a = TEST_PRNG(&prng) % M; // remove the attr - a_size[x][a] = LFS_ERR_NOATTR; - lfsr_file_sync(&lfs, &file[x]) => 0; + a_size[x][a] = LFS3_ERR_NOATTR; + lfs3_file_sync(&lfs3, &file[x]) => 0; // update our sim sim_prngs[x*M+a] = 0; @@ -4516,28 +4525,28 @@ code = ''' } // check attrs on all file handles - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { for (uint16_t a = 0; a < M; a++) { if (sim_prngs[x*M+a]) { assert(a_size[x][a] == SIZE); uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } assert(memcmp(a_buf[x][a], wbuf, SIZE) == 0); } else { - assert(a_size[x][a] == LFS_ERR_NOATTR); + assert(a_size[x][a] == LFS3_ERR_NOATTR); } } } - // clean up sim/lfs - for (lfs_size_t x = 0; x < N; x++) { - lfsr_file_close(&lfs, &file[x]) => 0; + // clean up sim/lfs3 + for (lfs3_size_t x = 0; x < N; x++) { + lfs3_file_close(&lfs3, &file[x]) => 0; } free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz attrs on multiple overlapping files @@ -4550,41 +4559,41 @@ defines.OPS = '4*N*M' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint8_t a_buf[N][H][M][SIZE]; - lfs_ssize_t a_size[N][H][M]; - struct lfs_attr attrs[N][H][M]; - struct lfs_file_config filecfg[N][H]; - lfsr_file_t file[N][H]; + lfs3_ssize_t a_size[N][H][M]; + struct lfs3_attr attrs[N][H][M]; + struct lfs3_file_config filecfg[N][H]; + lfs3_file_t file[N][H]; // create N files - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; sprintf(path, "cat%03x", x); - for (lfs_size_t y = 0; y < H; y++) { - for (lfs_size_t a = 0; a < M; a++) { - attrs[x][y][a] = (struct lfs_attr){ + for (lfs3_size_t y = 0; y < H; y++) { + for (lfs3_size_t a = 0; a < M; a++) { + attrs[x][y][a] = (struct lfs3_attr){ .type = a, - .flags = LFS_A_RDWR, + .flags = LFS3_A_RDWR, .buffer = a_buf[x][y][a], .buffer_size = SIZE, .size = &a_size[x][y][a], }; } - filecfg[x][y] = (struct lfs_file_config){ + filecfg[x][y] = (struct lfs3_file_config){ .attrs = attrs[x][y], .attr_count = M, }; - lfsr_file_opencfg(&lfs, &file[x][y], path, - LFS_O_WRONLY | LFS_O_CREAT, + lfs3_file_opencfg(&lfs3, &file[x][y], path, + LFS3_O_WRONLY | LFS3_O_CREAT, &filecfg[x][y]) => 0; - lfsr_file_write(&lfs, &file[x][y], "meow", strlen("meow")) + lfs3_file_write(&lfs3, &file[x][y], "meow", strlen("meow")) => strlen("meow"); - lfsr_file_sync(&lfs, &file[x][y]) => 0; + lfs3_file_sync(&lfs3, &file[x][y]) => 0; } } @@ -4593,16 +4602,16 @@ code = ''' memset(sim_prngs, 0, N*M*sizeof(uint32_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 2; // create an attr? if (op == 0) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // choose a file handle - lfs_size_t y = TEST_PRNG(&prng) % H; + lfs3_size_t y = TEST_PRNG(&prng) % H; // choose an attr uint8_t a = TEST_PRNG(&prng) % M; // choose a prng @@ -4611,12 +4620,12 @@ code = ''' // update the attr uint32_t wprng_ = wprng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } memcpy(a_buf[x][y][a], wbuf, SIZE); a_size[x][y][a] = SIZE; - lfsr_file_sync(&lfs, &file[x][y]) => 0; + lfs3_file_sync(&lfs3, &file[x][y]) => 0; // update our sim sim_prngs[x*M+a] = wprng; @@ -4624,15 +4633,15 @@ code = ''' // remove an attr? } else if (op == 1) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // choose a file handle - lfs_size_t y = TEST_PRNG(&prng) % H; + lfs3_size_t y = TEST_PRNG(&prng) % H; // choose an attr uint8_t a = TEST_PRNG(&prng) % M; // remove the attr - a_size[x][y][a] = LFS_ERR_NOATTR; - lfsr_file_sync(&lfs, &file[x][y]) => 0; + a_size[x][y][a] = LFS3_ERR_NOATTR; + lfs3_file_sync(&lfs3, &file[x][y]) => 0; // update our sim sim_prngs[x*M+a] = 0; @@ -4640,32 +4649,32 @@ code = ''' } // check attrs on all file handles - for (lfs_size_t x = 0; x < N; x++) { - for (lfs_size_t y = 0; y < H; y++) { + for (lfs3_size_t x = 0; x < N; x++) { + for (lfs3_size_t y = 0; y < H; y++) { for (uint16_t a = 0; a < M; a++) { if (sim_prngs[x*M+a]) { assert(a_size[x][y][a] == SIZE); uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } assert(memcmp(a_buf[x][y][a], wbuf, SIZE) == 0); } else { - assert(a_size[x][y][a] == LFS_ERR_NOATTR); + assert(a_size[x][y][a] == LFS3_ERR_NOATTR); } } } } - // clean up sim/lfs - for (lfs_size_t x = 0; x < N; x++) { - for (lfs_size_t y = 0; y < M; y++) { - lfsr_file_close(&lfs, &file[x][y]) => 0; + // clean up sim/lfs3 + for (lfs3_size_t x = 0; x < N; x++) { + for (lfs3_size_t y = 0; y < M; y++) { + lfs3_file_close(&lfs3, &file[x][y]) => 0; } } free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz file-attached attrs mixed with file moves and removes @@ -4677,40 +4686,40 @@ defines.OPS = '4*N*M' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint8_t a_buf[N][M][SIZE]; - lfs_ssize_t a_size[N][M]; - struct lfs_attr attrs[N][M]; - struct lfs_file_config filecfg[N]; - lfsr_file_t file[N]; + lfs3_ssize_t a_size[N][M]; + struct lfs3_attr attrs[N][M]; + struct lfs3_file_config filecfg[N]; + lfs3_file_t file[N]; // create N files - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; sprintf(path, "cat%03x", x); - for (lfs_size_t a = 0; a < M; a++) { - attrs[x][a] = (struct lfs_attr){ + for (lfs3_size_t a = 0; a < M; a++) { + attrs[x][a] = (struct lfs3_attr){ .type = a, - .flags = LFS_A_RDWR, + .flags = LFS3_A_RDWR, .buffer = a_buf[x][a], .buffer_size = SIZE, .size = &a_size[x][a], }; } - filecfg[x] = (struct lfs_file_config){ + filecfg[x] = (struct lfs3_file_config){ .attrs = attrs[x], .attr_count = M, }; - lfsr_file_opencfg(&lfs, &file[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL, + lfs3_file_opencfg(&lfs3, &file[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL, &filecfg[x]) => 0; - lfsr_file_write(&lfs, &file[x], "meow", strlen("meow")) + lfs3_file_write(&lfs3, &file[x], "meow", strlen("meow")) => strlen("meow"); - lfsr_file_sync(&lfs, &file[x]) => 0; + lfs3_file_sync(&lfs3, &file[x]) => 0; } // set up a simulation to compare against @@ -4718,14 +4727,14 @@ code = ''' memset(sim_prngs, 0, N*M*sizeof(uint32_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 4; // create an attr? if (op == 0) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // choose an attr uint8_t a = TEST_PRNG(&prng) % M; // choose a prng @@ -4734,12 +4743,12 @@ code = ''' // update the attr uint32_t wprng_ = wprng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } memcpy(a_buf[x][a], wbuf, SIZE); a_size[x][a] = SIZE; - lfsr_file_sync(&lfs, &file[x]) => 0; + lfs3_file_sync(&lfs3, &file[x]) => 0; // update our sim sim_prngs[x*M+a] = wprng; @@ -4747,13 +4756,13 @@ code = ''' // remove an attr? } else if (op == 1) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // choose an attr uint8_t a = TEST_PRNG(&prng) % M; // remove the attr - a_size[x][a] = LFS_ERR_NOATTR; - lfsr_file_sync(&lfs, &file[x]) => 0; + a_size[x][a] = LFS3_ERR_NOATTR; + lfs3_file_sync(&lfs3, &file[x]) => 0; // update our sim sim_prngs[x*M+a] = 0; @@ -4761,12 +4770,12 @@ code = ''' // remove a file? } else if (op == 2) { // choose a file - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char path[256]; sprintf(path, "cat%03x", x); // remove the file - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; // check that remove had no affect on open attrs for (uint16_t a = 0; a < M; a++) { @@ -4774,25 +4783,25 @@ code = ''' assert(a_size[x][a] == SIZE); uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } assert(memcmp(a_buf[x][a], wbuf, SIZE) == 0); } else { - assert(a_size[x][a] == LFS_ERR_NOATTR); + assert(a_size[x][a] == LFS3_ERR_NOATTR); } } // but recreate the file so we always have something to // attach attrs to - lfsr_file_close(&lfs, &file[x]) => 0; + lfs3_file_close(&lfs3, &file[x]) => 0; sprintf(path, "cat%03x", x); - lfsr_file_opencfg(&lfs, &file[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL, + lfs3_file_opencfg(&lfs3, &file[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL, &filecfg[x]) => 0; - lfsr_file_write(&lfs, &file[x], "miao", strlen("miao")) + lfs3_file_write(&lfs3, &file[x], "miao", strlen("miao")) => strlen("miao"); - lfsr_file_sync(&lfs, &file[x]) => 0; + lfs3_file_sync(&lfs3, &file[x]) => 0; // update our sim memset(&sim_prngs[x*M], 0, M*sizeof(uint32_t)); @@ -4800,15 +4809,15 @@ code = ''' // rename a file? } else if (op == 3) { // choose two files - lfs_size_t x = TEST_PRNG(&prng) % N; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t y = TEST_PRNG(&prng) % N; char path[256]; char path_[256]; sprintf(path, "cat%03x", x); sprintf(path_, "cat%03x", y); // rename the file - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; // check that rename had no affect on open attrs for (uint16_t a = 0; a < M; a++) { @@ -4816,12 +4825,12 @@ code = ''' assert(a_size[x][a] == SIZE); uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } assert(memcmp(a_buf[x][a], wbuf, SIZE) == 0); } else { - assert(a_size[x][a] == LFS_ERR_NOATTR); + assert(a_size[x][a] == LFS3_ERR_NOATTR); } } for (uint16_t a = 0; a < M; a++) { @@ -4829,31 +4838,31 @@ code = ''' assert(a_size[y][a] == SIZE); uint32_t wprng_ = sim_prngs[y*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } assert(memcmp(a_buf[y][a], wbuf, SIZE) == 0); } else { - assert(a_size[y][a] == LFS_ERR_NOATTR); + assert(a_size[y][a] == LFS3_ERR_NOATTR); } } if (x != y) { // but recreate the file so we always have something to // attach attrs to - lfsr_file_close(&lfs, &file[y]) => 0; + lfs3_file_close(&lfs3, &file[y]) => 0; sprintf(path, "cat%03x", y); - lfsr_file_opencfg(&lfs, &file[y], path, - LFS_O_WRONLY, + lfs3_file_opencfg(&lfs3, &file[y], path, + LFS3_O_WRONLY, &filecfg[y]) => 0; - lfsr_file_close(&lfs, &file[x]) => 0; + lfs3_file_close(&lfs3, &file[x]) => 0; sprintf(path, "cat%03x", x); - lfsr_file_opencfg(&lfs, &file[x], path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL, + lfs3_file_opencfg(&lfs3, &file[x], path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL, &filecfg[x]) => 0; - lfsr_file_write(&lfs, &file[x], "nyan", strlen("nyan")) + lfs3_file_write(&lfs3, &file[x], "nyan", strlen("nyan")) => strlen("nyan"); - lfsr_file_sync(&lfs, &file[x]) => 0; + lfs3_file_sync(&lfs3, &file[x]) => 0; // update our sim memcpy(&sim_prngs[y*M], &sim_prngs[x*M], M*sizeof(uint32_t)); @@ -4863,28 +4872,28 @@ code = ''' } // check attrs on all file handles - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { for (uint16_t a = 0; a < M; a++) { if (sim_prngs[x*M+a]) { assert(a_size[x][a] == SIZE); uint32_t wprng_ = sim_prngs[x*M+a]; uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&wprng_) % 26); } assert(memcmp(a_buf[x][a], wbuf, SIZE) == 0); } else { - assert(a_size[x][a] == LFS_ERR_NOATTR); + assert(a_size[x][a] == LFS3_ERR_NOATTR); } } } - // clean up sim/lfs - for (lfs_size_t x = 0; x < N; x++) { - lfsr_file_close(&lfs, &file[x]) => 0; + // clean up sim/lfs3 + for (lfs3_size_t x = 0; x < N; x++) { + lfs3_file_close(&lfs3, &file[x]) => 0; } free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that file-attached attrs are actually atomic @@ -4898,33 +4907,34 @@ fuzz = 'SEED' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; - lfsr_file_t state_file; - lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_t state_file; + lfs3_file_open(&lfs3, &state_file, + "state", LFS3_O_RDWR | LFS3_O_CREAT) => 0; fuzz_state_t state; - if (lfsr_file_size(&lfs, &state_file) == 0) { + if (lfs3_file_size(&lfs3, &state_file) == 0) { state.i = 0; state.prng = SEED; } else { - lfsr_file_read(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); } for (; state.i < OPS; state.i++) { // choose a random file - lfs_size_t x = TEST_PRNG(&state.prng) % N; + lfs3_size_t x = TEST_PRNG(&state.prng) % N; char path[256]; sprintf(path, "cat%03x", x); @@ -4934,35 +4944,35 @@ code = ''' // try to open the file with attrs uint8_t a_buf[M][SIZE]; - lfs_ssize_t a_size[M]; - struct lfs_attr attrs[M]; - struct lfs_file_config filecfg; - lfsr_file_t file; - for (lfs_size_t a = 0; a < M; a++) { - attrs[a] = (struct lfs_attr){ + lfs3_ssize_t a_size[M]; + struct lfs3_attr attrs[M]; + struct lfs3_file_config filecfg; + lfs3_file_t file; + for (lfs3_size_t a = 0; a < M; a++) { + attrs[a] = (struct lfs3_attr){ .type = a, - .flags = LFS_A_RDWR, + .flags = LFS3_A_RDWR, .buffer = a_buf[a], .buffer_size = SIZE, .size = &a_size[a], }; } - filecfg = (struct lfs_file_config){ + filecfg = (struct lfs3_file_config){ .attrs = attrs, .attr_count = M, }; - lfsr_file_opencfg(&lfs, &file, path, LFS_O_RDWR | LFS_O_CREAT, + lfs3_file_opencfg(&lfs3, &file, path, LFS3_O_RDWR | LFS3_O_CREAT, &filecfg) => 0; // if the file exists, check our invariant - if (lfsr_file_size(&lfs, &file) > 0) { + if (lfs3_file_size(&lfs3, &file) > 0) { uint8_t wbuf[SIZE]; - lfsr_file_read(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, wbuf, SIZE) => SIZE; - for (lfs_size_t a = 0; a < M; a++) { + for (lfs3_size_t a = 0; a < M; a++) { assert(a_size[a] == SIZE); - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(a_buf[a][j] == 'a' + (((wbuf[j]-'a') + a) % 26)); } } @@ -4971,85 +4981,85 @@ code = ''' // choose a new seed and rewrite our file uint32_t wprng = TEST_PRNG(&state.prng); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &file) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // and update attrs - for (lfs_size_t a = 0; a < M; a++) { + for (lfs3_size_t a = 0; a < M; a++) { a_size[a] = SIZE; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { a_buf[a][j] = 'a' + (((wbuf[j]-'a') + a) % 26); } } // and sync/close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // update our state file - lfsr_file_rewind(&lfs, &state_file) => 0; - lfsr_file_write(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_rewind(&lfs3, &state_file) => 0; + lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_sync(&lfs, &state_file) => 0; + lfs3_file_sync(&lfs3, &state_file) => 0; } // go ahead and close our state file in case we remount - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our invariant was held in all files - for (lfs_size_t x = 0; x < N; x++) { + for (lfs3_size_t x = 0; x < N; x++) { char path[256]; sprintf(path, "cat%03x", x); uint8_t a_buf[M][SIZE]; - lfs_ssize_t a_size[M]; - struct lfs_attr attrs[M]; - struct lfs_file_config filecfg; - lfsr_file_t file; - for (lfs_size_t a = 0; a < M; a++) { - attrs[a] = (struct lfs_attr){ + lfs3_ssize_t a_size[M]; + struct lfs3_attr attrs[M]; + struct lfs3_file_config filecfg; + lfs3_file_t file; + for (lfs3_size_t a = 0; a < M; a++) { + attrs[a] = (struct lfs3_attr){ .type = a, - .flags = LFS_A_RDWR, + .flags = LFS3_A_RDWR, .buffer = a_buf[a], .buffer_size = SIZE, .size = &a_size[a], }; } - filecfg = (struct lfs_file_config){ + filecfg = (struct lfs3_file_config){ .attrs = attrs, .attr_count = M, }; - int err = lfsr_file_opencfg(&lfs, &file, path, LFS_O_RDONLY, + int err = lfs3_file_opencfg(&lfs3, &file, path, LFS3_O_RDONLY, &filecfg); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { continue; } // if the file exists, check our invariant uint8_t wbuf[SIZE]; - lfsr_file_read(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, wbuf, SIZE) => SIZE; - for (lfs_size_t a = 0; a < M; a++) { + for (lfs3_size_t a = 0; a < M; a++) { assert(a_size[a] == SIZE); - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(a_buf[a][j] == 'a' + (((wbuf[j]-'a') + a) % 26)); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index 2a2c8036..0cd9e377 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -21,63 +21,63 @@ after = [ [cases.test_badblocks_every_btree_many] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] # maximize lookahead buffer to avoid alloc scans defines.LOOKAHEAD_SIZE = '(BLOCK_COUNT+8-1) / 8' defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' -in = 'lfs.c' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' +in = 'lfs3.c' code = ''' // test all possible bad blocks - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test creating a btree - lfs_t lfs; - lfs_init(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_init(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against char *sim = malloc(N); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; memset(sim, 0, N); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim @@ -89,7 +89,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -104,30 +104,30 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == i); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -135,114 +135,114 @@ code = ''' [cases.test_badblocks_every_spam_dir_many] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test creating directories - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -250,54 +250,54 @@ code = ''' [cases.test_badblocks_every_spam_dir_fuzz] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.OPS = '2*N' defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test fuzz with dirs - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -305,7 +305,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -316,47 +316,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -368,67 +368,67 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -436,14 +436,14 @@ code = ''' [cases.test_badblocks_every_spam_file_many] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -455,91 +455,91 @@ defines.SIZE = [ '4*BLOCK_SIZE', ] if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 32', ] code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test creating files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -547,14 +547,14 @@ code = ''' [cases.test_badblocks_every_spam_file_fuzz] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' defines.SIZE = [ @@ -569,49 +569,49 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test fuzz with files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -620,7 +620,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -635,24 +635,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -660,25 +660,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -691,7 +691,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -699,7 +699,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -714,82 +714,82 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -797,14 +797,14 @@ code = ''' [cases.test_badblocks_every_spam_fwrite_fuzz] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.OPS = 20 defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -824,142 +824,142 @@ defines.SYNC = [false, true] defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', 'CHUNK <= SIZE', # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test with complex file writes - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( TEST_PRNG(&prng) % CHUNK, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } if (chunk != 0) { - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); } // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -967,14 +967,14 @@ code = ''' [cases.test_badblocks_every_spam_uz_fuzz] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' defines.SIZE = [ @@ -989,48 +989,48 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test with uncreats, zombies, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -1041,13 +1041,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -1061,23 +1061,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -1089,7 +1089,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1098,7 +1098,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1118,26 +1118,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -1148,7 +1148,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -1164,8 +1164,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -1173,10 +1173,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -1187,7 +1187,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -1195,10 +1195,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -1216,17 +1216,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1234,7 +1234,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1247,9 +1247,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -1258,16 +1258,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1283,7 +1283,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1293,7 +1293,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1307,7 +1307,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -1321,97 +1321,97 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -1419,14 +1419,14 @@ code = ''' [cases.test_badblocks_every_spam_uzd_fuzz] defines.BADBLOCK = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' defines.SIZE = [ @@ -1441,49 +1441,49 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test all possible bad blocks - for (lfs_size_t i = 2; + for (lfs3_size_t i = 2; i < ((BADBLOCK == -1) ? BLOCK_COUNT : 1); i++) { - lfs_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; + lfs3_size_t badblock = (BADBLOCK == -1) ? i : BADBLOCK; printf("--- badblock: 0x%x ---\n", badblock); // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // test with uncreats, zombies, dirs, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -1494,13 +1494,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -1517,23 +1517,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -1545,7 +1545,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1554,7 +1554,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1577,26 +1577,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -1607,7 +1607,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -1623,19 +1623,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -1646,7 +1646,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -1654,10 +1654,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -1677,17 +1677,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1697,7 +1697,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1710,14 +1710,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -1735,16 +1735,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1763,7 +1763,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1775,7 +1775,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1792,7 +1792,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -1806,9 +1806,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1821,14 +1821,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1844,7 +1844,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1853,113 +1853,113 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badblock - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -1974,65 +1974,65 @@ code = ''' # them a bit of a pain to test, here we test them explicitly [cases.test_badblocks_region_btree_many] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] # maximize lookahead buffer to avoid alloc scans defines.LOOKAHEAD_SIZE = '(BLOCK_COUNT+8-1) / 8' defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' -in = 'lfs.c' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' +in = 'lfs3.c' code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } else { - lfs_emubd_markbad(CFG, i + BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i + BLOCK_COUNT/2) => 0; } } // test creating a btree - lfs_t lfs; - lfs_init(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_init(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against char *sim = malloc(N); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; memset(sim, 0, N); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim @@ -2044,7 +2044,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -2059,202 +2059,202 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == i); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' # badblocks with dirs [cases.test_badblocks_region_spam_dir_many] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test creating directories - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with fuzz dirs [cases.test_badblocks_region_spam_dir_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.OPS = '2*N' defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test fuzz with dirs - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2262,7 +2262,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -2273,47 +2273,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -2325,77 +2325,77 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with files [cases.test_badblocks_region_spam_file_many] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -2408,106 +2408,106 @@ defines.SIZE = [ '4*BLOCK_SIZE', ] if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 32', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test creating files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with fuzz files [cases.test_badblocks_region_spam_file_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' @@ -2523,54 +2523,54 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test fuzz with files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2579,7 +2579,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -2594,24 +2594,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2619,25 +2619,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2650,7 +2650,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -2658,7 +2658,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -2673,92 +2673,92 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with more complex file writes [cases.test_badblocks_region_spam_fwrite_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.OPS = 20 defines.SIZE = [ @@ -2779,157 +2779,157 @@ defines.SYNC = [false, true] defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', 'CHUNK <= SIZE', # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test with complex file writes - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( TEST_PRNG(&prng) % CHUNK, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } if (chunk != 0) { - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); } // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with uncreats, zombies, etc [cases.test_badblocks_region_spam_uz_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' @@ -2945,53 +2945,53 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test with uncreats, zombies, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -3002,13 +3002,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -3022,23 +3022,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -3050,7 +3050,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -3059,7 +3059,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3079,26 +3079,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -3109,7 +3109,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -3125,8 +3125,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -3134,10 +3134,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -3148,7 +3148,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -3156,10 +3156,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -3177,17 +3177,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3195,7 +3195,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -3208,9 +3208,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -3219,16 +3219,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3244,7 +3244,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3254,7 +3254,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3268,7 +3268,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -3282,107 +3282,107 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with uncreats, zombies, dirs, etc [cases.test_badblocks_region_spam_uzd_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' @@ -3398,54 +3398,54 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16' ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (i >= 2) { - lfs_emubd_markbad(CFG, i) => 0; + lfs3_emubd_markbad(CFG, i) => 0; } } else { if (i+BLOCK_COUNT/2 >= 2) { - lfs_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; + lfs3_emubd_markbad(CFG, i+BLOCK_COUNT/2) => 0; } } } // test with uncreats, zombies, dirs, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -3456,13 +3456,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -3479,23 +3479,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -3507,7 +3507,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -3516,7 +3516,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3539,26 +3539,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -3569,7 +3569,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -3585,19 +3585,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -3608,7 +3608,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -3616,10 +3616,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -3639,17 +3639,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3659,7 +3659,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -3672,14 +3672,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -3697,16 +3697,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3725,7 +3725,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3737,7 +3737,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3754,7 +3754,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -3768,9 +3768,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -3783,14 +3783,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3806,7 +3806,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -3815,110 +3815,110 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -3931,65 +3931,65 @@ code = ''' # them a bit of a pain to test, here we test them explicitly [cases.test_badblocks_alternating_btree_many] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] # maximize lookahead buffer to avoid alloc scans defines.LOOKAHEAD_SIZE = '(BLOCK_COUNT+8-1) / 8' defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' -in = 'lfs.c' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' +in = 'lfs3.c' code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } else { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } // test creating a btree - lfs_t lfs; - lfs_init(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_init(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against char *sim = malloc(N); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; memset(sim, 0, N); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim @@ -4001,7 +4001,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -4016,202 +4016,202 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == i); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' # badblocks with dirs [cases.test_badblocks_alternating_spam_dir_many] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test creating directories - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with fuzz dirs [cases.test_badblocks_alternating_spam_dir_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.OPS = '2*N' defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test fuzz with dirs - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -4219,7 +4219,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -4230,47 +4230,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -4282,77 +4282,77 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with files [cases.test_badblocks_alternating_spam_file_many] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -4365,106 +4365,106 @@ defines.SIZE = [ '4*BLOCK_SIZE', ] if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 32', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test creating files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with fuzz files [cases.test_badblocks_alternating_spam_file_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' @@ -4480,54 +4480,54 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test fuzz with files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -4536,7 +4536,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -4551,24 +4551,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -4576,25 +4576,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -4607,7 +4607,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -4615,7 +4615,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -4630,92 +4630,92 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with more complex file writes [cases.test_badblocks_alternating_spam_fwrite_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.OPS = 20 defines.SIZE = [ @@ -4736,155 +4736,155 @@ defines.SYNC = [false, true] defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', 'CHUNK <= SIZE', # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test with complex file writes - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with uncreats, zombies, etc [cases.test_badblocks_alternating_spam_uz_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' @@ -4900,53 +4900,53 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test with uncreats, zombies, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -4957,13 +4957,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -4977,23 +4977,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -5005,7 +5005,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -5014,7 +5014,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -5034,26 +5034,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -5064,7 +5064,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -5080,8 +5080,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -5089,10 +5089,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -5103,7 +5103,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -5111,10 +5111,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -5132,17 +5132,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -5150,7 +5150,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -5163,9 +5163,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -5174,16 +5174,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -5199,7 +5199,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -5209,7 +5209,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -5223,7 +5223,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -5237,107 +5237,107 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # badblocks with uncreats, zombies, dirs, etc [cases.test_badblocks_alternating_spam_uzd_fuzz] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.MIRROR = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.OPS = '2*N' @@ -5353,54 +5353,54 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // test a large region of bad blocks - for (lfs_size_t i = 0; i < BLOCK_COUNT/2; i++) { + for (lfs3_size_t i = 0; i < BLOCK_COUNT/2; i++) { // mark our badblock as bad if (!MIRROR) { if (2*i+0 >= 2) { - lfs_emubd_markbad(CFG, 2*i+0) => 0; + lfs3_emubd_markbad(CFG, 2*i+0) => 0; } } else { if (2*i+1 >= 2) { - lfs_emubd_markbad(CFG, 2*i+1) => 0; + lfs3_emubd_markbad(CFG, 2*i+1) => 0; } } } // test with uncreats, zombies, dirs, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -5411,13 +5411,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -5434,23 +5434,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -5462,7 +5462,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -5471,7 +5471,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -5494,26 +5494,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -5524,7 +5524,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -5540,19 +5540,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -5563,7 +5563,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -5571,10 +5571,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -5594,17 +5594,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -5614,7 +5614,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -5627,14 +5627,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -5652,16 +5652,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -5680,7 +5680,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -5692,7 +5692,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -5709,7 +5709,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -5723,9 +5723,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -5738,14 +5738,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -5761,7 +5761,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -5770,110 +5770,110 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -5884,73 +5884,73 @@ code = ''' [cases.test_badblocks_mrootanchor_format] defines.BADBLOCKS = [0x1, 0x2, 0x3] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] code = ''' if (BADBLOCKS & 0x1) { - lfs_emubd_markbad(CFG, 0) => 0; + lfs3_emubd_markbad(CFG, 0) => 0; } if (BADBLOCKS & 0x2) { - lfs_emubd_markbad(CFG, 1) => 0; + lfs3_emubd_markbad(CFG, 1) => 0; } - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => LFS_ERR_CORRUPT; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => LFS3_ERR_CORRUPT; ''' # test blocks 0 or 1 going bad, this should just error [cases.test_badblocks_mrootanchor_wear] defines.BADBLOCKS = [0x1, 0x2] defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; if (BADBLOCKS & 0x1) { - lfs_emubd_markbad(CFG, 0) => 0; + lfs3_emubd_markbad(CFG, 0) => 0; } if (BADBLOCKS & 0x2) { - lfs_emubd_markbad(CFG, 1) => 0; + lfs3_emubd_markbad(CFG, 1) => 0; } - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), CFG) => 0; - for (lfs_size_t i = 0;; i++) { + for (lfs3_size_t i = 0;; i++) { // this should eventually fail assert(i <= BLOCK_COUNT); - int err = lfsr_mkdir(&lfs, "hi"); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, "hi"); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { break; } - err = lfsr_remove(&lfs, "hi"); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_remove(&lfs3, "hi"); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { break; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_bd.toml b/tests/test_bd.toml index 25910ef3..88871c53 100644 --- a/tests/test_bd.toml +++ b/tests/test_bd.toml @@ -10,23 +10,23 @@ defines.READ = ['READ_SIZE', 'BLOCK_SIZE'] defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE'] code = ''' - uint8_t buffer[LFS_MAX(READ, PROG)]; + uint8_t buffer[LFS3_MAX(READ, PROG)]; // write data CFG->erase(CFG, 0) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (i+j) % 251; } CFG->prog(CFG, 0, i, buffer, PROG) => 0; } // read data - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, 0, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (i+j) % 251); } } ''' @@ -35,14 +35,14 @@ code = ''' defines.READ = ['READ_SIZE', 'BLOCK_SIZE'] defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE'] code = ''' - uint8_t buffer[LFS_MAX(READ, PROG)]; - lfs_block_t block; + uint8_t buffer[LFS3_MAX(READ, PROG)]; + lfs3_block_t block; // write block 0 block = 0; CFG->erase(CFG, block) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (block+i+j) % 251; } CFG->prog(CFG, block, i, buffer, PROG) => 0; @@ -50,19 +50,19 @@ code = ''' // read block 0 block = 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } // write block 1 block = 1; CFG->erase(CFG, block) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (block+i+j) % 251; } CFG->prog(CFG, block, i, buffer, PROG) => 0; @@ -70,21 +70,21 @@ code = ''' // read block 1 block = 1; - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } // read block 0 again block = 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } ''' @@ -93,14 +93,14 @@ code = ''' defines.READ = ['READ_SIZE', 'BLOCK_SIZE'] defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE'] code = ''' - uint8_t buffer[LFS_MAX(READ, PROG)]; - lfs_block_t block; + uint8_t buffer[LFS3_MAX(READ, PROG)]; + lfs3_block_t block; // write block 0 block = 0; CFG->erase(CFG, block) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (block+i+j) % 251; } CFG->prog(CFG, block, i, buffer, PROG) => 0; @@ -108,19 +108,19 @@ code = ''' // read block 0 block = 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } // write block n-1 block = CFG->block_count-1; CFG->erase(CFG, block) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (block+i+j) % 251; } CFG->prog(CFG, block, i, buffer, PROG) => 0; @@ -128,21 +128,21 @@ code = ''' // read block n-1 block = CFG->block_count-1; - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } // read block 0 again block = 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } ''' @@ -151,26 +151,26 @@ code = ''' defines.READ = ['READ_SIZE', 'BLOCK_SIZE'] defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE'] code = ''' - uint8_t buffer[LFS_MAX(READ, PROG)]; + uint8_t buffer[LFS3_MAX(READ, PROG)]; // write/read every power of 2 - lfs_block_t block = 1; + lfs3_block_t block = 1; while (block < CFG->block_count) { // write CFG->erase(CFG, block) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (block+i+j) % 251; } CFG->prog(CFG, block, i, buffer, PROG) => 0; } // read - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } @@ -181,11 +181,11 @@ code = ''' block = 1; while (block < CFG->block_count) { // read - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } @@ -197,31 +197,31 @@ code = ''' defines.READ = ['READ_SIZE', 'BLOCK_SIZE'] defines.PROG = ['PROG_SIZE', 'BLOCK_SIZE'] code = ''' - uint8_t buffer[LFS_MAX(READ, PROG)]; + uint8_t buffer[LFS3_MAX(READ, PROG)]; // write/read every fibonacci number on our device - lfs_block_t block = 1; - lfs_block_t block_ = 1; + lfs3_block_t block = 1; + lfs3_block_t block_ = 1; while (block < CFG->block_count) { // write CFG->erase(CFG, block) => 0; - for (lfs_off_t i = 0; i < CFG->block_size; i += PROG) { - for (lfs_off_t j = 0; j < PROG; j++) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += PROG) { + for (lfs3_off_t j = 0; j < PROG; j++) { buffer[j] = (block+i+j) % 251; } CFG->prog(CFG, block, i, buffer, PROG) => 0; } // read - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } - lfs_block_t nblock = block + block_; + lfs3_block_t nblock = block + block_; block_ = block; block = nblock; } @@ -231,15 +231,15 @@ code = ''' block_ = 1; while (block < CFG->block_count) { // read - for (lfs_off_t i = 0; i < CFG->block_size; i += READ) { + for (lfs3_off_t i = 0; i < CFG->block_size; i += READ) { CFG->read(CFG, block, i, buffer, READ) => 0; - for (lfs_off_t j = 0; j < READ; j++) { - LFS_ASSERT(buffer[j] == (block+i+j) % 251); + for (lfs3_off_t j = 0; j < READ; j++) { + LFS3_ASSERT(buffer[j] == (block+i+j) % 251); } } - lfs_block_t nblock = block + block_; + lfs3_block_t nblock = block + block_; block_ = block; block = nblock; } diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 82826b81..ec596d69 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -7,21 +7,21 @@ defines.LOOKAHEAD_SIZE = '(BLOCK_COUNT+8-1) / 8' # test an empty tree [cases.test_btree_zero] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create an empty tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -29,34 +29,34 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # test an inlined tree [cases.test_btree_one] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -65,44 +65,44 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == 0); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # test a single-rbyd tree [cases.test_btree_two] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -111,49 +111,49 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_two_backwards] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -162,52 +162,52 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # still a single-rbyd tree, just making sure it works [cases.test_btree_three] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "c", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -216,58 +216,58 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, + lfs3_btree_lookupnext(&lfs3, &btree, 2, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_three_backwards] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "c", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -276,60 +276,60 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, + lfs3_btree_lookupnext(&lfs3, &btree, 2, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # try larger trees, when exactly a tree splits depends on the disk geometry, so # we don't really have a better way of testing multi-rbyd trees [cases.test_btree_push] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfs_size_t n = 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_size_t n = 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; n += 1; } @@ -341,47 +341,47 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_push_backwards] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfs_size_t n = 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_size_t n = 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+((N-1-i) % 26)}, 1))) => 0; n += 1; } @@ -393,62 +393,62 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, n-1-i, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, n-1-i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+((N-1-i) % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_push_fuzz] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; memset(sim, 0, N); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim @@ -460,7 +460,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -475,51 +475,51 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' [cases.test_btree_push_sparse] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfs_size_t n = 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_size_t n = 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, &(uint8_t){'a'+(i % 26)}, 1))) => 0; n += 1; } @@ -531,38 +531,38 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n*W, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n*W, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == i*W+W-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_push_sparse_fuzz] @@ -570,55 +570,55 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.W = 5 defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; memset(sim, 0, N); - memset(sim_weights, 0, N*sizeof(lfs_size_t)); + memset(sim_weights, 0, N*sizeof(lfs3_size_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // choose a pseudo-random weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } // add to btree - lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +weight, + lfs3_btree_commit(&lfs3, &btree, weighted_bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +weight, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); memmove(&sim_weights[bid+1], &sim_weights[bid], - (sim_size-bid)*sizeof(lfs_size_t)); + (sim_size-bid)*sizeof(lfs3_size_t)); sim[bid] = 'a'+(i % 26); sim_weights[bid] = weight; sim_size += 1; @@ -627,10 +627,10 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -647,56 +647,56 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } 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_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + lfs3_btree_lookupnext(&lfs3, &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); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -707,27 +707,27 @@ code = ''' # try some small trees for easy corner cases first [cases.test_btree_update_one] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; // update the tree - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "A", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -737,50 +737,50 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_two] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; // update the tree - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "A", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "B", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -790,63 +790,63 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_three] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "c", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; // update the tree - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "A", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "B", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "C", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -856,64 +856,64 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, + lfs3_btree_lookupnext(&lfs3, &btree, 2, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // update the tree - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'A'+(i % 26)}, 1))) => 0; } printf("btree: w%d 0x%x.%x\n", @@ -924,48 +924,48 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'A'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, N, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, N, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_fuzz] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } @@ -974,19 +974,19 @@ code = ''' // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = 'a'+(i % 26); } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % N; + lfs3_size_t bid = TEST_PRNG(&prng) % N; // update btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'A'+(i % 26)}, 1))) => 0; // update sim @@ -996,7 +996,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { if (!first) { printf(", "); } @@ -1011,22 +1011,22 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, N, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, N, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -1035,32 +1035,32 @@ code = ''' [cases.test_btree_update_sparse] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // update the tree - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'A'+(i % 26)}, 1))) => 0; } printf("btree: w%d 0x%x.%x\n", @@ -1071,38 +1071,38 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'A'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, N*W, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, N*W, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == i*W+W-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'A'+(i % 26)}, 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_sparse_fuzz] @@ -1110,25 +1110,25 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.W = 5 defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } @@ -1137,33 +1137,33 @@ code = ''' // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - for (lfs_size_t i = 0; i < N; i++) { + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = 'a'+(i % 26); sim_weights[i] = W; } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % N; + lfs3_size_t bid = TEST_PRNG(&prng) % N; // choose a pseudo-random weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } // update btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'A'+(i % 26)}, 1), - LFSR_RATTR( - LFSR_TAG_GROW, +weight-sim_weights[bid]))) => 0; + LFS3_RATTR( + LFS3_TAG_GROW, +weight-sim_weights[bid]))) => 0; // update sim sim[bid] = 'A'+(i % 26); @@ -1173,10 +1173,10 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -1193,56 +1193,56 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < N; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < N; j++) { total_weight += sim_weights[j]; } 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_; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < N; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + lfs3_btree_lookupnext(&lfs3, &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); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -1254,26 +1254,26 @@ code = ''' # try some corner cases first, these are actually pretty tricky since we # need to recognize when to collapse back into an inlined tree [cases.test_btree_pop_one] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1282,17 +1282,17 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "A", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "A", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1300,40 +1300,40 @@ code = ''' assert(btree.weight == 1); // try looking up tags - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_two] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1342,24 +1342,24 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "B", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "B", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1367,47 +1367,47 @@ code = ''' assert(btree.weight == 2); // try looking up tags - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_two_other] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1416,24 +1416,24 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "A", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "A", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1441,49 +1441,49 @@ code = ''' assert(btree.weight == 2); // try looking up tags - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_three] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "b", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "c", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1492,31 +1492,31 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "C", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "C", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1524,60 +1524,60 @@ code = ''' assert(btree.weight == 3); // try looking up tags - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 1, + lfs3_btree_lookupnext(&lfs3, &btree, 1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 2, + lfs3_btree_lookupnext(&lfs3, &btree, 2, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 3, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.REMAINING = [64, 2, 1, 0] if = 'N > REMAINING' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // drain the tree - for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { + lfs3_btree_commit(&lfs3, &btree, N-1-i, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; } printf("btree: w%d 0x%x.%x\n", @@ -1588,77 +1588,77 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, REMAINING, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try recovering - lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "R", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, REMAINING, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "R", 1))) => 0; - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, REMAINING, + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, REMAINING+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_backwards] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.REMAINING = [64, 2, 1, 0] if = 'N > REMAINING' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // drain the tree - for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1668,48 +1668,48 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+((i+(N-REMAINING)) % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, REMAINING, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try recovering - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "R", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "R", 1))) => 0; - lfsr_btree_lookupnext(&lfs, &btree, 0, + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i+1, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i+1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+((i+(N-REMAINING)) % 26)}, 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, REMAINING+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_fuzz] @@ -1718,25 +1718,25 @@ defines.REMAINING = [64, 2, 1, 0] defines.SEED = 'range(20)' fuzz = 'SEED' if = 'N > REMAINING' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } @@ -1745,19 +1745,19 @@ code = ''' // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t sim_size = N; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_size_t sim_size = N; + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = 'a'+(i % 26); } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < (N-REMAINING); i++) { + for (lfs3_size_t i = 0; i < (N-REMAINING); i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % sim_size; + lfs3_size_t bid = TEST_PRNG(&prng) % sim_size; // remove from btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -1767,7 +1767,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -1782,22 +1782,22 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -1808,31 +1808,31 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 defines.REMAINING = [64, 2, 1, 0] if = 'N > REMAINING' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // drain the tree - for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -W))) => 0; + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { + lfs3_btree_commit(&lfs3, &btree, (N-1-i)*W+W-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -W))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1842,71 +1842,71 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, REMAINING*W+W-1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING*W+W-1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // try recovering - lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +W, "R", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, REMAINING*W, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +W, "R", 1))) => 0; - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, REMAINING*W+W-1, + lfs3_btree_lookupnext(&lfs3, &btree, REMAINING*W+W-1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, "R", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, (REMAINING+1)*W+W-1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, (REMAINING+1)*W+W-1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + for (lfs3_size_t i = 0; i < REMAINING; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == i*W+W-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == REMAINING*W+W-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "R", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_sparse_fuzz] @@ -1916,45 +1916,45 @@ defines.REMAINING = [64, 2, 1, 0] defines.SEED = 'range(20)' fuzz = 'SEED' if = 'N > REMAINING' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; // set up simulation and btree with pseudo-random weights uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +weight, + lfs3_btree_commit(&lfs3, &btree, weighted_bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +weight, &(uint8_t){'a'+(i % 26)}, 1))) => 0; sim[i] = 'a'+(i % 26); @@ -1962,36 +1962,36 @@ code = ''' sim_size += 1; } - for (lfs_size_t i = 0; i < (N-REMAINING); i++) { + for (lfs3_size_t i = 0; i < (N-REMAINING); i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % sim_size; + lfs3_size_t bid = TEST_PRNG(&prng) % sim_size; // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } // remove from btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM, -sim_weights[bid]))) => 0; + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM, -sim_weights[bid]))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); memmove(&sim_weights[bid], &sim_weights[bid+1], - (sim_size-(bid+1))*sizeof(lfs_size_t)); + (sim_size-(bid+1))*sizeof(lfs3_size_t)); sim_size -= 1; } // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -2008,56 +2008,56 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } 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_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + lfs3_btree_lookupnext(&lfs3, &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); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2067,33 +2067,33 @@ code = ''' # test btree splits [cases.test_btree_split] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(0 % 26)}, 1))) => 0; - lfs_size_t n = 1; - for (lfs_size_t i = 1; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_size_t n = 1; + for (lfs3_size_t i = 1; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'a'+((i-1) % 26)}, 1), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+((i-0) % 26)}, 1))) => 0; n += 1; } @@ -2105,68 +2105,68 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_split_fuzz] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "_", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t sim_size = 1; + lfs3_size_t sim_size = 1; memset(sim, 0, N); sim[0] = '_'; uint32_t prng = SEED; - for (lfs_size_t i = 1; i < N; i++) { + for (lfs3_size_t i = 1; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % sim_size; + lfs3_size_t bid = TEST_PRNG(&prng) % sim_size; // split btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'a'+(i % 26)}, 1), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'A'+(i % 26)}, 1))) => 0; // split sim @@ -2179,7 +2179,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -2194,58 +2194,58 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' [cases.test_btree_split_sparse] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, &(uint8_t){'a'+(0 % 26)}, 1))) => 0; - lfs_size_t n = 1; - for (lfs_size_t i = 1; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_size_t n = 1; + for (lfs3_size_t i = 1; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, (i-1)*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'a'+((i-1) % 26)}, 1), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, &(uint8_t){'a'+((i-0) % 26)}, 1))) => 0; n += 1; } @@ -2257,23 +2257,23 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i*W+W-1, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n*W, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n*W, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_split_sparse_fuzz] @@ -2281,66 +2281,66 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.W = 5 defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +W, "_", 1))) => 0; + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +W, "_", 1))) => 0; // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 1; + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 1; memset(sim, 0, N); - memset(sim_weights, 0, N*sizeof(lfs_size_t)); + memset(sim_weights, 0, N*sizeof(lfs3_size_t)); sim[0] = '_'; sim_weights[0] = W; uint32_t prng = SEED; - for (lfs_size_t i = 1; i < N; i++) { + for (lfs3_size_t i = 1; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % sim_size; + lfs3_size_t bid = TEST_PRNG(&prng) % sim_size; // choose pseudo-random weights - lfs_size_t weight1 = 1 + (TEST_PRNG(&prng) % W); - lfs_size_t weight2 = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight1 = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight2 = 1 + (TEST_PRNG(&prng) % W); // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } // split btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_GROW, +weight1-sim_weights[bid]), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_GROW, +weight1-sim_weights[bid]), + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'a'+(i % 26)}, 1), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +weight2, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +weight2, &(uint8_t){'A'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); memmove(&sim_weights[bid+1], &sim_weights[bid], - (sim_size-bid)*sizeof(lfs_size_t)); + (sim_size-bid)*sizeof(lfs3_size_t)); sim[bid+0] = 'a'+(i % 26); sim[bid+1] = 'A'+(i % 26); sim_weights[bid+0] = weight1; @@ -2348,28 +2348,28 @@ code = ''' sim_size += 1; // TODO rm - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } 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_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + lfs3_btree_lookupnext(&lfs3, &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); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -2378,10 +2378,10 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -2398,56 +2398,56 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } 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_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + lfs3_btree_lookupnext(&lfs3, &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); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2459,47 +2459,47 @@ code = ''' # this should large enough so only one entry can fit in a block defines.SIZE = 'BLOCK_SIZE / 4' defines.SIBLING = [0, 1] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "_", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE), - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, buf1, SIZE), + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, buf2, SIZE))) => 0; assert(btree.weight == 2); // now remove one entry, since this brings the rbyd down to zero, // this should force one of the blocks to drop - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2508,60 +2508,60 @@ 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_lookupnext(&lfs, &btree, 0, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buf1, SIZE) => SIZE; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_drop_compact] # this should large enough so only one entry can fit in a block defines.SIZE = 'BLOCK_SIZE / 4' defines.SIBLING = [0, 1] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "_", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE), - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, buf1, SIZE), + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, buf2, SIZE))) => 0; assert(btree.weight == 2); @@ -2570,8 +2570,8 @@ code = ''' // // do this while forcing a compaction btree.eoff = -1; - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2580,54 +2580,54 @@ 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_lookupnext(&lfs, &btree, 0, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buf1, SIZE) => SIZE; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_drop_split] # this should large enough so only one entry can fit in a block defines.SIZE = 'BLOCK_SIZE / 4' defines.SIBLING = [0, 1] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "_", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE), - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, buf1, SIZE), + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction, causing a split, but while we're splitting, // also remove an entry, bringing the split rbyd down to zero mid split @@ -2635,8 +2635,8 @@ code = ''' // messy, isn't it? this is why we need an explicit test // btree.eoff = -1; - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2645,78 +2645,78 @@ 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_lookupnext(&lfs, &btree, 0, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buf1, SIZE) => SIZE; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buf1, SIZE) => SIZE; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_drop_merge] # this should large enough so only one entry can fit in a block defines.SIZE = 'BLOCK_SIZE / 4' defines.SIBLING = [0, 1] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "_", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, buf1, SIZE), - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, buf1, SIZE), + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, buf2, SIZE))) => 0; assert(btree.weight == 2); // now make both entries small so they should be merged if either compacts - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "a", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, "b", 1))) => 0; // force compaction, while removing one entry, this drops the rbyd // down to zero while also triggering a merge btree.eoff = -1; - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2725,20 +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_lookupnext(&lfs, &btree, 0, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buf1, SIZE) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buf1, SIZE) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, ((SIBLING) ? "a" : "b"), 1) == 0); // and check that our pop worked - lfsr_btree_lookupnext(&lfs, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' @@ -2747,42 +2747,42 @@ code = ''' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; memset(sim, 0, N); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); if (op == 0 || bid == sim_size) { // push to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // push to sim @@ -2792,9 +2792,9 @@ code = ''' } else if (op == 1) { // update btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // update sim @@ -2802,8 +2802,8 @@ code = ''' } else { // pop from btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -2814,7 +2814,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -2829,22 +2829,22 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2855,71 +2855,71 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; memset(sim, 0, N); - memset(sim_weights, 0, N*sizeof(lfs_size_t)); + memset(sim_weights, 0, N*sizeof(lfs3_size_t)); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // choose a pseudo-random weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } if (op == 0 || bid == sim_size) { // push to btree - lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +weight, + lfs3_btree_commit(&lfs3, &btree, weighted_bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +weight, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // push to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); memmove(&sim_weights[bid+1], &sim_weights[bid], - (sim_size-bid)*sizeof(lfs_size_t)); + (sim_size-bid)*sizeof(lfs3_size_t)); sim[bid] = 'a'+(i % 26); sim_weights[bid] = weight; sim_size += 1; } else if (op == 1) { // update btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'a'+(i % 26)}, 1), - LFSR_RATTR( - LFSR_TAG_GROW, +weight-sim_weights[bid]))) => 0; + LFS3_RATTR( + LFS3_TAG_GROW, +weight-sim_weights[bid]))) => 0; // update sim sim[bid] = 'a'+(i % 26); @@ -2927,15 +2927,15 @@ code = ''' } else { // remove from btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM, -sim_weights[bid]))) => 0; + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM, -sim_weights[bid]))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); memmove(&sim_weights[bid], &sim_weights[bid+1], - (sim_size-(bid+1))*sizeof(lfs_size_t)); + (sim_size-(bid+1))*sizeof(lfs3_size_t)); sim_size -= 1; } } @@ -2943,10 +2943,10 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -2963,56 +2963,56 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } 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_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, weighted_bid+sim_weights[i]-1, + lfs3_btree_lookupnext(&lfs3, &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); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, total_weight, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -3021,21 +3021,21 @@ code = ''' # test key-value btrees [cases.test_btree_find_zero] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a zero-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3043,38 +3043,38 @@ code = ''' assert(btree.weight == 0); // try to find tags - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfs_size_t weight_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_size_t weight_; - lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_ERR_NOENT; + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_ERR_NOENT; ''' [cases.test_btree_find_one] # true or false for if we should use dids vs names defines.DID = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a single-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "aaa", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3083,63 +3083,63 @@ code = ''' // try to find tags uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0*DID, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 1*DID, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_LT; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); ''' [cases.test_btree_find_two] # true or false for if we should use dids vs names defines.DID = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "aaa", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "aab", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3148,79 +3148,79 @@ code = ''' // try to find tags uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aab", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aac", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, "aac", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_LT; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); ''' [cases.test_btree_find_three] -in = 'lfs.c' +in = 'lfs3.c' # true or false for if we should use dids vs names defines.DID = [false, true] code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "aaa", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 1*DID, "aab", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 2*DID, "aac", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "2", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3229,89 +3229,89 @@ code = ''' // try to find tags uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0*DID, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 1*DID, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 2*DID, "aac", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 3*DID, "aad", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_LT; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); ''' [cases.test_btree_find_three_backwards] # true or false for if we should use dids vs names defines.DID = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a two-entry tree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "aaa", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 2*DID, "aac", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "2", 1))) => 0; + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 1*DID, "aab", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3320,51 +3320,51 @@ code = ''' // try to find tags uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0*DID, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 1*DID, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 2*DID, "aac", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); - lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 3*DID, "aad", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_LT; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); ''' @@ -3372,45 +3372,45 @@ code = ''' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] # true or false for if we should use dids vs names defines.DID = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); char name[3] = { 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(0 % 10)}, 1))) => 0; - lfs_size_t n = 1; - for (lfs_size_t i = 1; i < N; i++) { + lfs3_size_t n = 1; + for (lfs3_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, i-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+((i-1) % 10)}, 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, i*DID, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+((i-0) % 10)}, 1))) => 0; n += 1; } @@ -3422,26 +3422,26 @@ code = ''' // try to find tags uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { + for (lfs3_size_t i = 0; i < n; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, i*DID, name, 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'0'+(i % 10)}, 1) == 0); } ''' @@ -3450,26 +3450,26 @@ code = ''' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "___", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3477,22 +3477,22 @@ code = ''' // starting to be a problem... char *sim = malloc(N); char (*sim_names)[3] = malloc(N*3); - lfs_size_t sim_size = 1; + lfs3_size_t sim_size = 1; memset(sim, 0, N); memset(sim_names, 0, N*3); sim[0] = '_'; memcpy(&sim_names[0], "___", 3); uint32_t prng = SEED; - for (lfs_size_t i = 1; i < N; i++) { + for (lfs3_size_t i = 1; i < N; i++) { // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % (26*26*26); + lfs3_size_t x = TEST_PRNG(&prng) % (26*26*26); char name[3] = { 'a'+((x/26/26) % 26), 'a'+((x/26) % 26), 'a'+(x % 26) }; // find where to split - lfs_size_t bid = 0; + lfs3_size_t bid = 0; while (bid+1 < sim_size && memcmp(sim_names[bid+1], name, 3) <= 0) { bid += 1; } @@ -3502,15 +3502,15 @@ code = ''' } // split btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; // split sim @@ -3525,7 +3525,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -3540,28 +3540,28 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } // clean up sim free(sim); free(sim_names); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' [cases.test_btree_find_sparse] @@ -3569,45 +3569,45 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 # true or false for if we should use dids vs names defines.DID = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); char name[3] = { 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +W, + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +W, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(0 % 10)}, 1))) => 0; - lfs_size_t n = 1; - for (lfs_size_t i = 1; i < N; i++) { + lfs3_size_t n = 1; + for (lfs3_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, (i-1)*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+((i-1) % 10)}, 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +W, + LFS3_RATTR_NAME( + LFS3_TAG_REG, +W, i*DID, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+((i-0) % 10)}, 1))) => 0; n += 1; } @@ -3619,26 +3619,26 @@ code = ''' // try to find tags uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { + for (lfs3_size_t i = 0; i < n; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, i*DID, name, 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == i*W+W-1); assert(weight_ == W); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'0'+(i % 10)}, 1) == 0); } ''' @@ -3648,26 +3648,26 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.W = 5 defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +W, 0, "___", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3675,28 +3675,28 @@ code = ''' // starting to be a problem... char *sim = malloc(N); char (*sim_names)[3] = malloc(N*3); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 1; + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 1; memset(sim, 0, N); memset(sim_names, 0, N*3); - memset(sim_weights, 0, N*sizeof(lfs_size_t)); + memset(sim_weights, 0, N*sizeof(lfs3_size_t)); sim[0] = '_'; memcpy(&sim_names[0], "___", 3); sim_weights[0] = W; uint32_t prng = SEED; - for (lfs_size_t i = 1; i < N; i++) { + for (lfs3_size_t i = 1; i < N; i++) { // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % (26*26*26); + lfs3_size_t x = TEST_PRNG(&prng) % (26*26*26); char name[3] = { 'a'+((x/26/26) % 26), 'a'+((x/26) % 26), 'a'+(x % 26) }; // choose pseudo-random weights - lfs_size_t weight1 = 1 + (TEST_PRNG(&prng) % W); - lfs_size_t weight2 = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight1 = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight2 = 1 + (TEST_PRNG(&prng) % W); // find where to split - lfs_size_t bid = 0; + lfs3_size_t bid = 0; while (bid+1 < sim_size && memcmp(sim_names[bid+1], name, 3) <= 0) { bid += 1; } @@ -3706,31 +3706,31 @@ code = ''' } // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } // split btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_GROW, +weight1-sim_weights[bid]), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_GROW, +weight1-sim_weights[bid]), + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +weight2, + LFS3_RATTR_NAME( + LFS3_TAG_REG, +weight2, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); memmove(&sim_names[bid+1], &sim_names[bid], (sim_size-bid)*3); memmove(&sim_weights[bid+1], &sim_weights[bid], - (sim_size-bid)*sizeof(lfs_size_t)); + (sim_size-bid)*sizeof(lfs3_size_t)); sim[bid+0] = '0'+(i % 10); sim[bid+1] = '0'+(i % 10); memcpy(&sim_names[bid+1], name, 3); @@ -3742,10 +3742,10 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -3765,34 +3765,34 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } assert(btree.weight == total_weight); uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -3800,7 +3800,7 @@ code = ''' free(sim); free(sim_names); free(sim_weights); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' # make sure we test finds with other operations @@ -3808,26 +3808,26 @@ code = ''' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, "___", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3835,20 +3835,20 @@ code = ''' // starting to be a problem... char *sim = malloc(N); char (*sim_names)[3] = malloc(N*3); - lfs_size_t sim_size = 1; + lfs3_size_t sim_size = 1; memset(sim, 0, N); memset(sim_names, 0, N*3); sim[0] = '_'; memcpy(&sim_names[0], "___", 3); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % ((sim_size == 0) ? 1 : sim_size); + lfs3_size_t bid = TEST_PRNG(&prng) % ((sim_size == 0) ? 1 : sim_size); // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % (26*26*26); + lfs3_size_t x = TEST_PRNG(&prng) % (26*26*26); char name[3] = { 'a'+((x/26/26) % 26), 'a'+((x/26) % 26), 'a'+(x % 26) }; @@ -3856,7 +3856,7 @@ code = ''' // don't let sim drop below one element if (op == 0 || sim_size <= 1) { // find where to split - lfs_size_t bid = 0; + lfs3_size_t bid = 0; while (bid < sim_size && memcmp(name, sim_names[bid], 3) > 0) { bid += 1; } @@ -3872,7 +3872,7 @@ code = ''' // // This is because our btrees contain vestigial names, i.e. // our inner nodes may contain names no longer in the tree. - // This simplifies lfsr_btree_commit_, but means + // This simplifies lfs3_btree_commit_, but means // insert-before-bid+1 is _not_ the same as insert-after-bid // when named btrees are involved. If you try this it _will // not_ work and if try to make it work you _will_ cry: @@ -3888,30 +3888,30 @@ code = ''' // | .-. .---. | // a c d g h i k // ^ - lfsr_bid_t split_bid; - lfsr_rbyd_t split_rbyd; - lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree, + lfs3_bid_t split_bid; + lfs3_rbyd_t split_rbyd; + lfs3_scmp_t cmp = lfs3_btree_namelookupleaf(&lfs3, &btree, 0, name, 3, &split_bid, &split_rbyd, NULL, NULL, NULL, NULL); assert(cmp >= 0); - assert(cmp != LFS_CMP_EQ); - if (cmp > LFS_CMP_EQ) { - lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + assert(cmp != LFS3_CMP_EQ); + if (cmp > LFS3_CMP_EQ) { + lfs3_btree_commit(&lfs3, &btree, split_bid, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; } else { - lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( + lfs3_btree_commit(&lfs3, &btree, split_bid, LFS3_RATTRS( // yes, we need this noop, see above - LFSR_RATTR_NOOP(), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + LFS3_RATTR_NOOP(), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; } @@ -3924,9 +3924,9 @@ code = ''' } else if (op == 1) { // update btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; // update sim @@ -3934,8 +3934,8 @@ code = ''' } else { // pop from btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -3947,7 +3947,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -3962,21 +3962,21 @@ code = ''' assert(btree.weight == sim_size); uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -3990,26 +3990,26 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.W = 5 defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +W, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +W, 0, "___", 3), - LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -4017,39 +4017,39 @@ code = ''' // starting to be a problem... char *sim = malloc(N); char (*sim_names)[3] = malloc(N*3); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 1; + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 1; memset(sim, 0, N); memset(sim_names, 0, N*3); - memset(sim_weights, 0, N*sizeof(lfs_size_t)); + memset(sim_weights, 0, N*sizeof(lfs3_size_t)); sim[0] = '_'; memcpy(&sim_names[0], "___", 3); sim_weights[0] = W; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % ((sim_size == 0) ? 1 : sim_size); + lfs3_size_t bid = TEST_PRNG(&prng) % ((sim_size == 0) ? 1 : sim_size); // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % (26*26*26); + lfs3_size_t x = TEST_PRNG(&prng) % (26*26*26); char name[3] = { 'a'+((x/26/26) % 26), 'a'+((x/26) % 26), 'a'+(x % 26) }; // choose a pseudo-random weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < bid; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < bid; j++) { weighted_bid += sim_weights[j]; } // don't let sim drop below one element if (op == 0 || sim_size <= 1) { // find where to split - lfs_size_t bid = 0; + lfs3_size_t bid = 0; while (bid < sim_size && memcmp(name, sim_names[bid], 3) > 0) { bid += 1; } @@ -4065,7 +4065,7 @@ code = ''' // // This is because our btrees contain vestigial names, i.e. // our inner nodes may contain names no longer in the tree. - // This simplifies lfsr_btree_commit_, but means + // This simplifies lfs3_btree_commit_, but means // insert-before-bid+1 is _not_ the same as insert-after-bid // when named btrees are involved. If you try this it _will // not_ work and if try to make it work you _will_ cry: @@ -4082,32 +4082,32 @@ code = ''' // | .-. .---. | // a c d g h i k // ^ - lfsr_bid_t split_bid; - lfsr_rbyd_t split_rbyd; - lfsr_bid_t split_weight; - lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree, + lfs3_bid_t split_bid; + lfs3_rbyd_t split_rbyd; + lfs3_bid_t split_weight; + lfs3_scmp_t cmp = lfs3_btree_namelookupleaf(&lfs3, &btree, 0, name, 3, &split_bid, &split_rbyd, NULL, NULL, &split_weight, NULL); assert(cmp >= 0); - assert(cmp != LFS_CMP_EQ); - if (cmp > LFS_CMP_EQ) { - lfsr_btree_commit(&lfs, &btree, - split_bid-(split_weight-1), LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +weight, + assert(cmp != LFS3_CMP_EQ); + if (cmp > LFS3_CMP_EQ) { + lfs3_btree_commit(&lfs3, &btree, + split_bid-(split_weight-1), LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +weight, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; } else { - lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( + lfs3_btree_commit(&lfs3, &btree, split_bid, LFS3_RATTRS( // yes, we need this noop, see above - LFSR_RATTR_NOOP(), - LFSR_RATTR_NAME( - LFSR_TAG_REG, +weight, + LFS3_RATTR_NOOP(), + LFS3_RATTR_NAME( + LFS3_TAG_REG, +weight, 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; } @@ -4115,7 +4115,7 @@ code = ''' memmove(&sim[bid+1], &sim[bid], sim_size-bid); memmove(&sim_names[bid+1], &sim_names[bid], (sim_size-bid)*3); memmove(&sim_weights[bid+1], &sim_weights[bid], - (sim_size-bid)*sizeof(lfs_size_t)); + (sim_size-bid)*sizeof(lfs3_size_t)); sim[bid] = '0'+(i % 10); memcpy(&sim_names[bid], name, 3); sim_weights[bid] = weight; @@ -4123,13 +4123,13 @@ code = ''' } else if (op == 1) { // update btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_DATA, 0, + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1), - LFSR_RATTR( - LFSR_TAG_GROW, +weight-sim_weights[bid]))) => 0; + LFS3_RATTR( + LFS3_TAG_GROW, +weight-sim_weights[bid]))) => 0; // update sim sim[bid] = '0'+(i % 10); @@ -4137,16 +4137,16 @@ code = ''' } else { // pop from btree - lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM, -sim_weights[bid]))) => 0; + lfs3_btree_commit(&lfs3, &btree, + weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM, -sim_weights[bid]))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); memmove(&sim_names[bid], &sim_names[bid+1], (sim_size-(bid+1))*3); memmove(&sim_weights[bid], &sim_weights[bid+1], - (sim_size-(bid+1))*sizeof(lfs_size_t)); + (sim_size-(bid+1))*sizeof(lfs3_size_t)); sim_size -= 1; } } @@ -4154,10 +4154,10 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } @@ -4177,34 +4177,34 @@ code = ''' btree.blocks[0], btree.trunk); - lfs_size_t total_weight = 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_size_t j = 0; j < sim_size; j++) { total_weight += sim_weights[j]; } assert(btree.weight == total_weight); uint8_t buffer[4]; - lfsr_bid_t bid_; - lfsr_rbyd_t rbyd_; - lfsr_srid_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - for (lfs_size_t i = 0; i < sim_size; i++) { + lfs3_bid_t bid_; + lfs3_rbyd_t rbyd_; + lfs3_srid_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { // calculate actual bid in btree space - lfs_size_t weighted_bid = 0; - for (lfs_size_t j = 0; j < i; j++) { + lfs3_size_t weighted_bid = 0; + for (lfs3_size_t j = 0; j < i; j++) { weighted_bid += sim_weights[j]; } - lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; - lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + lfs3_btree_namelookupleaf(&lfs3, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS3_CMP_EQ; + lfs3_rbyd_lookup(&lfs3, &rbyd_, rid_, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -4220,26 +4220,26 @@ code = ''' # some simple btree traversals [cases.test_btree_traversal] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a tree with N elements - lfsr_btree_t btree; - lfsr_btree_init(&btree); - lfs_size_t n = 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_t btree; + lfs3_btree_init(&btree); + lfs3_size_t n = 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; n += 1; } @@ -4251,46 +4251,46 @@ 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_; + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i <= 2*N); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_btree_traverse(&lfs, &btree, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_btree_traverse(&lfs3, &btree, &bt, &bid, &tag, &data); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, @@ -4299,11 +4299,11 @@ code = ''' // keep track of seen blocks seen[rbyd->blocks[0] / 8] |= 1 << (rbyd->blocks[0] % 8); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(data)); + lfs3_data_size(data)); } else { // well this shouldn't happen @@ -4317,7 +4317,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -4328,57 +4328,57 @@ code = ''' // and the tree should still work // check that the elements are in the tree - for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < n; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } // and check that we can't lookup elements that aren't in the tree - lfsr_btree_lookupnext(&lfs, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, n, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_traversal_fuzz] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.SEED = 'range(20)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; // create free lookahead - memset(lfs.lookahead.buffer, 0, CFG->lookahead_size); - lfs.lookahead.window = 2; - lfs.lookahead.off = 0; - lfs.lookahead.size = lfs_min(8*CFG->lookahead_size, + memset(lfs3.lookahead.buffer, 0, CFG->lookahead_size); + lfs3.lookahead.window = 2; + lfs3.lookahead.off = 0; + lfs3.lookahead.size = lfs3_min(8*CFG->lookahead_size, CFG->block_count-2); - lfs_alloc_ckpoint(&lfs); + lfs3_alloc_ckpoint(&lfs3); // create a btree - lfsr_btree_t btree; - lfsr_btree_init(&btree); + lfs3_btree_t btree; + lfs3_btree_init(&btree); // set up a simulation to compare against // // fun fact this is slower than our actual tree! unfun fact this is // starting to be a problem... char *sim = malloc(N); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; memset(sim, 0, N); uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random bid - lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); + lfs3_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim @@ -4390,7 +4390,7 @@ code = ''' // check that btree matches sim printf("expd: ["); bool first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -4405,46 +4405,46 @@ 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_lookupnext(&lfs, &btree, i, + lfs3_bid_t bid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // test that we can traverse the tree, keeping track of all blocks // we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i <= 2*N); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_data_t data; - int err = lfsr_btree_traverse(&lfs, &btree, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_data_t data; + int err = lfs3_btree_traverse(&lfs3, &btree, &bt, &bid, &tag, &data); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, @@ -4453,11 +4453,11 @@ code = ''' // keep track of seen blocks seen[rbyd->blocks[0] / 8] |= 1 << (rbyd->blocks[0] % 8); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(data)); + lfs3_data_size(data)); } else { // well this shouldn't happen @@ -4471,7 +4471,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -4484,7 +4484,7 @@ code = ''' // check that btree matches sim printf("expd: ["); first = true; - for (lfs_size_t i = 0; i < sim_size; i++) { + for (lfs3_size_t i = 0; i < sim_size; i++) { if (!first) { printf(", "); } @@ -4498,21 +4498,21 @@ code = ''' btree.trunk); assert(btree.weight == sim_size); - for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_lookupnext(&lfs, &btree, i, + for (lfs3_size_t i = 0; i < sim_size; i++) { + lfs3_btree_lookupnext(&lfs3, &btree, i, &bid_, &tag_, &weight_, &data_) => 0; - lfsr_data_read(&lfs, &data_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_DATA); + lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } // and no extra elements - lfsr_btree_lookupnext(&lfs, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_btree_lookupnext(&lfs3, &btree, sim_size, + &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); - lfs_deinit(&lfs) => 0; + lfs3_deinit(&lfs3) => 0; ''' diff --git a/tests/test_ck.toml b/tests/test_ck.toml index 2068ec35..35753328 100644 --- a/tests/test_ck.toml +++ b/tests/test_ck.toml @@ -50,14 +50,14 @@ defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { uint8_t buffer[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { buffer[j] = TEST_PRNG(&prng); } uint32_t a = test_ck_naive_crc32c(0, buffer, SIZE); - uint32_t b = lfs_crc32c(0, buffer, SIZE); + uint32_t b = lfs3_crc32c(0, buffer, SIZE); assert(a == b); } ''' @@ -70,16 +70,16 @@ defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { uint8_t buffer[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { buffer[j] = TEST_PRNG(&prng); } - uint32_t a = lfs_crc32c(0, buffer, SIZE); + uint32_t a = lfs3_crc32c(0, buffer, SIZE); uint32_t b = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { - b = lfs_crc32c(b, &buffer[j], 1); + for (lfs3_size_t j = 0; j < SIZE; j++) { + b = lfs3_crc32c(b, &buffer[j], 1); } assert(a == b); } @@ -92,12 +92,12 @@ defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { uint32_t x = TEST_PRNG(&prng); uint32_t y = TEST_PRNG(&prng); uint32_t a = test_ck_naive_crc32c_mul(x, y); - uint32_t b = lfs_crc32c_mul(x, y); + uint32_t b = lfs3_crc32c_mul(x, y); assert(a == b); } ''' @@ -109,13 +109,13 @@ defines.N = 1000 fuzz = 'SEED' code = ''' uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { uint32_t x = TEST_PRNG(&prng); uint32_t y = TEST_PRNG(&prng); uint32_t z = TEST_PRNG(&prng); - uint32_t a = lfs_crc32c_mul(x, y ^ z); - uint32_t b = lfs_crc32c_mul(x, y) ^ lfs_crc32c_mul(x, z); + uint32_t a = lfs3_crc32c_mul(x, y ^ z); + uint32_t b = lfs3_crc32c_mul(x, y) ^ lfs3_crc32c_mul(x, z); assert(a == b); } ''' @@ -123,7 +123,7 @@ code = ''' # Test filesystem-level checksum things -# test that lfsr_fs_cksum doesn't do anything weird +# test that lfs3_fs_cksum doesn't do anything weird [cases.test_ck_cksum] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -137,55 +137,55 @@ defines.SIZE = [ ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, METHOD != 1)', + 'LFS3_IFDEF_GC(true, METHOD != 1)', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // get the filesystem cksum uint32_t gcksum; - lfsr_fs_cksum(&lfs, &gcksum) => 0; + lfs3_fs_cksum(&lfs3, &gcksum) => 0; printf("cksum: %08x\n", gcksum); // test that the cksum remains the same after a remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t gcksum_; - lfsr_fs_cksum(&lfs, &gcksum_) => 0; + lfs3_fs_cksum(&lfs3, &gcksum_) => 0; assert(gcksum_ == gcksum); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can detect at least fully clobbered blocks [cases.test_ck_ckmeta_easy] -# METHOD=0 => lfsr_fs_ckmeta -# METHOD=1 => lfsr_fs_gc -# METHOD=2 => lfsr_traversal_read -# METHOD=3 => lfsr_mount +# METHOD=0 => lfs3_fs_ckmeta +# METHOD=1 => lfs3_fs_gc +# METHOD=2 => lfs3_traversal_read +# METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] -defines.GC_FLAGS = 'LFS_GC_CKMETA' +defines.GC_FLAGS = 'LFS3_GC_CKMETA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -199,56 +199,56 @@ defines.SIZE = [ ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, METHOD != 1)', + 'LFS3_IFDEF_GC(true, METHOD != 1)', ] code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -257,9 +257,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -268,61 +268,61 @@ code = ''' } clobbered:; - // find clobbered blocks with lfsr_fs_ckmeta + // find clobbered blocks with lfs3_fs_ckmeta if (METHOD == 0) { - lfsr_fs_ckmeta(&lfs) => LFS_ERR_CORRUPT; + lfs3_fs_ckmeta(&lfs3) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfsr_fs_gc + // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { - #ifdef LFS_GC - lfsr_fs_gc(&lfs) => LFS_ERR_CORRUPT; + #ifdef LFS3_GC + lfs3_fs_gc(&lfs3) => LFS3_ERR_CORRUPT; #else - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfsr_traversal_read + // find clobbered blocks with lfs3_traversal_read } else if (METHOD == 2) { - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - // find clobbered blocks with lfsr_mount + // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_CKMETA, - CFG) => LFS_ERR_CORRUPT; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_CKMETA, + CFG) => LFS3_ERR_CORRUPT; } else { assert(false); } if (METHOD != 3) { - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } } done:; ''' [cases.test_ck_ckdata_easy] -# METHOD=0 => lfsr_fs_ckdata -# METHOD=1 => lfsr_fs_gc -# METHOD=2 => lfsr_traversal_read -# METHOD=3 => lfsr_mount +# METHOD=0 => lfs3_fs_ckdata +# METHOD=1 => lfs3_fs_gc +# METHOD=2 => lfs3_traversal_read +# METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] -defines.GC_FLAGS = 'LFS_GC_CKDATA' +defines.GC_FLAGS = 'LFS3_GC_CKDATA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -336,57 +336,57 @@ defines.SIZE = [ ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, METHOD != 1)', + 'LFS3_IFDEF_GC(true, METHOD != 1)', ] code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -395,9 +395,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -406,49 +406,49 @@ code = ''' } clobbered:; - // find clobbered blocks with lfsr_fs_ckmeta + // find clobbered blocks with lfs3_fs_ckmeta if (METHOD == 0) { - lfsr_fs_ckdata(&lfs) => LFS_ERR_CORRUPT; + lfs3_fs_ckdata(&lfs3) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfsr_fs_gc + // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { - #ifdef LFS_GC - lfsr_fs_gc(&lfs) => LFS_ERR_CORRUPT; + #ifdef LFS3_GC + lfs3_fs_gc(&lfs3) => LFS3_ERR_CORRUPT; #else - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfsr_traversal_read + // find clobbered blocks with lfs3_traversal_read } else if (METHOD == 2) { - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKDATA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - // find clobbered blocks with lfsr_mount + // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_CKDATA, - CFG) => LFS_ERR_CORRUPT; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_CKDATA, + CFG) => LFS3_ERR_CORRUPT; } else { assert(false); } if (METHOD != 3) { - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } } done:; @@ -456,12 +456,12 @@ done:; # test some more interesting errors [cases.test_ck_ckmeta_hard] -# METHOD=0 => lfsr_fs_ckmeta -# METHOD=1 => lfsr_fs_gc -# METHOD=2 => lfsr_traversal_read -# METHOD=3 => lfsr_mount +# METHOD=0 => lfs3_fs_ckmeta +# METHOD=1 => lfs3_fs_gc +# METHOD=2 => lfs3_traversal_read +# METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] -defines.GC_FLAGS = 'LFS_GC_CKMETA' +defines.GC_FLAGS = 'LFS3_GC_CKMETA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -478,59 +478,59 @@ defines.M = 100 fuzz = 'SEED' if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, METHOD != 1)', + 'LFS3_IFDEF_GC(true, METHOD != 1)', ] code = ''' uint32_t prng_ = SEED; - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - lfs_block_t badblock; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + lfs3_block_t badblock; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE) { // found an interesting block? if (k == i) { badblock = tinfo.block; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobber; } k += 1; @@ -540,69 +540,69 @@ code = ''' clobber:; // save the current gcksum uint32_t gcksum; - lfsr_fs_cksum(&lfs, &gcksum) => 0; + lfs3_fs_cksum(&lfs3, &gcksum) => 0; // try flipping some bits - for (lfs_size_t j = 0; j < M; j++) { + for (lfs3_size_t j = 0; j < M; j++) { // choose a bit - lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); + lfs3_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfsr_fs_ckmeta + // find clobbered blocks with lfs3_fs_ckmeta if (METHOD == 0) { - int err = lfsr_fs_ckmeta(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckmeta(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfsr_fs_gc + // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { - #ifdef LFS_GC - int err = lfsr_fs_gc(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + #ifdef LFS3_GC + int err = lfs3_fs_gc(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } #else - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfsr_traversal_read + // find clobbered blocks with lfs3_traversal_read } else if (METHOD == 2) { - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto detected; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - // find clobbered blocks with lfsr_mount + // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { - lfsr_unmount(&lfs) => 0; - int err = lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_CKMETA, + lfs3_unmount(&lfs3) => 0; + int err = lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_CKMETA, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } @@ -623,32 +623,32 @@ code = ''' // for any filesystem with logs (AKA any powerloss-resilient // filesystem). // - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfs_size_t found = 0; - for (lfs_size_t i = 0;; i++) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + lfs3_size_t found = 0; + for (lfs3_size_t i = 0;; i++) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } found += 1; char name[256]; sprintf(name, "squid%03x", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // we should at least detect rollback if we don't lose // power/remount @@ -661,62 +661,62 @@ code = ''' // stored externally if (found != N) { uint32_t gcksum_; - lfsr_fs_cksum(&lfs, &gcksum_) => 0; + lfs3_fs_cksum(&lfs3, &gcksum_) => 0; assert(gcksum_ != gcksum); } // test we can read the files that survived prng = 42; - for (lfs_size_t i = 0; i < found; i++) { + for (lfs3_size_t i = 0; i < found; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // clear any ck flags for gc - lfsr_fs_unck(&lfs, GC_FLAGS) => 0; + lfs3_fs_unck(&lfs3, GC_FLAGS) => 0; continue; detected:; // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // remount if we ended up unmounted if (METHOD == 3) { - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // clear any ck flags for gc - lfsr_fs_unck(&lfs, GC_FLAGS) => 0; + lfs3_fs_unck(&lfs3, GC_FLAGS) => 0; continue; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' [cases.test_ck_ckdata_hard] -# METHOD=0 => lfsr_fs_ckdata -# METHOD=1 => lfsr_fs_gc -# METHOD=2 => lfsr_traversal_read -# METHOD=3 => lfsr_mount +# METHOD=0 => lfs3_fs_ckdata +# METHOD=1 => lfs3_fs_gc +# METHOD=2 => lfs3_traversal_read +# METHOD=3 => lfs3_mount defines.METHOD = [0, 1, 2, 3] -defines.GC_FLAGS = 'LFS_GC_CKDATA' +defines.GC_FLAGS = 'LFS3_GC_CKDATA' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -733,60 +733,60 @@ defines.M = 100 fuzz = 'SEED' if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, METHOD != 1)', + 'LFS3_IFDEF_GC(true, METHOD != 1)', ] code = ''' uint32_t prng_ = SEED; - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - lfs_block_t badblock; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + lfs3_block_t badblock; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { // found an interesting block? if (k == i) { badblock = tinfo.block; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobber; } k += 1; @@ -795,70 +795,70 @@ code = ''' clobber:; // save the current gcksum - uint32_t gcksum = lfs.gcksum; - lfsr_fs_cksum(&lfs, &gcksum) => 0; + uint32_t gcksum = lfs3.gcksum; + lfs3_fs_cksum(&lfs3, &gcksum) => 0; // try flipping some bits - for (lfs_size_t j = 0; j < M; j++) { + for (lfs3_size_t j = 0; j < M; j++) { // choose a bit - lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); + lfs3_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfsr_fs_ckdata + // find clobbered blocks with lfs3_fs_ckdata if (METHOD == 0) { - int err = lfsr_fs_ckdata(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckdata(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfsr_fs_gc + // find clobbered blocks with lfs3_fs_gc } else if (METHOD == 1) { - #ifdef LFS_GC - int err = lfsr_fs_gc(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + #ifdef LFS3_GC + int err = lfs3_fs_gc(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } #else - LFS_UNREACHABLE(); + LFS3_UNREACHABLE(); #endif - // find clobbered blocks with lfsr_traversal_read + // find clobbered blocks with lfs3_traversal_read } else if (METHOD == 2) { - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_CKDATA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto detected; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - // find clobbered blocks with lfsr_mount + // find clobbered blocks with lfs3_mount } else if (METHOD == 3) { - lfsr_unmount(&lfs) => 0; - int err = lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_CKDATA, + lfs3_unmount(&lfs3) => 0; + int err = lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_CKDATA, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } @@ -879,32 +879,32 @@ code = ''' // for any filesystem with logs (AKA any powerloss-resilient // filesystem). // - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfs_size_t found = 0; - for (lfs_size_t i = 0;; i++) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + lfs3_size_t found = 0; + for (lfs3_size_t i = 0;; i++) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } found += 1; char name[256]; sprintf(name, "squid%03x", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // we should at least detect rollback if we don't lose // power/remount @@ -917,51 +917,51 @@ code = ''' // stored externally if (found != N) { uint32_t gcksum_; - lfsr_fs_cksum(&lfs, &gcksum_) => 0; + lfs3_fs_cksum(&lfs3, &gcksum_) => 0; assert(gcksum_ != gcksum); } // test we can read the files that survived prng = 42; - for (lfs_size_t i = 0; i < found; i++) { + for (lfs3_size_t i = 0; i < found; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // clear any ck flags for gc - lfsr_fs_unck(&lfs, GC_FLAGS) => 0; + lfs3_fs_unck(&lfs3, GC_FLAGS) => 0; continue; detected:; // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // remount if we ended up unmounted if (METHOD == 3) { - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // clear any ck flags for gc - lfsr_fs_unck(&lfs, GC_FLAGS) => 0; + lfs3_fs_unck(&lfs3, GC_FLAGS) => 0; continue; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -971,9 +971,9 @@ done:; # test we can detect at least fully clobbered blocks [cases.test_ck_file_ckmeta_easy] -# METHOD=0 => lfsr_file_ckmeta -# METHOD=1 => lfsr_file_close+open+ckmeta -# METHOD=2 => lfsr_file_close+open +# METHOD=0 => lfs3_file_ckmeta +# METHOD=1 => lfs3_file_close+open+ckmeta +# METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -986,44 +986,44 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1032,7 +1032,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1040,37 +1040,37 @@ code = ''' } clobbered:; - // find clobbered blocks with lfsr_file_ckmeta + // find clobbered blocks with lfs3_file_ckmeta if (METHOD == 0) { - lfsr_file_ckmeta(&lfs, &file) => LFS_ERR_CORRUPT; + lfs3_file_ckmeta(&lfs3, &file) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfsr_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ckmeta } else if (METHOD == 1) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; - lfsr_file_ckmeta(&lfs, &file) => LFS_ERR_CORRUPT; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; + lfs3_file_ckmeta(&lfs3, &file) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfsr_file_close+open + // find clobbered blocks with lfs3_file_close+open } else if (METHOD == 2) { - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDONLY | LFS_O_CKMETA) => LFS_ERR_CORRUPT; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDONLY | LFS3_O_CKMETA) => LFS3_ERR_CORRUPT; } else { assert(false); } if (METHOD != 2) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' [cases.test_ck_file_ckdata_easy] -# METHOD=0 => lfsr_file_ckdata -# METHOD=1 => lfsr_file_close+open+ckdata -# METHOD=2 => lfsr_file_close+open +# METHOD=0 => lfs3_file_ckdata +# METHOD=1 => lfs3_file_close+open+ckdata +# METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -1083,45 +1083,45 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1130,7 +1130,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1138,39 +1138,39 @@ code = ''' } clobbered:; - // find clobbered blocks with lfsr_file_ckmeta + // find clobbered blocks with lfs3_file_ckmeta if (METHOD == 0) { - lfsr_file_ckdata(&lfs, &file) => LFS_ERR_CORRUPT; + lfs3_file_ckdata(&lfs3, &file) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfsr_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ckmeta } else if (METHOD == 1) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; - lfsr_file_ckdata(&lfs, &file) => LFS_ERR_CORRUPT; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; + lfs3_file_ckdata(&lfs3, &file) => LFS3_ERR_CORRUPT; - // find clobbered blocks with lfsr_file_close+open + // find clobbered blocks with lfs3_file_close+open } else if (METHOD == 2) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDONLY | LFS_O_CKDATA) => LFS_ERR_CORRUPT; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDONLY | LFS3_O_CKDATA) => LFS3_ERR_CORRUPT; } else { assert(false); } if (METHOD != 2) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' # test some more interesting errors [cases.test_ck_file_ckmeta_hard] -# METHOD=0 => lfsr_file_ckmeta -# METHOD=1 => lfsr_file_close+open+ckmeta -# METHOD=2 => lfsr_file_close+open +# METHOD=0 => lfs3_file_ckmeta +# METHOD=1 => lfs3_file_close+open+ckmeta +# METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -1187,49 +1187,49 @@ defines.M = 100 fuzz = 'SEED' code = ''' uint32_t prng_ = SEED; - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - lfs_block_t badblock; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + lfs3_block_t badblock; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_BTREE) { // found an interesting block? if (k == i) { badblock = tinfo.block; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobber; } k += 1; @@ -1238,38 +1238,38 @@ code = ''' clobber:; // try flipping some bits - for (lfs_size_t j = 0; j < M; j++) { + for (lfs3_size_t j = 0; j < M; j++) { // choose a bit - lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); + lfs3_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfsr_file_ckmeta + // find clobbered blocks with lfs3_file_ckmeta if (METHOD == 0) { - int err = lfsr_file_ckmeta(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_ckmeta(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfsr_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ckmeta } else if (METHOD == 1) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; - int err = lfsr_file_ckmeta(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; + int err = lfs3_file_ckmeta(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfsr_file_close+open + // find clobbered blocks with lfs3_file_close+open } else if (METHOD == 2) { - lfsr_file_close(&lfs, &file) => 0; - int err = lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDONLY | LFS_O_CKMETA); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; + int err = lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDONLY | LFS3_O_CKMETA); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } @@ -1285,40 +1285,40 @@ code = ''' prng = 42; { uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &file) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; continue; detected:; // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // reopen our file if we ended up closed if (METHOD == 2) { - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR) => 0; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDWR) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } done:; ''' [cases.test_ck_file_ckdata_hard] -# METHOD=0 => lfsr_file_ckdata -# METHOD=1 => lfsr_file_close+open+ckdata -# METHOD=2 => lfsr_file_close+open +# METHOD=0 => lfs3_file_ckdata +# METHOD=1 => lfs3_file_close+open+ckdata +# METHOD=2 => lfs3_file_close+open defines.METHOD = [0, 1, 2] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -1335,50 +1335,50 @@ defines.M = 100 fuzz = 'SEED' code = ''' uint32_t prng_ = SEED; - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting file uint32_t prng = 42; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - lfs_block_t badblock; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + lfs3_block_t badblock; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { // found an interesting block? if (k == i) { badblock = tinfo.block; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobber; } k += 1; @@ -1387,38 +1387,38 @@ code = ''' clobber:; // try flipping some bits - for (lfs_size_t j = 0; j < M; j++) { + for (lfs3_size_t j = 0; j < M; j++) { // choose a bit - lfs_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); + lfs3_size_t badbit = TEST_PRNG(&prng_) % (BLOCK_SIZE*8); // flip printf("flipping 0x%x.%x+%x\n", badblock, badbit/8, badbit%8); - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; - // find clobbered blocks with lfsr_file_ckdata + // find clobbered blocks with lfs3_file_ckdata if (METHOD == 0) { - int err = lfsr_file_ckdata(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_ckdata(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfsr_file_close+open+ckmeta + // find clobbered blocks with lfs3_file_close+open+ckmeta } else if (METHOD == 1) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; - int err = lfsr_file_ckdata(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; + int err = lfs3_file_ckdata(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } - // find clobbered blocks with lfsr_file_close+open + // find clobbered blocks with lfs3_file_close+open } else if (METHOD == 2) { - lfsr_file_close(&lfs, &file) => 0; - int err = lfsr_file_open(&lfs, &file, "octopus", - LFS_O_RDONLY | LFS_O_CKDATA); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; + int err = lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_RDONLY | LFS3_O_CKDATA); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto detected; } @@ -1434,31 +1434,31 @@ code = ''' prng = 42; { uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &file) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; continue; detected:; // unflip our bit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // reopen our file if we ended up closed if (METHOD == 2) { - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDWR) => 0; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDWR) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } done:; ''' @@ -1471,54 +1471,54 @@ done:; [cases.test_ck_ckprogs_mroot] defines.BADBLOCK = [0, 1] defines.BADBIT = -1 -defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' +defines.BADBLOCK_BEHAVIOR = 'LFS3_EMUBD_BADBLOCK_PROGFLIP' # this should stay inlined defines.SIZE = 'BLOCK_SIZE/16' -ifdef = 'LFS_CKPROGS' +ifdef = 'LFS3_CKPROGS' code = ''' // test all bad bits in the mroot - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", - (lfs_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); + (lfs3_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad - lfs_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; + lfs3_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; // formatting the filesystem may already find the bit error - lfs_t lfs; - int err = lfsr_format(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_t lfs3; + int err = lfs3_format(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt; } - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; { // create a file - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, "physalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, "physalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -1527,107 +1527,107 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; } - lfsr_file_open(&lfs, &file, "physalia", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "physalia", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; corrupt:; // reset badbit - lfs_emubd_markgood(CFG, BADBLOCK) => 0; + lfs3_emubd_markgood(CFG, BADBLOCK) => 0; } ''' # test every single-bit error in a file's data block [cases.test_ck_ckprogs_data] defines.BADBIT = -1 -defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' +defines.BADBLOCK_BEHAVIOR = 'LFS3_EMUBD_BADBLOCK_PROGFLIP' # this should create a single block file defines.SIZE = 'BLOCK_SIZE' -ifdef = 'LFS_CKPROGS' +ifdef = 'LFS3_CKPROGS' code = ''' // first we need to figure out where the data block will actually // end up, fortunately our block randomization is intentionally // consistent // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKPROGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "physalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "physalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // find the data block - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t badblock; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t badblock; while (true) { - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - if (tinfo.btype == LFS_BTYPE_DATA) { + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + if (tinfo.btype == LFS3_BTYPE_DATA) { badblock = tinfo.block; break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // now test all bad bits in the data block - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad - lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; + lfs3_emubd_markbadbit(CFG, badblock, badbit) => 0; // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKPROGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "physalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "physalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - int err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -1636,109 +1636,109 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; } - lfsr_file_open(&lfs, &file, "physalia", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "physalia", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badbit - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' # test every single-bit error in a file's btree node [cases.test_ck_ckprogs_btree] defines.BADBIT = -1 -defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' +defines.BADBLOCK_BEHAVIOR = 'LFS3_EMUBD_BADBLOCK_PROGFLIP' # force the file to create a btree defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.FRAGMENT_SIZE = 'BLOCK_SIZE/8' defines.SIZE = '2*FRAGMENT_SIZE' -ifdef = 'LFS_CKPROGS' +ifdef = 'LFS3_CKPROGS' code = ''' // first we need to figure out where the btree block will actually // end up, fortunately our block randomization is intentionally // consistent // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKPROGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "physalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "physalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // find the btree block - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t badblock; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t badblock; while (true) { - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - if (tinfo.btype == LFS_BTYPE_BTREE) { + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + if (tinfo.btype == LFS3_BTYPE_BTREE) { badblock = tinfo.block; break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // now test all bad bits in the btree block - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad - lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; + lfs3_emubd_markbadbit(CFG, badblock, badbit) => 0; // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKPROGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKPROGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "physalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "physalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - int err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -1747,23 +1747,23 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; } - lfsr_file_open(&lfs, &file, "physalia", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "physalia", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badbit - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -1777,102 +1777,103 @@ defines.BADBIT = -1 defines.BADBLOCK_ = '(BADBLOCK+1) % 2' defines.BADBIT_ = -1 defines.M = 4000 -defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_PROGFLIP' +defines.BADBLOCK_BEHAVIOR = 'LFS3_EMUBD_BADBLOCK_PROGFLIP' # this should stay inlined defines.SIZE = 'BLOCK_SIZE/64' defines.N = 4 defines.FLUSH = [false, true] defines.SYNC = [false, true] defines.SEED = 42 -ifdef = 'LFS_CKPROGS' +ifdef = 'LFS3_CKPROGS' code = ''' // to avoid taking up too much testing time, assign bits // pseudorandomly uint32_t prng = SEED; - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? M : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) + lfs3_size_t badbit = (BADBIT == -1) ? TEST_PRNG(&prng) % (8*BLOCK_SIZE) : BADBIT; - lfs_size_t badbit_ = (BADBIT_ == -1) + lfs3_size_t badbit_ = (BADBIT_ == -1) ? TEST_PRNG(&prng) % (8*BLOCK_SIZE) : BADBIT_; printf("--- badblocks: 0x%x.%x + 0x%x.%x, " "badbits: 0x%x + 0x%x (0x%x+%x + 0x%x+%x) ---\n", - (lfs_off_t)BADBLOCK, badbit/8, - (lfs_off_t)BADBLOCK_, badbit_/8, + (lfs3_off_t)BADBLOCK, badbit/8, + (lfs3_off_t)BADBLOCK_, badbit_/8, badbit, badbit_, badbit/8, badbit%8, badbit_/8, badbit_%8); // mark our badbits as bad - lfs_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; - lfs_emubd_markbadbit(CFG, BADBLOCK_, badbit_) => 0; + lfs3_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; + lfs3_emubd_markbadbit(CFG, BADBLOCK_, badbit_) => 0; // keep track of open files so we clean up correctly - lfsr_file_t files[N]; + lfs3_file_t files[N]; bool open[N]; memset(open, 0, N*sizeof(bool)); // formatting the filesystem may already find the bit error - lfs_t lfs; - int err = lfsr_format(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_t lfs3; + int err = lfs3_format(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt; } - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; { // create some files // // don't use global prng here! if we do we lose reproducibility uint32_t wprng = 42+0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "physalia%03d", i); - err = lfsr_file_open(&lfs, &files[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); + err = lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); assert(!err - || err == LFS_ERR_CORRUPT - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_CORRUPT + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOSPC) { goto corrupt_open; } open[i] = true; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &files[i], wbuf, SIZE); + lfs3_ssize_t res = lfs3_file_write(&lfs3, &files[i], + wbuf, SIZE); assert(res == SIZE - || res == LFS_ERR_CORRUPT - || res == LFS_ERR_NOSPC); - if (res == LFS_ERR_CORRUPT || res == LFS_ERR_NOSPC) { + || res == LFS3_ERR_CORRUPT + || res == LFS3_ERR_NOSPC); + if (res == LFS3_ERR_CORRUPT || res == LFS3_ERR_NOSPC) { goto corrupt_open; } // flush? if (FLUSH) { - err = lfsr_file_flush(&lfs, &files[i]); + err = lfs3_file_flush(&lfs3, &files[i]); assert(!err - || err == LFS_ERR_CORRUPT - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_CORRUPT + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOSPC) { goto corrupt_open; } } // sync? if (SYNC) { - err = lfsr_file_sync(&lfs, &files[i]); + err = lfs3_file_sync(&lfs3, &files[i]); assert(!err - || err == LFS_ERR_CORRUPT - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_CORRUPT + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOSPC) { goto corrupt_open; } } @@ -1880,52 +1881,53 @@ code = ''' // rewrite for good measure wprng = 42+1; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_rewind(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_rewind(&lfs3, &files[i]) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &files[i], wbuf, SIZE); + lfs3_ssize_t res = lfs3_file_write(&lfs3, &files[i], + wbuf, SIZE); assert(res == SIZE - || res == LFS_ERR_CORRUPT - || res == LFS_ERR_NOSPC); - if (res == LFS_ERR_CORRUPT || res == LFS_ERR_NOSPC) { + || res == LFS3_ERR_CORRUPT + || res == LFS3_ERR_NOSPC); + if (res == LFS3_ERR_CORRUPT || res == LFS3_ERR_NOSPC) { goto corrupt_open; } // flush? if (FLUSH) { - err = lfsr_file_flush(&lfs, &files[i]); + err = lfs3_file_flush(&lfs3, &files[i]); assert(!err - || err == LFS_ERR_CORRUPT - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_CORRUPT + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOSPC) { goto corrupt_open; } } // sync? if (SYNC) { - err = lfsr_file_sync(&lfs, &files[i]); + err = lfs3_file_sync(&lfs3, &files[i]); assert(!err - || err == LFS_ERR_CORRUPT - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_CORRUPT + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOSPC) { goto corrupt_open; } } } // and close - for (lfs_size_t i = 0; i < N; i++) { - err = lfsr_file_close(&lfs, &files[i]); + for (lfs3_size_t i = 0; i < N; i++) { + err = lfs3_file_close(&lfs3, &files[i]); assert(!err - || err == LFS_ERR_CORRUPT - || err == LFS_ERR_NOSPC); + || err == LFS3_ERR_CORRUPT + || err == LFS3_ERR_NOSPC); open[i] = false; - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOSPC) { + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOSPC) { goto corrupt_open; } } @@ -1935,43 +1937,43 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKPROGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKPROGS, CFG) => 0; } wprng = 42+1; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "physalia%03d", i); - lfsr_file_open(&lfs, &files[i], name, LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &files[i], name, LFS3_O_RDONLY) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; } } } corrupt_open:; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { if (open[i]) { - lfsr_file_desync(&lfs, &files[i]) => 0; - lfsr_file_close(&lfs, &files[i]) => 0; + lfs3_file_desync(&lfs3, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; open[i] = false; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; corrupt:; // reset badbits - lfs_emubd_markgood(CFG, BADBLOCK) => 0; - lfs_emubd_markgood(CFG, BADBLOCK_) => 0; + lfs3_emubd_markgood(CFG, BADBLOCK) => 0; + lfs3_emubd_markgood(CFG, BADBLOCK_) => 0; } ''' @@ -1985,75 +1987,75 @@ defines.BADBLOCK = [0, 1] defines.BADBIT = -1 # this should stay inlined defines.SIZE = 'BLOCK_SIZE/16' -ifdef = 'LFS_CKFETCHES' +ifdef = 'LFS3_CKFETCHES' code = ''' // test all bad bits in the mroot - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", - (lfs_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); + (lfs3_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKFETCHES, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "stygiomedusa", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "stygiomedusa", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // flip our badbit - lfs_emubd_flipbit(CFG, BADBLOCK, badbit) => 0; + lfs3_emubd_flipbit(CFG, BADBLOCK, badbit) => 0; - int err = lfsr_mount(&lfs, - LFS_M_RDWR | LFS_M_CKFETCHES, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_mount(&lfs3, + LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt; } } // yes reads can fail here - int err = lfsr_file_open(&lfs, &file, - "stygiomedusa", LFS_O_RDONLY); + int err = lfs3_file_open(&lfs3, &file, + "stygiomedusa", LFS3_O_RDONLY); assert(!err // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with // ckfetches alone - || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; corrupt:; // reset badbit - lfs_emubd_markgood(CFG, BADBLOCK) => 0; + lfs3_emubd_markgood(CFG, BADBLOCK) => 0; } ''' @@ -2062,106 +2064,106 @@ code = ''' defines.BADBIT = -1 # this should create a single block file defines.SIZE = 'BLOCK_SIZE' -ifdef = 'LFS_CKFETCHES' +ifdef = 'LFS3_CKFETCHES' code = ''' // first we need to figure out where the data block will actually // end up, fortunately our block randomization is intentionally // consistent // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKFETCHES, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "stygiomedusa", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "stygiomedusa", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // find the data block - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t badblock; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t badblock; while (true) { - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - if (tinfo.btype == LFS_BTYPE_DATA) { + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + if (tinfo.btype == LFS3_BTYPE_DATA) { badblock = tinfo.block; break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // now test all bad bits in the data block - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKFETCHES, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "stygiomedusa", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "stygiomedusa", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // flip our badbit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; } // yes reads can fail here - int err = lfsr_file_open(&lfs, &file, - "stygiomedusa", LFS_O_RDONLY); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_open(&lfs3, &file, + "stygiomedusa", LFS3_O_RDONLY); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; - lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_read(&lfs3, &file, rbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badbit - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -2173,106 +2175,106 @@ defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.FRAGMENT_SIZE = 'BLOCK_SIZE/8' defines.SIZE = '2*FRAGMENT_SIZE' -ifdef = 'LFS_CKFETCHES' +ifdef = 'LFS3_CKFETCHES' code = ''' // first we need to figure out where the btree block will actually // end up, fortunately our block randomization is intentionally // consistent // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKFETCHES, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "stygiomedusa", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "stygiomedusa", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // find the btree block - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t badblock; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t badblock; while (true) { - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - if (tinfo.btype == LFS_BTYPE_BTREE) { + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + if (tinfo.btype == LFS3_BTYPE_BTREE) { badblock = tinfo.block; break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // now test all bad bits in the btree block - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKFETCHES, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKFETCHES, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "stygiomedusa", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "stygiomedusa", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // flip our badbit - lfs_emubd_flipbit(CFG, badblock, badbit) => 0; + lfs3_emubd_flipbit(CFG, badblock, badbit) => 0; // try to read our file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKFETCHES, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKFETCHES, CFG) => 0; } // yes reads can fail here - int err = lfsr_file_open(&lfs, &file, - "stygiomedusa", LFS_O_RDONLY); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_open(&lfs3, &file, + "stygiomedusa", LFS3_O_RDONLY); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; - lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_read(&lfs3, &file, rbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badbit - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -2310,15 +2312,15 @@ code = ''' defines.BADBLOCK = [0, 1] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGFLIP', - 'LFS_EMUBD_BADBLOCK_READFLIP', + 'LFS3_EMUBD_BADBLOCK_PROGFLIP', + 'LFS3_EMUBD_BADBLOCK_READFLIP', ] # this should stay inlined defines.SIZE = 'BLOCK_SIZE/16' -ifdef = 'LFS_CKMETAPARITY' +ifdef = 'LFS3_CKMETAPARITY' code = ''' // test all bad bits in the mroot - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; // we can't detect metastable tags, so limit read-flips // to our revision count + first tag i < ((BADBIT == -1) ? 8*6 : 1); @@ -2328,55 +2330,55 @@ code = ''' if (BADBIT == -1 && i == 8*4+6) { continue; } - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; // reset the bd prng every run for reproducibility - lfs_emubd_seed(CFG, 42); + lfs3_emubd_seed(CFG, 42); printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", - (lfs_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); + (lfs3_size_t)BADBLOCK, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad - lfs_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; + lfs3_emubd_markbadbit(CFG, BADBLOCK, badbit) => 0; // With metastability, basically any filesystem operation can - // return LFS_ERR_CORRUPT. This is ok, what we're really testing + // return LFS3_ERR_CORRUPT. This is ok, what we're really testing // for is no internal/external asserts failing. // format - lfs_t lfs; - int err = lfsr_format(&lfs, LFS_M_RDWR | LFS_M_CKMETAPARITY, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_t lfs3; + int err = lfs3_format(&lfs3, LFS3_M_RDWR | LFS3_M_CKMETAPARITY, CFG); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt; } - err = lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETAPARITY, CFG); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + err = lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKMETAPARITY, CFG); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt; } { // create a file - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, "tripedalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, "tripedalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - err = lfsr_file_close(&lfs, &file); - if (err == LFS_ERR_CORRUPT) { + err = lfs3_file_close(&lfs3, &file); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -2384,43 +2386,43 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - err = lfsr_mount(&lfs, - LFS_M_RDWR | LFS_M_CKMETAPARITY, CFG); - if (err == LFS_ERR_CORRUPT) { + lfs3_unmount(&lfs3) => 0; + err = lfs3_mount(&lfs3, + LFS3_M_RDWR | LFS3_M_CKMETAPARITY, CFG); + if (err == LFS3_ERR_CORRUPT) { goto corrupt; } } // yes reads can fail here - err = lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_RDONLY); + err = lfs3_file_open(&lfs3, &file, "tripedalia", LFS3_O_RDONLY); assert(!err - || err == LFS_ERR_CORRUPT + || err == LFS3_ERR_CORRUPT // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with // ckparity alone - || err == LFS_ERR_NOENT); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; - lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_read(&lfs3, &file, rbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; corrupt:; // reset badbit - lfs_emubd_markgood(CFG, BADBLOCK) => 0; + lfs3_emubd_markgood(CFG, BADBLOCK) => 0; } ''' @@ -2428,55 +2430,55 @@ code = ''' [cases.test_ck_ckparity_btree] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGFLIP', - 'LFS_EMUBD_BADBLOCK_READFLIP', + 'LFS3_EMUBD_BADBLOCK_PROGFLIP', + 'LFS3_EMUBD_BADBLOCK_READFLIP', ] # force the file to create a btree defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.FRAGMENT_SIZE = 'BLOCK_SIZE/8' defines.SIZE = '2*FRAGMENT_SIZE' -ifdef = 'LFS_CKMETAPARITY' +ifdef = 'LFS3_CKMETAPARITY' code = ''' // first we need to figure out where the btree block will actually // end up, fortunately our block randomization is intentionally // consistent // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKMETAPARITY, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETAPARITY, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKMETAPARITY, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKMETAPARITY, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "tripedalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "tripedalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // find the btree block - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t badblock; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t badblock; while (true) { - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - if (tinfo.btype == LFS_BTYPE_BTREE) { + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + if (tinfo.btype == LFS3_BTYPE_BTREE) { badblock = tinfo.block; break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // now test all bad bits in the btree block - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; // we can't detect metastable tags, so limit read-flips // to our revision count + first tag i < ((BADBIT == -1) ? 8*6 : 1); @@ -2486,43 +2488,43 @@ code = ''' if (BADBIT == -1 && i == 8*4+6) { continue; } - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; // reset the bd prng every run for reproducibility - lfs_emubd_seed(CFG, 42); + lfs3_emubd_seed(CFG, 42); printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad - lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; + lfs3_emubd_markbadbit(CFG, badblock, badbit) => 0; // With metastability, basically any filesystem operation can - // return LFS_ERR_CORRUPT. This is ok, what we're really testing + // return LFS3_ERR_CORRUPT. This is ok, what we're really testing // for is no internal/external asserts failing. // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKMETAPARITY, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETAPARITY, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKMETAPARITY, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKMETAPARITY, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "tripedalia", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "tripedalia", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - int err = lfsr_file_close(&lfs, &file); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_close(&lfs3, &file); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -2530,38 +2532,40 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETAPARITY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | LFS3_M_CKMETAPARITY, + CFG) => 0; } // yes reads can fail here - err = lfsr_file_open(&lfs, &file, "tripedalia", LFS_O_RDONLY); + err = lfs3_file_open(&lfs3, &file, "tripedalia", LFS3_O_RDONLY); assert(!err - || err == LFS_ERR_CORRUPT + || err == LFS3_ERR_CORRUPT // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with // ckparity alone - || err == LFS_ERR_NOENT); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; - lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_read(&lfs3, &file, rbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badbit - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -2573,91 +2577,91 @@ code = ''' [cases.test_ck_ckdatacksums_data] defines.BADBIT = -1 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGFLIP', - 'LFS_EMUBD_BADBLOCK_READFLIP', + 'LFS3_EMUBD_BADBLOCK_PROGFLIP', + 'LFS3_EMUBD_BADBLOCK_READFLIP', ] # this should create a single block file defines.SIZE = 'BLOCK_SIZE' -ifdef = 'LFS_CKDATACKSUMREADS' +ifdef = 'LFS3_CKDATACKSUMREADS' code = ''' // first we need to figure out where the data block will actually // end up, fortunately our block randomization is intentionally // consistent // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKDATACKSUMREADS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATACKSUMREADS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKDATACKSUMREADS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKDATACKSUMREADS, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "bathykorus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "bathykorus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // find the data block - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t badblock; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t badblock; while (true) { - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - if (tinfo.btype == LFS_BTYPE_DATA) { + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + if (tinfo.btype == LFS3_BTYPE_DATA) { badblock = tinfo.block; break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // now test all bad bits in the data block - for (lfs_size_t i = 0; + for (lfs3_size_t i = 0; i < ((BADBIT == -1) ? 8*BLOCK_SIZE : 1); i++) { - lfs_size_t badbit = (BADBIT == -1) ? i : BADBIT; + lfs3_size_t badbit = (BADBIT == -1) ? i : BADBIT; // reset the bd prng every run for reproducibility - lfs_emubd_seed(CFG, 42); + lfs3_emubd_seed(CFG, 42); printf("--- badblock: 0x%x.%x, badbit: 0x%x (0x%x+%x) ---\n", badblock, badbit/8, badbit, badbit/8, badbit%8); // mark our badbit as bad - lfs_emubd_markbadbit(CFG, badblock, badbit) => 0; + lfs3_emubd_markbadbit(CFG, badblock, badbit) => 0; // With metastability, basically any filesystem operation can - // return LFS_ERR_CORRUPT. This is ok, what we're really testing + // return LFS3_ERR_CORRUPT. This is ok, what we're really testing // for is no internal/external asserts failing. // format - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | LFS_F_CKDATACKSUMREADS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATACKSUMREADS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | LFS3_F_CKDATACKSUMREADS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKDATACKSUMREADS, CFG) => 0; { // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "bathykorus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "bathykorus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 42; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfs_ssize_t res = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - int err = lfsr_file_close(&lfs, &file); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_file_close(&lfs3, &file); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -2665,40 +2669,40 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR | LFS_M_CKDATACKSUMREADS, + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | LFS3_M_CKDATACKSUMREADS, CFG) => 0; } // yes reads can fail here - err = lfsr_file_open(&lfs, &file, "bathykorus", LFS_O_RDONLY); + err = lfs3_file_open(&lfs3, &file, "bathykorus", LFS3_O_RDONLY); assert(!err - || err == LFS_ERR_CORRUPT + || err == LFS3_ERR_CORRUPT // bit errors can also cause our fs state to "rollback", // which is not great but we can't solve this with ckreads // alone - || err == LFS_ERR_NOENT); - if (err == LFS_ERR_CORRUPT || err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_CORRUPT || err == LFS3_ERR_NOENT) { goto corrupt_mounted; } uint8_t rbuf[SIZE]; - lfs_ssize_t res = lfsr_file_read(&lfs, &file, rbuf, SIZE); - assert(res == SIZE || res == LFS_ERR_CORRUPT); - if (res == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t res = lfs3_file_read(&lfs3, &file, rbuf, SIZE); + assert(res == SIZE || res == LFS3_ERR_CORRUPT); + if (res == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // reset badbit - lfs_emubd_markgood(CFG, badblock) => 0; + lfs3_emubd_markgood(CFG, badblock) => 0; } ''' @@ -2708,7 +2712,7 @@ code = ''' ## High-level error spam tests # # we basically just throw errors at filesystem operations until they -# error with either LFS_ERR_CORRUPT or LFS_ERR_NOSPC +# error with either LFS3_ERR_CORRUPT or LFS3_ERR_NOSPC # # TODO revisit these when ckredund is implemented, ckredund should # finally close the ckread hole @@ -2729,8 +2733,8 @@ defines.PROTECTED_MROOTANCHOR = [false, true] defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) - ? LFS_EMUBD_BADBLOCK_PROGFLIP - : LFS_EMUBD_BADBLOCK_MANUAL + ? LFS3_EMUBD_BADBLOCK_PROGFLIP + : LFS3_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' @@ -2743,16 +2747,16 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; - lfs_emubd_seed(CFG, TEST_PRNG(&prng)); + lfs3_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // @@ -2762,43 +2766,43 @@ code = ''' TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test fuzz with dirs - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; // keep adding errors until we either run out of blocks or detect // corruption - lfs_size_t i = 0; + lfs3_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { - lfs_block_t badblock = badblocks[i/PERIOD]; + lfs3_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different @@ -2806,51 +2810,51 @@ code = ''' // bit differently // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks - if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { - lfs_emubd_flip(CFG) => 0; + if (BADBLOCK_BEHAVIOR == LFS3_EMUBD_BADBLOCK_MANUAL) { + lfs3_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { - int err = lfsr_fs_ckdata(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckdata(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfsr_fs_ckmeta(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckmeta(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto corrupt_mounted; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } } @@ -2861,9 +2865,9 @@ code = ''' if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2871,7 +2875,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -2882,54 +2886,54 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -2941,9 +2945,9 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } } @@ -2952,67 +2956,67 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) | ((CKFETCHES) - ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) + ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS( - LFS_M_CKDATACKSUMREADS, + ? LFS3_IFDEF_CKDATACKSUMREADS( + LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // clean up sim free(sim); @@ -3036,8 +3040,8 @@ defines.PROTECTED_MROOTANCHOR = [false, true] defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) - ? LFS_EMUBD_BADBLOCK_PROGFLIP - : LFS_EMUBD_BADBLOCK_MANUAL + ? LFS3_EMUBD_BADBLOCK_PROGFLIP + : LFS3_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' @@ -3059,17 +3063,17 @@ defines.SIZE = [ defines.SEED = 'range(10)' fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; - lfs_emubd_seed(CFG, TEST_PRNG(&prng)); + lfs3_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // @@ -3079,44 +3083,44 @@ code = ''' TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test fuzz with files - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; // keep adding errors until we either run out of blocks or detect // corruption - lfs_size_t i = 0; + lfs3_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { - lfs_block_t badblock = badblocks[i/PERIOD]; + lfs3_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different @@ -3124,51 +3128,51 @@ code = ''' // bit differently // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks - if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { - lfs_emubd_flip(CFG) => 0; + if (BADBLOCK_BEHAVIOR == LFS3_EMUBD_BADBLOCK_MANUAL) { + lfs3_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { - int err = lfsr_fs_ckdata(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckdata(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfsr_fs_ckmeta(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckmeta(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto corrupt_mounted; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } } @@ -3180,12 +3184,12 @@ code = ''' // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -3194,7 +3198,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -3209,37 +3213,37 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - int err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); + lfs3_file_t file; + int err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); if (err) { goto corrupt_mounted; } - lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -3247,9 +3251,9 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } @@ -3257,19 +3261,19 @@ code = ''' } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -3282,7 +3286,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -3290,7 +3294,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -3305,9 +3309,9 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } } @@ -3316,87 +3320,87 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) | ((CKFETCHES) - ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) + ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS( - LFS_M_CKDATACKSUMREADS, + ? LFS3_IFDEF_CKDATACKSUMREADS( + LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfs_ssize_t d = lfsr_file_read(&lfs, &file, rbuf, SIZE); + lfs3_ssize_t d = lfs3_file_read(&lfs3, &file, rbuf, SIZE); assert(d == SIZE - || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); + if (d == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // clean up sim free(sim); @@ -3421,8 +3425,8 @@ defines.PROTECTED_MROOTANCHOR = [false, true] defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) - ? LFS_EMUBD_BADBLOCK_PROGFLIP - : LFS_EMUBD_BADBLOCK_MANUAL + ? LFS3_EMUBD_BADBLOCK_PROGFLIP + : LFS3_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' @@ -3451,10 +3455,10 @@ defines.SYNC = [false, true] defines.SEED = 'range(10)' fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', 'CHUNK <= SIZE', # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', @@ -3463,7 +3467,7 @@ code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; - lfs_emubd_seed(CFG, TEST_PRNG(&prng)); + lfs3_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // @@ -3473,66 +3477,66 @@ code = ''' TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test with complex file writes - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // keep adding errors until we either run out of blocks or detect // corruption - lfs_size_t i = 0; + lfs3_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { - lfs_block_t badblock = badblocks[i/PERIOD]; + lfs3_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different @@ -3540,167 +3544,167 @@ code = ''' // bit differently // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks - if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { - lfs_emubd_flip(CFG) => 0; + if (BADBLOCK_BEHAVIOR == LFS3_EMUBD_BADBLOCK_MANUAL) { + lfs3_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { - int err = lfsr_fs_ckdata(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckdata(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_open; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfsr_fs_ckmeta(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckmeta(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_open; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto corrupt_open; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } } // keep testing... // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( TEST_PRNG(&prng) % CHUNK, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } if (chunk != 0) { - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); } // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfs_ssize_t d = lfsr_file_write(&lfs, &file, &sim[off], chunk); - assert(d == (lfs_ssize_t)chunk - || d == LFS_ERR_NOSPC - || (d == LFS_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_NOSPC || d == LFS_ERR_CORRUPT) { + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, &sim[off], chunk); + assert(d == (lfs3_ssize_t)chunk + || d == LFS3_ERR_NOSPC + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); + if (d == LFS3_ERR_NOSPC || d == LFS3_ERR_CORRUPT) { goto corrupt_open; } // sync? if (SYNC) { - int err = lfsr_file_sync(&lfs, &file); + int err = lfs3_file_sync(&lfs3, &file); assert(!err - || err == LFS_ERR_NOSPC - || (err == LFS_ERR_CORRUPT + || err == LFS3_ERR_NOSPC + || (err == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_NOSPC || err == LFS3_ERR_CORRUPT) { goto corrupt_open; } } } - int err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR | ((CKPROGS) - ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) + ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) | ((CKFETCHES) - ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) + ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS( - LFS_M_CKDATACKSUMREADS, + ? LFS3_IFDEF_CKDATACKSUMREADS( + LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } goto corrupt_mounted; corrupt_open:; - lfsr_file_desync(&lfs, &file) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_desync(&lfs3, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; corrupt_mounted:; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // how many errors did we survive? printf("survived %d block errors! (%d)\n", (int)(i/PERIOD), i); @@ -3722,8 +3726,8 @@ defines.PROTECTED_MROOTANCHOR = [false, true] defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) - ? LFS_EMUBD_BADBLOCK_PROGFLIP - : LFS_EMUBD_BADBLOCK_MANUAL + ? LFS3_EMUBD_BADBLOCK_PROGFLIP + : LFS3_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' @@ -3747,17 +3751,17 @@ defines.SIZE = [ defines.SEED = 'range(10)' fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; - lfs_emubd_seed(CFG, TEST_PRNG(&prng)); + lfs3_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // @@ -3767,55 +3771,55 @@ code = ''' TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test with uncreats, zombies, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; // keep adding errors until we either run out of blocks or detect // corruption - lfs_size_t i = 0; + lfs3_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { - lfs_block_t badblock = badblocks[i/PERIOD]; + lfs3_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different @@ -3823,51 +3827,51 @@ code = ''' // bit differently // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks - if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { - lfs_emubd_flip(CFG) => 0; + if (BADBLOCK_BEHAVIOR == LFS3_EMUBD_BADBLOCK_MANUAL) { + lfs3_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { - int err = lfsr_fs_ckdata(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckdata(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfsr_fs_ckmeta(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckmeta(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto corrupt_mounted; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } } @@ -3883,13 +3887,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -3903,16 +3907,16 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { free(sim_files[j]); goto corrupt_mounted; } @@ -3921,14 +3925,14 @@ code = ''' if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); goto corrupt_mounted; } @@ -3942,7 +3946,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -3951,7 +3955,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3971,33 +3975,33 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); assert(d == SIZE - || d == LFS_ERR_NOSPC - || (d == LFS_ERR_CORRUPT + || d == LFS3_ERR_NOSPC + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_NOSPC || d == LFS_ERR_CORRUPT) { + if (d == LFS3_ERR_NOSPC || d == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } - int err = lfsr_file_sync(&lfs, &sim_files[j]->file); + int err = lfs3_file_sync(&lfs3, &sim_files[j]->file); assert(!err - || err == LFS_ERR_NOSPC - || (err == LFS_ERR_CORRUPT + || err == LFS3_ERR_NOSPC + || (err == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (err == LFS_ERR_NOSPC || LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_NOSPC || LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -4005,7 +4009,7 @@ code = ''' sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -4016,7 +4020,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -4032,8 +4036,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -4041,10 +4045,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -4055,7 +4059,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -4063,10 +4067,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -4084,21 +4088,21 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -4106,7 +4110,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -4119,9 +4123,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -4130,20 +4134,20 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -4159,7 +4163,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -4169,7 +4173,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -4183,7 +4187,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -4197,109 +4201,109 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfs_ssize_t d = lfsr_file_read(&lfs, &file, rbuf, SIZE); + lfs3_ssize_t d = lfs3_file_read(&lfs3, &file, rbuf, SIZE); assert(d == SIZE - || (d == LFS_ERR_CORRUPT + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + if (d == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfs_ssize_t d = lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE); + lfs3_ssize_t d = lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE); assert(d == SIZE - || (d == LFS_ERR_CORRUPT + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_CORRUPT) { + if (d == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); } corrupt_mounted:; - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // how many errors did we survive? printf("survived %d block errors!\n", (int)(i/PERIOD)); @@ -4321,8 +4325,8 @@ defines.PROTECTED_MROOTANCHOR = [false, true] defines.ERASE_VALUE = -1 defines.BADBLOCK_BEHAVIOR = ''' (METHOD == 0) - ? LFS_EMUBD_BADBLOCK_PROGFLIP - : LFS_EMUBD_BADBLOCK_MANUAL + ? LFS3_EMUBD_BADBLOCK_PROGFLIP + : LFS3_EMUBD_BADBLOCK_MANUAL ''' defines.CKMETA = 'METHOD == 2 || METHOD == 3' defines.CKDATA = 'METHOD == 1' @@ -4346,17 +4350,17 @@ defines.SIZE = [ defines.SEED = 'range(10)' fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' // seed our block device with our seed so we have different error // bit patterns uint32_t prng = SEED; - lfs_emubd_seed(CFG, TEST_PRNG(&prng)); + lfs3_emubd_seed(CFG, TEST_PRNG(&prng)); // create a permutation of blocks to test against // @@ -4366,56 +4370,56 @@ code = ''' TEST_PERMUTATION(TEST_PRNG(&prng), badblocks, BLOCK_COUNT); // test with uncreats, zombies, dirs, etc - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, -1) : 0), CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, -1) : 0), CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; // keep adding errors until we either run out of blocks or detect // corruption - lfs_size_t i = 0; + lfs3_size_t i = 0; for (; i < PERIOD*BLOCK_COUNT; i++) { // add an error? if (i % PERIOD == 0 // protected mrootanchor? (just makes things more interesting) && !(PROTECTED_MROOTANCHOR && badblocks[i/PERIOD] < 2)) { - lfs_block_t badblock = badblocks[i/PERIOD]; + lfs3_block_t badblock = badblocks[i/PERIOD]; printf("badblock: 0x%x\n", badblock); // our different error-detection methods detect different @@ -4423,51 +4427,51 @@ code = ''' // bit differently // mark our badblock as bad - lfs_emubd_markbad(CFG, badblock) => 0; + lfs3_emubd_markbad(CFG, badblock) => 0; // manually flipping? flip all badbits in badblocks - if (BADBLOCK_BEHAVIOR == LFS_EMUBD_BADBLOCK_MANUAL) { - lfs_emubd_flip(CFG) => 0; + if (BADBLOCK_BEHAVIOR == LFS3_EMUBD_BADBLOCK_MANUAL) { + lfs3_emubd_flip(CFG) => 0; } // run ckdata? if (CKDATA) { - int err = lfsr_fs_ckdata(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckdata(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta? } else if (CKMETA && !MTREEONLY) { - int err = lfsr_fs_ckmeta(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + int err = lfs3_fs_ckmeta(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } // run ckmeta mtreeonly? } else if (CKMETA && MTREEONLY) { // need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); assert(!err - || err == LFS_ERR_NOENT - || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_NOENT) { + || err == LFS3_ERR_NOENT + || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_NOENT) { break; } - if (err == LFS_ERR_CORRUPT) { - lfsr_traversal_close(&lfs, &t) => 0; + if (err == LFS3_ERR_CORRUPT) { + lfs3_traversal_close(&lfs3, &t) => 0; goto corrupt_mounted; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } } @@ -4483,13 +4487,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -4506,16 +4510,16 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { free(sim_files[j]); goto corrupt_mounted; } @@ -4524,14 +4528,14 @@ code = ''' if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); goto corrupt_mounted; } @@ -4545,7 +4549,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -4554,7 +4558,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -4577,33 +4581,33 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); assert(d == SIZE - || d == LFS_ERR_NOSPC - || (d == LFS_ERR_CORRUPT + || d == LFS3_ERR_NOSPC + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_NOSPC || d == LFS_ERR_CORRUPT) { + if (d == LFS3_ERR_NOSPC || d == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } - int err = lfsr_file_sync(&lfs, &sim_files[j]->file); + int err = lfs3_file_sync(&lfs3, &sim_files[j]->file); assert(!err - || err == LFS_ERR_NOSPC - || (err == LFS_ERR_CORRUPT + || err == LFS3_ERR_NOSPC + || (err == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_NOSPC || err == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } @@ -4611,7 +4615,7 @@ code = ''' sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -4622,7 +4626,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -4638,19 +4642,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -4661,7 +4665,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -4669,10 +4673,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -4692,21 +4696,21 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -4716,7 +4720,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -4729,14 +4733,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -4754,20 +4758,20 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -4786,7 +4790,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -4798,7 +4802,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -4815,7 +4819,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -4829,9 +4833,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -4844,18 +4848,18 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto corrupt_mounted; } // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -4871,7 +4875,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -4880,125 +4884,125 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfs_ssize_t d = lfsr_file_read(&lfs, &file, rbuf, SIZE); + lfs3_ssize_t d = lfs3_file_read(&lfs3, &file, rbuf, SIZE); assert(d == SIZE - || (d == LFS_ERR_CORRUPT + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_CORRUPT) { - lfsr_file_close(&lfs, &file) => 0; + if (d == LFS3_ERR_CORRUPT) { + lfs3_file_close(&lfs3, &file) => 0; goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfs_ssize_t d = lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE); + lfs3_ssize_t d = lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE); assert(d == SIZE - || (d == LFS_ERR_CORRUPT + || (d == LFS3_ERR_CORRUPT && (METHOD == 2 || METHOD == 3))); - if (d == LFS_ERR_CORRUPT) { + if (d == LFS3_ERR_CORRUPT) { goto corrupt_mounted; } assert(memcmp(rbuf, wbuf, SIZE) == 0); } corrupt_mounted:; - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // how many errors did we survive? printf("survived %d block errors!\n", (int)(i/PERIOD)); diff --git a/tests/test_compat.toml b/tests/test_compat.toml index adb0f39e..992ffa41 100644 --- a/tests/test_compat.toml +++ b/tests/test_compat.toml @@ -9,15 +9,15 @@ after = [ # Note, these tests are a bit special. They can run as-is to test various # compatbility corner-cases, but if you link a previous version of littlefs -# as "lfsp" and define LFSP, they will also test migrating from lfsp -> lfs. +# as "lfsp" and define LFSP, they will also test migrating from lfsp -> lfs3. # -# If LFSP is not defined, these tests will alias lfsp = lfs so things will +# If LFSP is not defined, these tests will alias lfsp = lfs3 so things will # still compile and run, but the value of many of these tests is to test # against a previous version linked in with the help of # scripts/changeprefix.py # # Though we are also limited by API changes... so by default these tests -# won't run if LFS_VERSION changes. This can be bypassed with the test +# won't run if LFS3_VERSION changes. This can be bypassed with the test # runner's -a/--all flag. # @@ -30,40 +30,40 @@ code = ''' #define STRINGIZE_(x) #x #include STRINGIZE(LFSP) #else -#define LFSP_VERSION LFS_VERSION -#define LFSP_VERSION_MAJOR LFS_VERSION_MAJOR -#define LFSP_VERSION_MINOR LFS_VERSION_MINOR -#define LFSP_DISK_VERSION LFS_DISK_VERSION -#define LFSP_DISK_VERSION_MAJOR LFS_DISK_VERSION_MAJOR -#define LFSP_DISK_VERSION_MINOR LFS_DISK_VERSION_MINOR -#define lfsp_t lfs_t -#define lfsp_config lfs_config -#define LFSP_ERR_NOENT LFS_ERR_NOENT -#define lfsp_format lfsr_format -#define LFSP_M_RDWR LFS_M_RDWR -#define lfsp_mount lfsr_mount -#define lfsp_unmount lfsr_unmount -#define lfsp_fsinfo lfs_fsinfo -#define lfsp_fs_stat lfsr_fs_stat -#define lfsp_dir_t lfsr_dir_t -#define lfsp_info lfs_info -#define LFSP_TYPE_REG LFS_TYPE_REG -#define LFSP_TYPE_DIR LFS_TYPE_DIR -#define lfsp_mkdir lfsr_mkdir -#define lfsp_dir_open lfsr_dir_open -#define lfsp_dir_read lfsr_dir_read -#define lfsp_dir_close lfsr_dir_close -#define lfsp_file_t lfsr_file_t -#define LFSP_O_RDONLY LFS_O_RDONLY -#define LFSP_O_WRONLY LFS_O_WRONLY -#define LFSP_O_CREAT LFS_O_CREAT -#define LFSP_O_EXCL LFS_O_EXCL -#define LFSP_SEEK_SET LFS_SEEK_SET -#define lfsp_file_open lfsr_file_open -#define lfsp_file_write lfsr_file_write -#define lfsp_file_read lfsr_file_read -#define lfsp_file_seek lfsr_file_seek -#define lfsp_file_close lfsr_file_close +#define LFSP_VERSION LFS3_VERSION +#define LFSP_VERSION_MAJOR LFS3_VERSION_MAJOR +#define LFSP_VERSION_MINOR LFS3_VERSION_MINOR +#define LFSP_DISK_VERSION LFS3_DISK_VERSION +#define LFSP_DISK_VERSION_MAJOR LFS3_DISK_VERSION_MAJOR +#define LFSP_DISK_VERSION_MINOR LFS3_DISK_VERSION_MINOR +#define lfsp_t lfs3_t +#define lfsp_config lfs3_config +#define LFSP_ERR_NOENT LFS3_ERR_NOENT +#define lfsp_format lfs3_format +#define LFSP_M_RDWR LFS3_M_RDWR +#define lfsp_mount lfs3_mount +#define lfsp_unmount lfs3_unmount +#define lfsp_fsinfo lfs3_fsinfo +#define lfsp_fs_stat lfs3_fs_stat +#define lfsp_dir_t lfs3_dir_t +#define lfsp_info lfs3_info +#define LFSP_TYPE_REG LFS3_TYPE_REG +#define LFSP_TYPE_DIR LFS3_TYPE_DIR +#define lfsp_mkdir lfs3_mkdir +#define lfsp_dir_open lfs3_dir_open +#define lfsp_dir_read lfs3_dir_read +#define lfsp_dir_close lfs3_dir_close +#define lfsp_file_t lfs3_file_t +#define LFSP_O_RDONLY LFS3_O_RDONLY +#define LFSP_O_WRONLY LFS3_O_WRONLY +#define LFSP_O_CREAT LFS3_O_CREAT +#define LFSP_O_EXCL LFS3_O_EXCL +#define LFSP_SEEK_SET LFS3_SEEK_SET +#define lfsp_file_open lfs3_file_open +#define lfsp_file_write lfs3_file_write +#define lfsp_file_read lfs3_file_read +#define lfsp_file_seek lfs3_file_seek +#define lfsp_file_close lfs3_file_close #endif ''' @@ -73,16 +73,16 @@ code = ''' # test we can mount in a new version [cases.test_compat_forward_mount] if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; // confirm the previous mount works lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; @@ -91,29 +91,29 @@ code = ''' ////// // now mount with new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can read dirs in a new version [cases.test_compat_forward_read_dirs] defines.COUNT = 5 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; // write COUNT dirs lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); lfsp_mkdir(&lfsp, name) => 0; @@ -123,35 +123,35 @@ code = ''' ////// // now mount with new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // can we list the directories? - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can read files in a new version @@ -160,29 +160,29 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 4 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; // write COUNT files lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_file_t file; char name[8]; sprintf(name, "file%03d", i); lfsp_file_open(&lfsp, &file, name, LFSP_O_WRONLY | LFSP_O_CREAT | LFSP_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } @@ -195,53 +195,53 @@ code = ''' ////// // now mount with new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // can we list the files? - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; char name[8]; sprintf(name, "file%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_file_t file; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_file_t file; char name[8]; sprintf(name, "file%03d", i); - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - lfsr_file_read(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can read files in dirs in a new version @@ -250,21 +250,21 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 4 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; // write COUNT files+dirs lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[16]; sprintf(name, "dir%03d", i); lfsp_mkdir(&lfsp, name) => 0; @@ -273,9 +273,9 @@ code = ''' sprintf(name, "dir%03d/file%03d", i, i); lfsp_file_open(&lfsp, &file, name, LFSP_O_WRONLY | LFSP_O_CREAT | LFSP_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } @@ -288,99 +288,99 @@ code = ''' ////// // now mount with new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // can we list the directories? - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // can we list the files? - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; sprintf(name, "file%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_file_t file; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_file_t file; char name[16]; sprintf(name, "dir%03d/file%03d", i, i); - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - lfsr_file_read(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can write dirs in a new version [cases.test_compat_forward_write_dirs] defines.COUNT = 10 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; // write COUNT/2 dirs lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; - for (lfs_size_t i = 0; i < COUNT/2; i++) { + for (lfs3_size_t i = 0; i < COUNT/2; i++) { char name[8]; sprintf(name, "dir%03d", i); lfsp_mkdir(&lfsp, name) => 0; @@ -390,42 +390,42 @@ code = ''' ////// // now mount with new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // write another COUNT/2 dirs - for (lfs_size_t i = COUNT/2; i < COUNT; i++) { + for (lfs3_size_t i = COUNT/2; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // can we list the directories? - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can write files in a new version @@ -434,30 +434,30 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 2 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; // write half COUNT files lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { // write half lfsp_file_t file; char name[8]; sprintf(name, "file%03d", i); lfsp_file_open(&lfsp, &file, name, LFSP_O_WRONLY | LFSP_O_CREAT | LFSP_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE/2; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE/2; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } @@ -466,7 +466,7 @@ code = ''' lfsp_file_close(&lfsp, &file) => 0; // skip the other half but keep our prng reproducible - for (lfs_size_t j = SIZE/2; j < SIZE; j++) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j++) { TEST_PRNG(&prng); } } @@ -475,79 +475,79 @@ code = ''' ////// // now mount with new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // write half COUNT files prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { // skip half but keep our prng reproducible - for (lfs_size_t j = 0; j < SIZE/2; j++) { + for (lfs3_size_t j = 0; j < SIZE/2; j++) { TEST_PRNG(&prng); } // write the other half - lfsr_file_t file; + lfs3_file_t file; char name[8]; sprintf(name, "file%03d", i); - lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY) => 0; - lfsr_file_seek(&lfs, &file, SIZE/2, LFS_SEEK_SET) => SIZE/2; + lfs3_file_open(&lfs3, &file, name, LFS3_O_WRONLY) => 0; + lfs3_file_seek(&lfs3, &file, SIZE/2, LFS3_SEEK_SET) => SIZE/2; - for (lfs_size_t j = SIZE/2; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } - lfsr_file_write(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, chunk, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // can we list the files? - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; char name[8]; sprintf(name, "file%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_file_t file; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_file_t file; char name[8]; sprintf(name, "file%03d", i); - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - lfsr_file_read(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can write files in dirs in a new version @@ -556,23 +556,23 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 2 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION_MAJOR == LFSP_DISK_VERSION_MAJOR', ] code = ''' // create the previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; - lfsr_format(&lfsp, LFS_F_RDWR, &cfgp) => 0; + lfs3_format(&lfsp, LFS3_F_RDWR, &cfgp) => 0; ////// // now mount with new version lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[16]; sprintf(name, "dir%03d", i); lfsp_mkdir(&lfsp, name) => 0; @@ -582,9 +582,9 @@ code = ''' sprintf(name, "dir%03d/file%03d", i, i); lfsp_file_open(&lfsp, &file, name, LFSP_O_WRONLY | LFSP_O_CREAT | LFSP_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE/2; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE/2; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } @@ -593,7 +593,7 @@ code = ''' lfsp_file_close(&lfsp, &file) => 0; // skip the other half but keep our prng reproducible - for (lfs_size_t j = SIZE/2; j < SIZE; j++) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j++) { TEST_PRNG(&prng); } } @@ -601,105 +601,105 @@ code = ''' // mount the new version - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // write half COUNT files prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { // skip half but keep our prng reproducible - for (lfs_size_t j = 0; j < SIZE/2; j++) { + for (lfs3_size_t j = 0; j < SIZE/2; j++) { TEST_PRNG(&prng); } // write the other half - lfsr_file_t file; + lfs3_file_t file; char name[16]; sprintf(name, "dir%03d/file%03d", i, i); - lfsr_file_open(&lfs, &file, name, LFS_O_WRONLY) => 0; - lfsr_file_seek(&lfs, &file, SIZE/2, LFS_SEEK_SET) => SIZE/2; + lfs3_file_open(&lfs3, &file, name, LFS3_O_WRONLY) => 0; + lfs3_file_seek(&lfs3, &file, SIZE/2, LFS3_SEEK_SET) => SIZE/2; - for (lfs_size_t j = SIZE/2; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } - lfsr_file_write(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, chunk, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // can we list the directories? - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // can we list the files? - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; sprintf(name, "file%03d", i); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_file_t file; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_file_t file; char name[16]; sprintf(name, "dir%03d/file%03d", i, i); - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - lfsr_file_read(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -709,23 +709,23 @@ code = ''' # test we can mount in an old version [cases.test_compat_backward_mount] if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the new version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // confirm the new mount works - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; @@ -737,28 +737,28 @@ code = ''' [cases.test_compat_backward_read_dirs] defines.COUNT = 5 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the new version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // write COUNT dirs - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - for (lfs_size_t i = 0; i < COUNT; i++) { + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; @@ -776,7 +776,7 @@ code = ''' assert(info.type == LFSP_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_dir_read(&lfsp, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); @@ -797,40 +797,40 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 4 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the new version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // write COUNT files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { - lfsr_file_t file; + for (lfs3_size_t i = 0; i < COUNT; i++) { + lfs3_file_t file; char name[8]; sprintf(name, "file%03d", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } - lfsr_file_write(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, chunk, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; @@ -848,7 +848,7 @@ code = ''' assert(info.type == LFSP_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_dir_read(&lfsp, &dir, &info) => 0; char name[8]; sprintf(name, "file%03d", i); @@ -862,16 +862,16 @@ code = ''' // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_file_t file; char name[8]; sprintf(name, "file%03d", i); lfsp_file_open(&lfsp, &file, name, LFSP_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; lfsp_file_read(&lfsp, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } @@ -887,43 +887,43 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 4 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the new version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // write COUNT files+dirs - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[16]; sprintf(name, "dir%03d", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; - lfsr_file_t file; + lfs3_file_t file; sprintf(name, "dir%03d/file%03d", i, i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } - lfsr_file_write(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, chunk, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; @@ -941,7 +941,7 @@ code = ''' assert(info.type == LFSP_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_dir_read(&lfsp, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); @@ -954,7 +954,7 @@ code = ''' lfsp_dir_close(&lfsp, &dir) => 0; // can we list the files? - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); lfsp_dir_t dir; @@ -981,16 +981,16 @@ code = ''' // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_file_t file; char name[16]; sprintf(name, "dir%03d/file%03d", i, i); lfsp_file_open(&lfsp, &file, name, LFSP_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; lfsp_file_read(&lfsp, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } @@ -1004,34 +1004,34 @@ code = ''' [cases.test_compat_backward_write_dirs] defines.COUNT = 10 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the new version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // write COUNT/2 dirs - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - for (lfs_size_t i = 0; i < COUNT/2; i++) { + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + for (lfs3_size_t i = 0; i < COUNT/2; i++) { char name[8]; sprintf(name, "dir%03d", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; // write another COUNT/2 dirs - for (lfs_size_t i = COUNT/2; i < COUNT; i++) { + for (lfs3_size_t i = COUNT/2; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); lfsp_mkdir(&lfsp, name) => 0; @@ -1050,7 +1050,7 @@ code = ''' assert(info.type == LFSP_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_dir_read(&lfsp, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); @@ -1071,55 +1071,55 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 2 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the previous version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // write half COUNT files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { // write half - lfsr_file_t file; + lfs3_file_t file; char name[8]; sprintf(name, "file%03d", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE/2; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + for (lfs3_size_t j = 0; j < SIZE/2; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } - lfsr_file_write(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, chunk, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // skip the other half but keep our prng reproducible - for (lfs_size_t j = SIZE/2; j < SIZE; j++) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j++) { TEST_PRNG(&prng); } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; // write half COUNT files prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { // skip half but keep our prng reproducible - for (lfs_size_t j = 0; j < SIZE/2; j++) { + for (lfs3_size_t j = 0; j < SIZE/2; j++) { TEST_PRNG(&prng); } @@ -1130,9 +1130,9 @@ code = ''' lfsp_file_open(&lfsp, &file, name, LFSP_O_WRONLY) => 0; lfsp_file_seek(&lfsp, &file, SIZE/2, LFSP_SEEK_SET) => SIZE/2; - for (lfs_size_t j = SIZE/2; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } @@ -1154,7 +1154,7 @@ code = ''' assert(info.type == LFSP_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_dir_read(&lfsp, &dir, &info) => 0; char name[8]; sprintf(name, "file%03d", i); @@ -1168,16 +1168,16 @@ code = ''' // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_file_t file; char name[8]; sprintf(name, "file%03d", i); lfsp_file_open(&lfsp, &file, name, LFSP_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; lfsp_file_read(&lfsp, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } @@ -1193,58 +1193,58 @@ defines.COUNT = 5 defines.SIZE = [4, 32, 512, 8192] defines.CHUNK = 2 if = [ - 'LFS_VERSION == LFSP_VERSION', - 'LFS_DISK_VERSION == LFSP_DISK_VERSION', + 'LFS3_VERSION == LFSP_VERSION', + 'LFS3_DISK_VERSION == LFSP_DISK_VERSION', ] code = ''' // create the previous version - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // write half COUNT files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[16]; sprintf(name, "dir%03d", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // write half - lfsr_file_t file; + lfs3_file_t file; sprintf(name, "dir%03d/file%03d", i, i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - for (lfs_size_t j = 0; j < SIZE/2; j += CHUNK) { + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + for (lfs3_size_t j = 0; j < SIZE/2; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } - lfsr_file_write(&lfs, &file, chunk, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, chunk, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // skip the other half but keep our prng reproducible - for (lfs_size_t j = SIZE/2; j < SIZE; j++) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j++) { TEST_PRNG(&prng); } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // now mount with previous version struct lfsp_config cfgp; - assert(sizeof(struct lfsp_config) == sizeof(struct lfs_config)); + assert(sizeof(struct lfsp_config) == sizeof(struct lfs3_config)); memcpy(&cfgp, CFG, sizeof(cfgp)); lfsp_t lfsp; lfsp_mount(&lfsp, LFSP_M_RDWR, &cfgp) => 0; // write half COUNT files prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { // skip half but keep our prng reproducible - for (lfs_size_t j = 0; j < SIZE/2; j++) { + for (lfs3_size_t j = 0; j < SIZE/2; j++) { TEST_PRNG(&prng); } @@ -1255,9 +1255,9 @@ code = ''' lfsp_file_open(&lfsp, &file, name, LFSP_O_WRONLY) => 0; lfsp_file_seek(&lfsp, &file, SIZE/2, LFSP_SEEK_SET) => SIZE/2; - for (lfs_size_t j = SIZE/2; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = SIZE/2; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { chunk[k] = TEST_PRNG(&prng) & 0xff; } @@ -1279,7 +1279,7 @@ code = ''' assert(info.type == LFSP_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_dir_read(&lfsp, &dir, &info) => 0; char name[8]; sprintf(name, "dir%03d", i); @@ -1292,7 +1292,7 @@ code = ''' lfsp_dir_close(&lfsp, &dir) => 0; // can we list the files? - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { char name[8]; sprintf(name, "dir%03d", i); lfsp_dir_t dir; @@ -1319,16 +1319,16 @@ code = ''' // now can we read the files? prng = 42; - for (lfs_size_t i = 0; i < COUNT; i++) { + for (lfs3_size_t i = 0; i < COUNT; i++) { lfsp_file_t file; char name[16]; sprintf(name, "dir%03d/file%03d", i, i); lfsp_file_open(&lfsp, &file, name, LFSP_O_RDONLY) => 0; - for (lfs_size_t j = 0; j < SIZE; j += CHUNK) { + for (lfs3_size_t j = 0; j < SIZE; j += CHUNK) { uint8_t chunk[CHUNK]; lfsp_file_read(&lfsp, &file, chunk, CHUNK) => CHUNK; - for (lfs_size_t k = 0; k < CHUNK; k++) { + for (lfs3_size_t k = 0; k < CHUNK; k++) { assert(chunk[k] == (TEST_PRNG(&prng) & 0xff)); } } diff --git a/tests/test_dirs.toml b/tests/test_dirs.toml index 6f661380..ef656b8d 100644 --- a/tests/test_dirs.toml +++ b/tests/test_dirs.toml @@ -7,106 +7,106 @@ after = 'test_mtree' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked with stat - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that noent errors work [cases.test_dirs_noent] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // make a directory - lfsr_mkdir(&lfs, "ardvark") => 0; + lfs3_mkdir(&lfs3, "ardvark") => 0; // try to read a nonsense path - struct lfs_info info; - lfsr_stat(&lfs, "no", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "no", &info) => LFS3_ERR_NOENT; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "no") => LFS_ERR_NOENT; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "no") => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that stat on root works [cases.test_dirs_stat_root] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // make a directory - lfsr_mkdir(&lfs, "ardvark") => 0; + lfs3_mkdir(&lfs3, "ardvark") => 0; // stat the root - struct lfs_info info; - lfsr_stat(&lfs, "/", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that creating the same directory twice errors @@ -114,68 +114,68 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // make the same directory, should error - lfsr_mkdir(&lfs, "ardvark") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "ardvark") => LFS3_ERR_EXIST; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that dir existance is the same before/after mkconsistent @@ -183,91 +183,91 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dir exists before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool exists = !err; // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == exists); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked with stat - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test what happens if we try to make root @@ -275,71 +275,71 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try to make root, which doesn't make sense - lfsr_mkdir(&lfs, "/") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "/") => LFS3_ERR_EXIST; // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to make root, which doesn't make sense - lfsr_mkdir(&lfs, "/") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "/") => LFS3_ERR_EXIST; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that creating a directory with an invalid path errors @@ -347,409 +347,409 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // make a nonsense directory, should error - lfsr_mkdir(&lfs, "no/hmm") => LFS_ERR_NOENT; + lfs3_mkdir(&lfs3, "no/hmm") => LFS3_ERR_NOENT; // make a nonsense child directory, should error - lfsr_mkdir(&lfs, "ardvark/no/hmm") => LFS_ERR_NOENT; + lfs3_mkdir(&lfs3, "ardvark/no/hmm") => LFS3_ERR_NOENT; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_siblings] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make some directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "cat") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "cat") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_children] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "ardvark/banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "ardvark/banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "ardvark/banana/cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "ardvark/banana/cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - err = lfsr_dir_open(&lfs, &dir, "/ardvark"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/ardvark"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == a_exists); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - err = lfsr_dir_open(&lfs, &dir, "/ardvark/banana"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/ardvark/banana"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == b_exists); if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // make some directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "ardvark/banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "ardvark/banana/cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "ardvark/banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "ardvark/banana/cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana/cat", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana/cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark/banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark/banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark/banana/cat") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark/banana/cat") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_many] @@ -760,88 +760,88 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_many_backwards] @@ -852,88 +852,88 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-1-i)); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_many_2layers] @@ -944,30 +944,30 @@ if = '!TEST_PLS || N <= 4' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { sprintf(name, "dir%03x/child%03x", i, j); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } } @@ -975,101 +975,101 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "child%03x", j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - for (lfs_size_t i = 0; i < N; i++) { - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t i = 0; i < N; i++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_many_3layers] @@ -1080,36 +1080,36 @@ if = '!TEST_PLS || N <= 2' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { sprintf(name, "dir%03x/child%03x", i, j); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } } @@ -1118,138 +1118,138 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "grandchild%03x", k); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "child%03x", j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "grandchild%03x", k); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - for (lfs_size_t i = 0; i < N; i++) { - for (lfs_size_t j = 0; j < N; j++) { - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t i = 0; i < N; i++) { + for (lfs3_size_t j = 0; j < N; j++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_many_linkedlist] @@ -1260,79 +1260,79 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create this many directory in a sort of linked-list by nesting char name[4096]; memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (i < N-1) { char name2[256]; sprintf(name2, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mkdir_fuzz] @@ -1347,29 +1347,29 @@ if = '!TEST_PLS || N <= 8' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (PARENT) { - err = lfsr_mkdir(&lfs, "pricklypear"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "pricklypear"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -1377,7 +1377,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -1388,79 +1388,79 @@ code = ''' // create a directory here char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), sim[j]); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1471,111 +1471,111 @@ code = ''' # ORDER=2 => random defines.ORDER = [0, 1, 2] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (ORDER == 0) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; - lfsr_mkdir(&lfs, "d") => 0; - lfsr_mkdir(&lfs, "e") => 0; - lfsr_mkdir(&lfs, "f") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; + lfs3_mkdir(&lfs3, "d") => 0; + lfs3_mkdir(&lfs3, "e") => 0; + lfs3_mkdir(&lfs3, "f") => 0; } else if (ORDER == 1) { - lfsr_mkdir(&lfs, "f") => 0; - lfsr_mkdir(&lfs, "e") => 0; - lfsr_mkdir(&lfs, "d") => 0; - lfsr_mkdir(&lfs, "c") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "a") => 0; + lfs3_mkdir(&lfs3, "f") => 0; + lfs3_mkdir(&lfs3, "e") => 0; + lfs3_mkdir(&lfs3, "d") => 0; + lfs3_mkdir(&lfs3, "c") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "a") => 0; } else if (ORDER == 2) { // "random", trust me - lfsr_mkdir(&lfs, "e") => 0; - lfsr_mkdir(&lfs, "c") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "d") => 0; - lfsr_mkdir(&lfs, "f") => 0; - lfsr_mkdir(&lfs, "a") => 0; + lfs3_mkdir(&lfs3, "e") => 0; + lfs3_mkdir(&lfs3, "c") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "d") => 0; + lfs3_mkdir(&lfs3, "f") => 0; + lfs3_mkdir(&lfs3, "a") => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - struct lfs_info info; - lfsr_stat(&lfs, "a", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "a", &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "b", &info) => 0; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "c", &info) => 0; + lfs3_stat(&lfs3, "c", &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "d", &info) => 0; + lfs3_stat(&lfs3, "d", &info) => 0; assert(strcmp(info.name, "d") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "e", &info) => 0; + lfs3_stat(&lfs3, "e", &info) => 0; assert(strcmp(info.name, "e") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "f", &info) => 0; + lfs3_stat(&lfs3, "f", &info) => 0; assert(strcmp(info.name, "f") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // check the directory order - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_ordering_length] @@ -1584,111 +1584,111 @@ code = ''' # ORDER=2 => random defines.ORDER = [0, 1, 2] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (ORDER == 0) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "aa") => 0; - lfsr_mkdir(&lfs, "aaa") => 0; - lfsr_mkdir(&lfs, "aaaa") => 0; - lfsr_mkdir(&lfs, "aaaaa") => 0; - lfsr_mkdir(&lfs, "aaaaaa") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "aa") => 0; + lfs3_mkdir(&lfs3, "aaa") => 0; + lfs3_mkdir(&lfs3, "aaaa") => 0; + lfs3_mkdir(&lfs3, "aaaaa") => 0; + lfs3_mkdir(&lfs3, "aaaaaa") => 0; } else if (ORDER == 1) { - lfsr_mkdir(&lfs, "aaaaaa") => 0; - lfsr_mkdir(&lfs, "aaaaa") => 0; - lfsr_mkdir(&lfs, "aaaa") => 0; - lfsr_mkdir(&lfs, "aaa") => 0; - lfsr_mkdir(&lfs, "aa") => 0; - lfsr_mkdir(&lfs, "a") => 0; + lfs3_mkdir(&lfs3, "aaaaaa") => 0; + lfs3_mkdir(&lfs3, "aaaaa") => 0; + lfs3_mkdir(&lfs3, "aaaa") => 0; + lfs3_mkdir(&lfs3, "aaa") => 0; + lfs3_mkdir(&lfs3, "aa") => 0; + lfs3_mkdir(&lfs3, "a") => 0; } else if (ORDER == 2) { // "random", trust me - lfsr_mkdir(&lfs, "aaaaa") => 0; - lfsr_mkdir(&lfs, "aaa") => 0; - lfsr_mkdir(&lfs, "aa") => 0; - lfsr_mkdir(&lfs, "aaaa") => 0; - lfsr_mkdir(&lfs, "aaaaaa") => 0; - lfsr_mkdir(&lfs, "a") => 0; + lfs3_mkdir(&lfs3, "aaaaa") => 0; + lfs3_mkdir(&lfs3, "aaa") => 0; + lfs3_mkdir(&lfs3, "aa") => 0; + lfs3_mkdir(&lfs3, "aaaa") => 0; + lfs3_mkdir(&lfs3, "aaaaaa") => 0; + lfs3_mkdir(&lfs3, "a") => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - struct lfs_info info; - lfsr_stat(&lfs, "a", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "a", &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "aa", &info) => 0; + lfs3_stat(&lfs3, "aa", &info) => 0; assert(strcmp(info.name, "aa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "aaa", &info) => 0; + lfs3_stat(&lfs3, "aaa", &info) => 0; assert(strcmp(info.name, "aaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "aaaa", &info) => 0; + lfs3_stat(&lfs3, "aaaa", &info) => 0; assert(strcmp(info.name, "aaaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "aaaaa", &info) => 0; + lfs3_stat(&lfs3, "aaaaa", &info) => 0; assert(strcmp(info.name, "aaaaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "aaaaaa", &info) => 0; + lfs3_stat(&lfs3, "aaaaaa", &info) => 0; assert(strcmp(info.name, "aaaaaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // check the directory order - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "aa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "aaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "aaaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "aaaaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "aaaaaa") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1697,184 +1697,184 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - assert(lfs_crc32c(0, "a_SNmwMTHH", 10) == 0x12345678); - assert(lfs_crc32c(0, "b_skvjpWJH", 10) == 0x12345678); - assert(lfs_crc32c(0, "c_OnOQhVPH", 10) == 0x12345678); - assert(lfs_crc32c(0, "d_puMpPjRH", 10) == 0x12345678); - assert(lfs_crc32c(0, "e_LptKHkHH", 10) == 0x12345678); - assert(lfs_crc32c(0, "f_lUoVuhJH", 10) == 0x12345678); + assert(lfs3_crc32c(0, "a_SNmwMTHH", 10) == 0x12345678); + assert(lfs3_crc32c(0, "b_skvjpWJH", 10) == 0x12345678); + assert(lfs3_crc32c(0, "c_OnOQhVPH", 10) == 0x12345678); + assert(lfs3_crc32c(0, "d_puMpPjRH", 10) == 0x12345678); + assert(lfs3_crc32c(0, "e_LptKHkHH", 10) == 0x12345678); + assert(lfs3_crc32c(0, "f_lUoVuhJH", 10) == 0x12345678); // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "a_SNmwMTHH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "a_SNmwMTHH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "b_skvjpWJH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "b_skvjpWJH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "c_OnOQhVPH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "c_OnOQhVPH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - err = lfsr_stat(&lfs, "d_puMpPjRH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "d_puMpPjRH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool d_exists = !err; - err = lfsr_stat(&lfs, "e_LptKHkHH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "e_LptKHkHH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool e_exists = !err; - err = lfsr_stat(&lfs, "f_lUoVuhJH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "f_lUoVuhJH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool f_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a_SNmwMTHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b_skvjpWJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c_OnOQhVPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (d_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d_puMpPjRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (e_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e_LptKHkHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (f_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f_lUoVuhJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make directories - err = lfsr_mkdir(&lfs, "a_SNmwMTHH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "b_skvjpWJH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "c_OnOQhVPH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); - err = lfsr_mkdir(&lfs, "d_puMpPjRH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == d_exists); - err = lfsr_mkdir(&lfs, "e_LptKHkHH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == e_exists); - err = lfsr_mkdir(&lfs, "f_lUoVuhJH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == f_exists); + err = lfs3_mkdir(&lfs3, "a_SNmwMTHH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "b_skvjpWJH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "c_OnOQhVPH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "d_puMpPjRH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == d_exists); + err = lfs3_mkdir(&lfs3, "e_LptKHkHH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == e_exists); + err = lfs3_mkdir(&lfs3, "f_lUoVuhJH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == f_exists); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - lfsr_stat(&lfs, "a_SNmwMTHH", &info) => 0; + lfs3_stat(&lfs3, "a_SNmwMTHH", &info) => 0; assert(strcmp(info.name, "a_SNmwMTHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "b_skvjpWJH", &info) => 0; + lfs3_stat(&lfs3, "b_skvjpWJH", &info) => 0; assert(strcmp(info.name, "b_skvjpWJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "c_OnOQhVPH", &info) => 0; + lfs3_stat(&lfs3, "c_OnOQhVPH", &info) => 0; assert(strcmp(info.name, "c_OnOQhVPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "d_puMpPjRH", &info) => 0; + lfs3_stat(&lfs3, "d_puMpPjRH", &info) => 0; assert(strcmp(info.name, "d_puMpPjRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "e_LptKHkHH", &info) => 0; + lfs3_stat(&lfs3, "e_LptKHkHH", &info) => 0; assert(strcmp(info.name, "e_LptKHkHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "f_lUoVuhJH", &info) => 0; + lfs3_stat(&lfs3, "f_lUoVuhJH", &info) => 0; assert(strcmp(info.name, "f_lUoVuhJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a_SNmwMTHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b_skvjpWJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c_OnOQhVPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d_puMpPjRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e_LptKHkHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f_lUoVuhJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # these will also collide with the root @@ -1882,184 +1882,184 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - assert(lfs_crc32c(0, "b_iUwOsqRH", 10) == 0x00000000); - assert(lfs_crc32c(0, "c_UPNtkpHH", 10) == 0x00000000); - assert(lfs_crc32c(0, "d_jKLUSLJH", 10) == 0x00000000); - assert(lfs_crc32c(0, "e_VNunKMPH", 10) == 0x00000000); - assert(lfs_crc32c(0, "f_vknsvNRH", 10) == 0x00000000); + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + assert(lfs3_crc32c(0, "b_iUwOsqRH", 10) == 0x00000000); + assert(lfs3_crc32c(0, "c_UPNtkpHH", 10) == 0x00000000); + assert(lfs3_crc32c(0, "d_jKLUSLJH", 10) == 0x00000000); + assert(lfs3_crc32c(0, "e_VNunKMPH", 10) == 0x00000000); + assert(lfs3_crc32c(0, "f_vknsvNRH", 10) == 0x00000000); // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "a_IplRNrPH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "a_IplRNrPH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "b_iUwOsqRH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "b_iUwOsqRH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "c_UPNtkpHH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "c_UPNtkpHH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - err = lfsr_stat(&lfs, "d_jKLUSLJH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "d_jKLUSLJH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool d_exists = !err; - err = lfsr_stat(&lfs, "e_VNunKMPH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "e_VNunKMPH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool e_exists = !err; - err = lfsr_stat(&lfs, "f_vknsvNRH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "f_vknsvNRH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool f_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a_IplRNrPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b_iUwOsqRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c_UPNtkpHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (d_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d_jKLUSLJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (e_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e_VNunKMPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (f_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f_vknsvNRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make directories - err = lfsr_mkdir(&lfs, "a_IplRNrPH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "b_iUwOsqRH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "c_UPNtkpHH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); - err = lfsr_mkdir(&lfs, "d_jKLUSLJH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == d_exists); - err = lfsr_mkdir(&lfs, "e_VNunKMPH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == e_exists); - err = lfsr_mkdir(&lfs, "f_vknsvNRH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == f_exists); + err = lfs3_mkdir(&lfs3, "a_IplRNrPH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "b_iUwOsqRH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "c_UPNtkpHH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "d_jKLUSLJH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == d_exists); + err = lfs3_mkdir(&lfs3, "e_VNunKMPH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == e_exists); + err = lfs3_mkdir(&lfs3, "f_vknsvNRH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == f_exists); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - lfsr_stat(&lfs, "a_IplRNrPH", &info) => 0; + lfs3_stat(&lfs3, "a_IplRNrPH", &info) => 0; assert(strcmp(info.name, "a_IplRNrPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "b_iUwOsqRH", &info) => 0; + lfs3_stat(&lfs3, "b_iUwOsqRH", &info) => 0; assert(strcmp(info.name, "b_iUwOsqRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "c_UPNtkpHH", &info) => 0; + lfs3_stat(&lfs3, "c_UPNtkpHH", &info) => 0; assert(strcmp(info.name, "c_UPNtkpHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "d_jKLUSLJH", &info) => 0; + lfs3_stat(&lfs3, "d_jKLUSLJH", &info) => 0; assert(strcmp(info.name, "d_jKLUSLJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "e_VNunKMPH", &info) => 0; + lfs3_stat(&lfs3, "e_VNunKMPH", &info) => 0; assert(strcmp(info.name, "e_VNunKMPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "f_vknsvNRH", &info) => 0; + lfs3_stat(&lfs3, "f_vknsvNRH", &info) => 0; assert(strcmp(info.name, "f_vknsvNRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a_IplRNrPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b_iUwOsqRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c_UPNtkpHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d_jKLUSLJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e_VNunKMPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f_vknsvNRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # these will need to rollover from 0xffffffff -> 0x00000000 correctly @@ -2069,184 +2069,184 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - assert(lfs_crc32c(0, "a_iomlVKPH", 10) == 0xffffffff); - assert(lfs_crc32c(0, "b_IJvqkHRH", 10) == 0xffffffff); - assert(lfs_crc32c(0, "c_uOOJsIHH", 10) == 0xffffffff); - assert(lfs_crc32c(0, "d_JTMkKuJH", 10) == 0xffffffff); - assert(lfs_crc32c(0, "e_vQtPStPH", 10) == 0xffffffff); - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + assert(lfs3_crc32c(0, "a_iomlVKPH", 10) == 0xffffffff); + assert(lfs3_crc32c(0, "b_IJvqkHRH", 10) == 0xffffffff); + assert(lfs3_crc32c(0, "c_uOOJsIHH", 10) == 0xffffffff); + assert(lfs3_crc32c(0, "d_JTMkKuJH", 10) == 0xffffffff); + assert(lfs3_crc32c(0, "e_vQtPStPH", 10) == 0xffffffff); + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "a_iomlVKPH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "a_iomlVKPH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "b_IJvqkHRH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "b_IJvqkHRH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "c_uOOJsIHH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "c_uOOJsIHH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - err = lfsr_stat(&lfs, "d_JTMkKuJH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "d_JTMkKuJH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool d_exists = !err; - err = lfsr_stat(&lfs, "e_vQtPStPH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "e_vQtPStPH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool e_exists = !err; - err = lfsr_stat(&lfs, "f_VtoMnwRH", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "f_VtoMnwRH", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool f_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a_iomlVKPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b_IJvqkHRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c_uOOJsIHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (d_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d_JTMkKuJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (e_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e_vQtPStPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (f_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f_VtoMnwRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make directories - err = lfsr_mkdir(&lfs, "a_iomlVKPH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "b_IJvqkHRH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "c_uOOJsIHH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); - err = lfsr_mkdir(&lfs, "d_JTMkKuJH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == d_exists); - err = lfsr_mkdir(&lfs, "e_vQtPStPH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == e_exists); - err = lfsr_mkdir(&lfs, "f_VtoMnwRH"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == f_exists); + err = lfs3_mkdir(&lfs3, "a_iomlVKPH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "b_IJvqkHRH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "c_uOOJsIHH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "d_JTMkKuJH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == d_exists); + err = lfs3_mkdir(&lfs3, "e_vQtPStPH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == e_exists); + err = lfs3_mkdir(&lfs3, "f_VtoMnwRH"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == f_exists); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdirs worked - lfsr_stat(&lfs, "a_iomlVKPH", &info) => 0; + lfs3_stat(&lfs3, "a_iomlVKPH", &info) => 0; assert(strcmp(info.name, "a_iomlVKPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "b_IJvqkHRH", &info) => 0; + lfs3_stat(&lfs3, "b_IJvqkHRH", &info) => 0; assert(strcmp(info.name, "b_IJvqkHRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "c_uOOJsIHH", &info) => 0; + lfs3_stat(&lfs3, "c_uOOJsIHH", &info) => 0; assert(strcmp(info.name, "c_uOOJsIHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "d_JTMkKuJH", &info) => 0; + lfs3_stat(&lfs3, "d_JTMkKuJH", &info) => 0; assert(strcmp(info.name, "d_JTMkKuJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "e_vQtPStPH", &info) => 0; + lfs3_stat(&lfs3, "e_vQtPStPH", &info) => 0; assert(strcmp(info.name, "e_vQtPStPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "f_VtoMnwRH", &info) => 0; + lfs3_stat(&lfs3, "f_VtoMnwRH", &info) => 0; assert(strcmp(info.name, "f_VtoMnwRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a_iomlVKPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b_IJvqkHRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c_uOOJsIHH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "d_JTMkKuJH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "e_vQtPStPH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "f_VtoMnwRH") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # these test some boundary conditions on the underlying leb128 encoding, @@ -2257,79 +2257,79 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked with stat - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // and remove the directory - lfsr_remove(&lfs, "ardvark") => 0; + lfs3_remove(&lfs3, "ardvark") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that remove worked with stat - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that noent errors work @@ -2337,62 +2337,62 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to remove a nonsense directory - lfsr_remove(&lfs, "no") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "no") => LFS3_ERR_NOENT; // try to remove a directory in a nonsense directory - lfsr_remove(&lfs, "no/ardvark") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "no/ardvark") => LFS3_ERR_NOENT; // try to remove a nonsense child directory - lfsr_remove(&lfs, "ardvark/no") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "ardvark/no") => LFS3_ERR_NOENT; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we catch removing of a non-empty directory @@ -2400,80 +2400,80 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // fill it with stuff - err = lfsr_mkdir(&lfs, "ardvark/banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark/banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to remove the parent directory - lfsr_remove(&lfs, "ardvark") => LFS_ERR_NOTEMPTY; + lfs3_remove(&lfs3, "ardvark") => LFS3_ERR_NOTEMPTY; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that dir existance is the same before/after mkconsistent @@ -2482,104 +2482,104 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dir exists before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool exists = !err; // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == exists); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked with stat - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // and remove the directory - lfsr_remove(&lfs, "ardvark") => 0; + lfs3_remove(&lfs3, "ardvark") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that remove worked with stat - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test what happens if we try to remove root @@ -2587,62 +2587,62 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try to remove root, which doesn't really make sense - lfsr_remove(&lfs, "/") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "/") => LFS3_ERR_INVAL; // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to remove root, which doesn't really make sense // // it doesn't really matter which error returns first, so accept both - err = lfsr_remove(&lfs, "/"); - assert(err == LFS_ERR_NOTEMPTY || err == LFS_ERR_INVAL); + err = lfs3_remove(&lfs3, "/"); + assert(err == LFS3_ERR_NOTEMPTY || err == LFS3_ERR_INVAL); for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_siblings] @@ -2650,216 +2650,216 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make some directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now remove each directory - lfsr_remove(&lfs, "ardvark") => 0; + lfs3_remove(&lfs3, "ardvark") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our remove worked - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // remove another - lfsr_remove(&lfs, "banana") => 0; + lfs3_remove(&lfs3, "banana") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our remove worked - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "banana", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "banana", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // remove another - lfsr_remove(&lfs, "cat") => 0; + lfs3_remove(&lfs3, "cat") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our remove worked - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "banana", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "cat", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "banana", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "cat", &info) => LFS3_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_children] @@ -2867,308 +2867,308 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "ardvark/banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "ardvark/banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "ardvark/banana/cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "ardvark/banana/cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - err = lfsr_dir_open(&lfs, &dir, "/ardvark"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/ardvark"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == a_exists); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - err = lfsr_dir_open(&lfs, &dir, "/ardvark/banana"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/ardvark/banana"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == b_exists); if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // make some directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "ardvark/banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "ardvark/banana/cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "ardvark/banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "ardvark/banana/cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdirs worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana/cat", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana/cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark/banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark/banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now remove each directory - lfsr_remove(&lfs, "ardvark/banana/cat") => 0; + lfs3_remove(&lfs3, "ardvark/banana/cat") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our remove worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana/cat", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark/banana/cat", &info) => LFS3_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark/banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark/banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // remove another - lfsr_remove(&lfs, "ardvark/banana") => 0; + lfs3_remove(&lfs3, "ardvark/banana") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our remove worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ardvark/banana/cat", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark/banana", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark/banana/cat", &info) => LFS3_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // remove another - lfsr_remove(&lfs, "ardvark") => 0; + lfs3_remove(&lfs3, "ardvark") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our remove worked - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ardvark/banana", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ardvark/banana/cat", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark/banana", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ardvark/banana/cat", &info) => LFS3_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_many] @@ -3183,122 +3183,122 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now remove some number of directories - for (lfs_size_t i = 0; i < N-REMAINING; i++) { + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our removes worked - for (lfs_size_t i = 0; i < N-REMAINING; i++) { + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-REMAINING + i)); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-REMAINING + i)); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_many_backwards] @@ -3313,122 +3313,122 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-1-i)); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now remove some number of directories - for (lfs_size_t i = 0; i < N-REMAINING; i++) { + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-1-i)); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our removes worked - for (lfs_size_t i = 0; i < N-REMAINING; i++) { + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-1-i)); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_many_2layers] @@ -3447,217 +3447,217 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { sprintf(name, "dir%03x/child%03x", i, j); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdirs worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "child%03x", j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now remove some number of directories - for (lfs_size_t i = 0; i < N; i++) { - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t i = 0; i < N; i++) { + for (lfs3_size_t j = 0; j < N; j++) { if (i < N-REMAINING || j < N-REMAINING) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (i < N-REMAINING) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our removes worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; + struct lfs3_info info; if (i < N-REMAINING) { - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } else { - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; + struct lfs3_info info; if (j < N-REMAINING) { - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } else { - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } } } - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-REMAINING + i)); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-REMAINING + i)); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < REMAINING; j++) { + for (lfs3_size_t j = 0; j < REMAINING; j++) { char name[256]; sprintf(name, "child%03x", (int)(N-REMAINING + j)); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_many_3layers] @@ -3672,235 +3672,235 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { sprintf(name, "dir%03x/child%03x", i, j); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } } } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdirs worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "grandchild%03x", k); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "child%03x", j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "grandchild%03x", k); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } // now remove some number of directories - for (lfs_size_t i = 0; i < N; i++) { - for (lfs_size_t j = 0; j < N; j++) { - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t i = 0; i < N; i++) { + for (lfs3_size_t j = 0; j < N; j++) { + for (lfs3_size_t k = 0; k < N; k++) { if (i < N-REMAINING || j < N-REMAINING || k < N-REMAINING) { char name[256]; sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (i < N-REMAINING || j < N-REMAINING) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (i < N-REMAINING) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our removes worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; + struct lfs3_info info; if (i < N-REMAINING) { - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } else { - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; + struct lfs3_info info; if (j < N-REMAINING) { - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } else { - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - struct lfs_info info; + struct lfs3_info info; if (k < N-REMAINING) { - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } else { - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "grandchild%03x", k); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } @@ -3909,80 +3909,80 @@ code = ''' } } - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-REMAINING + i)); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-REMAINING + i)); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < REMAINING; j++) { + for (lfs3_size_t j = 0; j < REMAINING; j++) { char name[256]; sprintf(name, "child%03x", (int)(N-REMAINING + j)); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - for (lfs_size_t i = 0; i < REMAINING; i++) { - for (lfs_size_t j = 0; j < REMAINING; j++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t j = 0; j < REMAINING; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", (int)(N-REMAINING + i), (int)(N-REMAINING + j)); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < REMAINING; k++) { + for (lfs3_size_t k = 0; k < REMAINING; k++) { char name[256]; sprintf(name, "grandchild%03x", (int)(N-REMAINING + k)); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_many_linkedlist] @@ -3997,130 +3997,130 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create this many directory in a sort of linked-list by nesting char name[4096]; memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (i < N-1) { char name2[256]; sprintf(name2, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now remove some number of directories - for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_remove(&lfs, name) => 0; + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { + lfs3_remove(&lfs3, name) => 0; name[strlen(name) - strlen("/dir...")] = '\0'; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our remove worked memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < REMAINING; i++) { + for (lfs3_size_t i = 0; i < REMAINING; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (i < REMAINING-1) { char name2[256]; sprintf(name2, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_rm_fuzz] @@ -4135,32 +4135,32 @@ if = '!TEST_PLS || N <= 8' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (PARENT) { - err = lfsr_mkdir(&lfs, "pricklypear"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "pricklypear"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir or rmdir uint8_t op = TEST_PRNG(&prng) % 2; if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -4168,7 +4168,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -4179,76 +4179,76 @@ code = ''' // create a directory here char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4259,93 +4259,93 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // clean up interrupted renames if (TEST_PLS) { - err = lfsr_remove(&lfs, "banana"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "banana"); + assert(!err || err == LFS3_ERR_NOENT); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked with stat - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now rename the directory - lfsr_rename(&lfs, "ardvark", "banana") => 0; + lfs3_rename(&lfs3, "ardvark", "banana") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that rename worked with stat - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we can rename, and replace, other directories @@ -4354,93 +4354,93 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - err = lfsr_mkdir(&lfs, "banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked with stat - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now rename the directory - lfsr_rename(&lfs, "ardvark", "banana") => 0; + lfs3_rename(&lfs3, "ardvark", "banana") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that rename worked with stat - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we can rename to ourselves @@ -4449,86 +4449,86 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked with stat - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now rename the directory to itself - lfsr_rename(&lfs, "ardvark", "ardvark") => 0; + lfs3_rename(&lfs3, "ardvark", "ardvark") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that rename worked with stat - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we catch replacing an invalid path @@ -4536,65 +4536,65 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to rename a nonsense directory - lfsr_rename(&lfs, "no", "ardvark") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "no", "ardvark") => LFS3_ERR_NOENT; // try to rename a directory in a nonsense directory - lfsr_rename(&lfs, "no/ardvark", "ardvark") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "no/ardvark", "ardvark") => LFS3_ERR_NOENT; // try to rename a nonsense child directory - lfsr_rename(&lfs, "ardvark/no", "banana") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "ardvark/no", "banana") => LFS3_ERR_NOENT; // try to rename to a nonense directory - lfsr_rename(&lfs, "ardvark", "no/ardvark") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "ardvark", "no/ardvark") => LFS3_ERR_NOENT; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we catch replacing a non-empty directory @@ -4602,89 +4602,89 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - err = lfsr_mkdir(&lfs, "banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // fill dest with stuff - err = lfsr_mkdir(&lfs, "banana/cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "banana/cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to rename - lfsr_rename(&lfs, "ardvark", "banana") => LFS_ERR_NOTEMPTY; + lfs3_rename(&lfs3, "ardvark", "banana") => LFS3_ERR_NOTEMPTY; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "banana/cat", &info) => 0; + lfs3_stat(&lfs3, "banana/cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that dir existance is the same before/after mkconsistent @@ -4693,128 +4693,128 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; // and with dir_read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); // clean up interrupted renames if (TEST_PLS) { - err = lfsr_remove(&lfs, "banana"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "banana"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == b_exists); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked with stat - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now rename the directory - lfsr_rename(&lfs, "ardvark", "banana") => 0; + lfs3_rename(&lfs3, "ardvark", "banana") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that rename worked with stat - lfsr_stat(&lfs, "ardvark", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir_read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test what happens if we try to rename root @@ -4822,59 +4822,59 @@ code = ''' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try to rename root, which doesn't really make sense - lfsr_rename(&lfs, "/", "notroot") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "/", "notroot") => LFS3_ERR_INVAL; // make a directory - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // try to rename root, which doesn't really make sense - lfsr_rename(&lfs, "/", "notroot") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "/", "notroot") => LFS3_ERR_INVAL; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // and check that this didn't interfere with our original directory - struct lfs_info info; - lfsr_stat(&lfs, "ardvark", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_siblings] @@ -4882,298 +4882,298 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - err = lfsr_stat(&lfs, "disco", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool d_exists = !err; - err = lfsr_stat(&lfs, "eggplant", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "eggplant", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool e_exists = !err; - err = lfsr_stat(&lfs, "fish", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "fish", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool f_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (d_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (e_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (f_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "fish") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // make some directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); // clean up interrupted renames if (TEST_PLS) { - err = lfsr_remove(&lfs, "disco"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == d_exists); - err = lfsr_remove(&lfs, "eggplant"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "eggplant"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == e_exists); - err = lfsr_remove(&lfs, "fish"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "fish"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == f_exists); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now rename each directory - lfsr_rename(&lfs, "ardvark", "disco") => 0; + lfs3_rename(&lfs3, "ardvark", "disco") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our rename worked - lfsr_stat(&lfs, "banana", &info) => 0; + lfs3_stat(&lfs3, "banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco", &info) => 0; + lfs3_stat(&lfs3, "disco", &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rename another - lfsr_rename(&lfs, "banana", "eggplant") => 0; + lfs3_rename(&lfs3, "banana", "eggplant") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our rename worked - lfsr_stat(&lfs, "cat", &info) => 0; + lfs3_stat(&lfs3, "cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco", &info) => 0; + lfs3_stat(&lfs3, "disco", &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "eggplant", &info) => 0; + lfs3_stat(&lfs3, "eggplant", &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rename another - lfsr_rename(&lfs, "cat", "fish") => 0; + lfs3_rename(&lfs3, "cat", "fish") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our rename worked - lfsr_stat(&lfs, "disco", &info) => 0; + lfs3_stat(&lfs3, "disco", &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "eggplant", &info) => 0; + lfs3_stat(&lfs3, "eggplant", &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "fish", &info) => 0; + lfs3_stat(&lfs3, "fish", &info) => 0; assert(strcmp(info.name, "fish") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "fish") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_children] @@ -5181,488 +5181,488 @@ defines.REMOUNT = [false, true] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if dirs exist before mkconsistent - struct lfs_info info; - err = lfsr_stat(&lfs, "ardvark", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + struct lfs3_info info; + err = lfs3_stat(&lfs3, "ardvark", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool a_exists = !err; - err = lfsr_stat(&lfs, "ardvark/banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "ardvark/banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool b_exists = !err; - err = lfsr_stat(&lfs, "ardvark/banana/cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "ardvark/banana/cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool c_exists = !err; - err = lfsr_stat(&lfs, "disco", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool d_exists = !err; - err = lfsr_stat(&lfs, "disco/eggplant", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco/eggplant", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool e_exists = !err; - err = lfsr_stat(&lfs, "disco/eggplant/fish", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco/eggplant/fish", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool f_exists = !err; - err = lfsr_stat(&lfs, "disco/banana", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco/banana", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool db_exists = !err; - err = lfsr_stat(&lfs, "disco/banana/cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco/banana/cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool dbc_exists = !err; - err = lfsr_stat(&lfs, "disco/eggplant/cat", &info); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_stat(&lfs3, "disco/eggplant/cat", &info); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); bool dec_exists = !err; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (d_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - err = lfsr_dir_open(&lfs, &dir, "/ardvark"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/ardvark"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == a_exists); if (a_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - err = lfsr_dir_open(&lfs, &dir, "/ardvark/banana"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/ardvark/banana"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == b_exists); if (b_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (c_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - err = lfsr_dir_open(&lfs, &dir, "/disco"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/disco"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == d_exists); if (d_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (db_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (e_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - err = lfsr_dir_open(&lfs, &dir, "/disco/eggplant"); - assert(err == LFS_ERR_NOENT || (TEST_PLS && !err)); + err = lfs3_dir_open(&lfs3, &dir, "/disco/eggplant"); + assert(err == LFS3_ERR_NOENT || (TEST_PLS && !err)); assert(!err == e_exists); if (e_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (dec_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } if (f_exists) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "fish") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // make some directories - err = lfsr_mkdir(&lfs, "ardvark"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == a_exists); - err = lfsr_mkdir(&lfs, "ardvark/banana"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == b_exists); - err = lfsr_mkdir(&lfs, "ardvark/banana/cat"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); - assert((err == LFS_ERR_EXIST) == c_exists); + err = lfs3_mkdir(&lfs3, "ardvark"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == a_exists); + err = lfs3_mkdir(&lfs3, "ardvark/banana"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == b_exists); + err = lfs3_mkdir(&lfs3, "ardvark/banana/cat"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); + assert((err == LFS3_ERR_EXIST) == c_exists); // clean up interrupted renames if (TEST_PLS) { - err = lfsr_remove(&lfs, "disco/eggplant/fish"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco/eggplant/fish"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == f_exists); - err = lfsr_remove(&lfs, "disco/eggplant/cat"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco/eggplant/cat"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == dec_exists); - err = lfsr_remove(&lfs, "disco/eggplant"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco/eggplant"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == e_exists); - err = lfsr_remove(&lfs, "disco/banana/cat"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco/banana/cat"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == dbc_exists); - err = lfsr_remove(&lfs, "disco/banana"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco/banana"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == db_exists); - err = lfsr_remove(&lfs, "disco"); - assert(!err || err == LFS_ERR_NOENT); + err = lfs3_remove(&lfs3, "disco"); + assert(!err || err == LFS3_ERR_NOENT); assert(!err == d_exists); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdirs worked - lfsr_stat(&lfs, "ardvark", &info) => 0; + lfs3_stat(&lfs3, "ardvark", &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "ardvark/banana/cat", &info) => 0; + lfs3_stat(&lfs3, "ardvark/banana/cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/ardvark/banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/ardvark/banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now rename each directory - lfsr_rename(&lfs, "ardvark", "disco") => 0; + lfs3_rename(&lfs3, "ardvark", "disco") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our rename worked - lfsr_stat(&lfs, "disco", &info) => 0; + lfs3_stat(&lfs3, "disco", &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco/banana", &info) => 0; + lfs3_stat(&lfs3, "disco/banana", &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco/banana/cat", &info) => 0; + lfs3_stat(&lfs3, "disco/banana/cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/disco") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/disco") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "banana") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/disco/banana") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/disco/banana") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rename another - lfsr_rename(&lfs, "disco/banana", "disco/eggplant") => 0; + lfs3_rename(&lfs3, "disco/banana", "disco/eggplant") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our rename worked - lfsr_stat(&lfs, "disco", &info) => 0; + lfs3_stat(&lfs3, "disco", &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco/eggplant", &info) => 0; + lfs3_stat(&lfs3, "disco/eggplant", &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco/eggplant/cat", &info) => 0; + lfs3_stat(&lfs3, "disco/eggplant/cat", &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/disco") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/disco") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/disco/eggplant") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/disco/eggplant") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "cat") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rename another - lfsr_rename(&lfs, "disco/eggplant/cat", "disco/eggplant/fish") => 0; + lfs3_rename(&lfs3, "disco/eggplant/cat", "disco/eggplant/fish") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our rename worked - lfsr_stat(&lfs, "disco", &info) => 0; + lfs3_stat(&lfs3, "disco", &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco/eggplant", &info) => 0; + lfs3_stat(&lfs3, "disco/eggplant", &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_stat(&lfs, "disco/eggplant/fish", &info) => 0; + lfs3_stat(&lfs3, "disco/eggplant/fish", &info) => 0; assert(strcmp(info.name, "fish") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "disco") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/disco") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/disco") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "eggplant") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/disco/eggplant") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/disco/eggplant") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "fish") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_many] @@ -5674,125 +5674,125 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if we have already started renaming, in case of powerloss - struct lfs_info info; - err = lfsr_stat(&lfs, ((BEFORE) ? "/0mved000" : "/mved000"), &info); - if (err == LFS_ERR_NOENT) { + struct lfs3_info info; + err = lfs3_stat(&lfs3, ((BEFORE) ? "/0mved000" : "/mved000"), &info); + if (err == LFS3_ERR_NOENT) { // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now rename the directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char old_name[256]; sprintf(old_name, "dir%03x", i); char new_name[256]; sprintf(new_name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our renames worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_many_backwards] @@ -5804,125 +5804,125 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if we have already started renaming, in case of powerloss - struct lfs_info info; - err = lfsr_stat(&lfs, ((BEFORE) ? "/0mved000" : "/mved000"), &info); - if (err == LFS_ERR_NOENT) { + struct lfs3_info info; + err = lfs3_stat(&lfs3, ((BEFORE) ? "/0mved000" : "/mved000"), &info); + if (err == LFS3_ERR_NOENT) { // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", (int)(N-1-i)); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now rename the directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char old_name[256]; sprintf(old_name, "dir%03x", i); char new_name[256]; sprintf(new_name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our renames worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_many_2layers] @@ -5934,123 +5934,123 @@ if = '!TEST_PLS || N <= 4' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if we have already started renaming, in case of powerloss - struct lfs_info info; - err = lfsr_stat(&lfs, ((BEFORE) ? "/0mved000" : "/mved000"), &info); - if (err == LFS_ERR_NOENT) { + struct lfs3_info info; + err = lfs3_stat(&lfs3, ((BEFORE) ? "/0mved000" : "/mved000"), &info); + if (err == LFS3_ERR_NOENT) { // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { sprintf(name, "dir%03x/child%03x", i, j); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdirs worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "child%03x", j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } // now rename our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char old_name[256]; sprintf(old_name, "dir%03x", i); char new_name[256]; sprintf(new_name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char old_name[256]; sprintf(old_name, "%smved%03x/child%03x", ((BEFORE) ? "0" : ""), i, j); @@ -6058,13 +6058,13 @@ code = ''' sprintf(new_name, "%smved%03x/%schmved%03x", ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } } @@ -6072,83 +6072,83 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our renames worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "%smved%03x/%schmved%03x", ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "%schmved%03x", ((BEFORE) ? "0" : ""), j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "%schmved%03x", ((BEFORE) ? "0" : ""), j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_many_3layers] @@ -6160,165 +6160,165 @@ if = '!TEST_PLS || N <= 2' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if we have already started renaming, in case of powerloss - struct lfs_info info; - err = lfsr_stat(&lfs, ((BEFORE) ? "/0mved000" : "/mved000"), &info); - if (err == LFS_ERR_NOENT) { + struct lfs3_info info; + err = lfs3_stat(&lfs3, ((BEFORE) ? "/0mved000" : "/mved000"), &info); + if (err == LFS3_ERR_NOENT) { // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { sprintf(name, "dir%03x/child%03x", i, j); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // containing this many directories - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } } } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdirs worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "child%03x", j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "dir%03x/child%03x/grandchild%03x", i, j, k); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "grandchild%03x", k); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "child%03x", j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "dir%03x/child%03x", i, j); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "grandchild%03x", k); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } } // now rename our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char old_name[256]; sprintf(old_name, "dir%03x", i); char new_name[256]; sprintf(new_name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char old_name[256]; sprintf(old_name, "%smved%03x/child%03x", ((BEFORE) ? "0" : ""), i, j); @@ -6326,16 +6326,16 @@ code = ''' sprintf(new_name, "%smved%03x/%schmved%03x", ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char old_name[256]; sprintf(old_name, "%smved%03x/%schmved%03x/grandchild%03x", ((BEFORE) ? "0" : ""), i, @@ -6345,13 +6345,13 @@ code = ''' ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j, ((BEFORE) ? "0" : ""), k); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } } @@ -6360,124 +6360,124 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our removes worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "%smved%03x/%schmved%03x", ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "%schmved%03x", ((BEFORE) ? "0" : ""), j); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "%smved%03x/%schmved%03x/%sgrmved%03x", ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j, ((BEFORE) ? "0" : ""), k); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; sprintf(name, "%sgrmved%03x", ((BEFORE) ? "0" : ""), k); assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "%schmved%03x", ((BEFORE) ? "0" : ""), j); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "%smved%03x/%schmved%03x", ((BEFORE) ? "0" : ""), i, ((BEFORE) ? "0" : ""), j); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t k = 0; k < N; k++) { + for (lfs3_size_t k = 0; k < N; k++) { char name[256]; sprintf(name, "%sgrmved%03x", ((BEFORE) ? "0" : ""), k); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_many_linkedlist] @@ -6489,69 +6489,69 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check if we have already started renaming, in case of powerloss - struct lfs_info info; - err = lfsr_stat(&lfs, ((BEFORE) ? "/0mved000" : "/mved000"), &info); - if (err == LFS_ERR_NOENT) { + struct lfs3_info info; + err = lfs3_stat(&lfs3, ((BEFORE) ? "/0mved000" : "/mved000"), &info); + if (err == LFS3_ERR_NOENT) { // create this many directory in a sort of linked-list by nesting char name[4096]; memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our mkdir worked memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/dir%03x", i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (i < N-1) { char name2[256]; sprintf(name2, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } @@ -6560,17 +6560,17 @@ code = ''' memset(old_name, 0, sizeof(old_name)); char new_name[4096]; memset(new_name, 0, sizeof(new_name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&old_name[strlen(old_name)], "/dir%03x", i); sprintf(&new_name[strlen(new_name)], "/%smved%03x", ((BEFORE) ? "0" : ""), i); - err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // update old_name's path @@ -6580,59 +6580,59 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our renames worked char name[4096]; memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/%smved%03x", ((BEFORE) ? "0" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "%smved%03x", ((BEFORE) ? "0" : ""), i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } memset(name, 0, sizeof(name)); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sprintf(&name[strlen(name)], "/%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, name) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, name) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); if (i < N-1) { char name2[256]; sprintf(name2, "%smved%03x", ((BEFORE) ? "0" : ""), i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dirs_mv_fuzz] @@ -6647,32 +6647,32 @@ if = '!TEST_PLS || N <= 8' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (PARENT) { - err = lfsr_mkdir(&lfs, "pricklypear"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "pricklypear"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir or rename uint8_t op = TEST_PRNG(&prng) % 2; if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -6680,7 +6680,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -6691,33 +6691,33 @@ code = ''' // create a directory here char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -6729,61 +6729,61 @@ code = ''' sprintf(old_name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); char new_name[256]; sprintf(new_name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test all of the operations together @@ -6799,32 +6799,32 @@ if = '!TEST_PLS || N <= 8' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (PARENT) { - err = lfsr_mkdir(&lfs, "pricklypear"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "pricklypear"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -6832,7 +6832,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -6843,47 +6843,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -6895,60 +6895,60 @@ code = ''' sprintf(old_name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), x); char new_name[256]; sprintf(new_name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_dread.toml b/tests/test_dread.toml index 5870633c..c1469ecf 100644 --- a/tests/test_dread.toml +++ b/tests/test_dread.toml @@ -11,19 +11,19 @@ after = 'test_dirs' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.PARENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // read our directory @@ -31,188 +31,188 @@ code = ''' // Note tell's value is not guaranteed! We can test the exact value only // because these tests are tightly bound to the current littlefs version. // - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - lfsr_dir_tell(&lfs, &dir) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_tell(&lfs3, &dir) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_tell(&lfs, &dir) => 1; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_tell(&lfs3, &dir) => 1; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_dir_tell(&lfs, &dir) => 2 + i; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_dir_tell(&lfs3, &dir) => 2 + i; char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_tell(&lfs, &dir) => 2 + N; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_tell(&lfs, &dir) => 2 + N; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_rewind] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.PARENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; // read our directory once - lfsr_dir_tell(&lfs, &dir) => 0;; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_tell(&lfs3, &dir) => 0;; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_tell(&lfs, &dir) => 1; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_tell(&lfs3, &dir) => 1; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_dir_tell(&lfs, &dir) => 2 + i; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_dir_tell(&lfs3, &dir) => 2 + i; char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_tell(&lfs, &dir) => 2 + N; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_tell(&lfs, &dir) => 2 + N; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; // now read it again - lfsr_dir_rewind(&lfs, &dir) => 0; - lfsr_dir_tell(&lfs, &dir) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; + lfs3_dir_tell(&lfs3, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_tell(&lfs, &dir) => 1; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_tell(&lfs3, &dir) => 1; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_dir_tell(&lfs, &dir) => 2 + i; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_dir_tell(&lfs3, &dir) => 2 + i; char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_tell(&lfs, &dir) => 2 + N; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_tell(&lfs, &dir) => 2 + N; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_seek] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.PARENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; // read our directory once - lfsr_dir_tell(&lfs, &dir) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_tell(&lfs3, &dir) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_tell(&lfs, &dir) => 1; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_tell(&lfs3, &dir) => 1; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_dir_tell(&lfs, &dir) => 2 + i; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_dir_tell(&lfs3, &dir) => 2 + i; char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_tell(&lfs, &dir) => 2 + N; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_tell(&lfs, &dir) => 2 + N; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_tell(&lfs3, &dir) => 2 + N; // now try to seek to each entry explicitly - lfsr_dir_seek(&lfs, &dir, 0) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_seek(&lfs3, &dir, 0) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_seek(&lfs, &dir, 1) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_seek(&lfs3, &dir, 1) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_dir_seek(&lfs, &dir, 2 + i) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_dir_seek(&lfs3, &dir, 2 + i) => 0; char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_seek(&lfs, &dir, 2 + N) => 0; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_seek(&lfs, &dir, 2 + N) => 0; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_seek(&lfs3, &dir, 2 + N) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_seek(&lfs3, &dir, 2 + N) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we don't ever get extra entries back after we reach @@ -225,88 +225,88 @@ defines.NEIGHBORS = [0x0, 0x1, 0x2, 0x3] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } } char name[256]; sprintf(name, "%s/ardvark", ((PARENT) ? "pricklypear" : "")); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // read to the end - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_tell(&lfs, &dir) => 3; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_tell(&lfs3, &dir) => 3; // reading again should still return noent - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; // seeking past the end of the directory should still return noent - lfsr_dir_seek(&lfs, &dir, 3) => 0; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_seek(&lfs3, &dir, 3) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; - lfsr_dir_seek(&lfs, &dir, 4) => 0; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_seek(&lfs3, &dir, 4) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; - lfsr_dir_seek(&lfs, &dir, 1000) => 0; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_seek(&lfs3, &dir, 1000) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; // but we should be able to read again - lfsr_dir_rewind(&lfs, &dir) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "ardvark") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test neighbor changes don't mess with an unrelated dir read @@ -330,109 +330,109 @@ defines.SEEK = [0, 1, 2, 3, 4] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // since modification is unrelated, the dir position should go unchanged - lfs_soff_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_soff_t off = lfs3_dir_tell(&lfs3, &dir); assert(off == I+2); // make unrelated dirs if (NEIGHBORS & 0x2) { - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "a_IplRNrPH/a_%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } } if (NEIGHBORS & 0x1) { - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "f_VtoMnwRH/f_%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } } // seek after mkdir? if (SEEK) { // note dir pos after reaching end of dir can be anything - lfs_soff_t off_ = lfsr_dir_tell(&lfs, &dir); + lfs3_soff_t off_ = lfs3_dir_tell(&lfs3, &dir); assert(off_ >= 0); if (I < N) { assert(off_ == off); } if (SEEK == 2 || SEEK == 4) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } if (SEEK == 3 || SEEK == 4) { - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } else { - lfsr_dir_seek(&lfs, &dir, off_) => 0; + lfs3_dir_seek(&lfs3, &dir, off_) => 0; } } // we should be able to keep reading where we left off - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_read_neighbor_rms] @@ -455,119 +455,119 @@ defines.SEEK = [0, 1, 2, 3, 4] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "a_IplRNrPH/a_%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "f_VtoMnwRH/f_%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // since modification is unrelated, the dir position should go unchanged - lfs_soff_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_soff_t off = lfs3_dir_tell(&lfs3, &dir); assert(off == I+2); // remove unrelated dirs if (NEIGHBORS & 0x2) { - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "a_IplRNrPH/a_%03x", i); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } } if (NEIGHBORS & 0x1) { - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "f_VtoMnwRH/f_%03x", i); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } } // seek after mkdir? if (SEEK) { // note dir pos after reaching end of dir can be anything - lfs_soff_t off_ = lfsr_dir_tell(&lfs, &dir); + lfs3_soff_t off_ = lfs3_dir_tell(&lfs3, &dir); assert(off_ >= 0); if (I < N) { assert(off_ == off); } if (SEEK == 2 || SEEK == 4) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } if (SEEK == 3 || SEEK == 4) { - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } else { - lfsr_dir_seek(&lfs, &dir, off_) => 0; + lfs3_dir_seek(&lfs3, &dir, off_) => 0; } } // we should be able to keep reading where we left off - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_read_neighbor_mvs] @@ -590,123 +590,123 @@ defines.SEEK = [0, 1, 2, 3, 4] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "a_IplRNrPH/a_%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "f_VtoMnwRH/f_%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // since modification is unrelated, the dir position should go unchanged - lfs_soff_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_soff_t off = lfs3_dir_tell(&lfs3, &dir); assert(off == I+2); // rename unrelated dirs if (NEIGHBORS & 0x2) { - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "a_IplRNrPH/a_%03x", i); char name_[256]; sprintf(name_, "a_IplRNrPH/b_%03x", i); - lfsr_rename(&lfs, name, name_) => 0; + lfs3_rename(&lfs3, name, name_) => 0; } } if (NEIGHBORS & 0x1) { - for (lfs_size_t i = 0; i < NEIGHBOR_N; i++) { + for (lfs3_size_t i = 0; i < NEIGHBOR_N; i++) { char name[256]; sprintf(name, "f_VtoMnwRH/f_%03x", i); char name_[256]; sprintf(name_, "f_VtoMnwRH/b_%03x", i); - lfsr_rename(&lfs, name, name_) => 0; + lfs3_rename(&lfs3, name, name_) => 0; } } // seek after mkdir? if (SEEK) { // note dir pos after reaching end of dir can be anything - lfs_soff_t off_ = lfsr_dir_tell(&lfs, &dir); + lfs3_soff_t off_ = lfs3_dir_tell(&lfs3, &dir); assert(off_ >= 0); if (I < N) { assert(off_ == off); } if (SEEK == 2 || SEEK == 4) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } if (SEEK == 3 || SEEK == 4) { - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } else { - lfsr_dir_seek(&lfs, &dir, off_) => 0; + lfs3_dir_seek(&lfs3, &dir, off_) => 0; } } // we should be able to keep reading where we left off - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test dir read has somewhat reasonable behaviour when the dir is modified @@ -727,88 +727,88 @@ defines.SEEK = [0, 1, 2] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i+1); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // make a dir at J char name[256]; sprintf(name, "%s/dir%03x_", ((PARENT) ? "pricklypear" : ""), (int)J); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // seek after mkdir? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // we should be able to keep reading, though we may pick up J - for (lfs_size_t i = I + ((I >= J) ? 1 : 0); i < N+1; i++) { + for (lfs3_size_t i = I + ((I >= J) ? 1 : 0); i < N+1; i++) { char name[256]; sprintf(name, "dir%03x%s", i+1 - ((i >= J) ? 1 : 0), (i == J) ? "_" : ""); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_read_with_rms] @@ -828,90 +828,90 @@ defines.SEEK = [0, 1, 2] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // remove the dir at J char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), (int)J); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // seek after remove? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // we should be able to keep reading - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { if (i == J) { continue; } char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_read_with_mvs] @@ -936,56 +936,56 @@ defines.SEEK = [0, 1, 2] # neighbors only make sense if we have a parent if = 'PARENT || NEIGHBORS == 0' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (PARENT >= 2) { - lfsr_mkdir(&lfs, "quiabentia") => 0; + lfs3_mkdir(&lfs3, "quiabentia") => 0; } if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } @@ -999,38 +999,38 @@ code = ''' : ""), ((BEFORE) ? "0" : ""), (int)J); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // seek after remove? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // we should be able to keep reading - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { if (i == J) { continue; } char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(err == LFS_ERR_NOENT || (!BEFORE && PARENT < 2)); - lfsr_dir_close(&lfs, &dir) => 0; + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(err == LFS3_ERR_NOENT || (!BEFORE && PARENT < 2)); + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # dir reads with 2x ops have better chances of catching bugs that depend on @@ -1057,76 +1057,76 @@ if = [ 'PARENT || NEIGHBORS == 0', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i+1); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // make a dir at J char name[256]; sprintf(name, "%s/dir%03x_", ((PARENT) ? "pricklypear" : ""), (int)J); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // make a dir at K sprintf(name, "%s/dir%03x_", ((PARENT) ? "pricklypear" : ""), (int)K); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // seek after mkdir? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // we should be able to keep reading, though we may pick up J - for (lfs_size_t i = I + ((I >= J) ? 1 : 0) + ((I >= K) ? 1 : 0); + for (lfs3_size_t i = I + ((I >= J) ? 1 : 0) + ((I >= K) ? 1 : 0); i < N+2; i++) { char name[256]; @@ -1135,16 +1135,16 @@ code = ''' - (i >= K + ((K >= J) ? 1 : 0) ? 1 : 0), (i == J + ((J > K) ? 1 : 0) || i == K + ((K > J) ? 1 : 0) ? "_" : "")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_read_with_2_rms] @@ -1168,94 +1168,94 @@ if = [ 'PARENT || NEIGHBORS == 0', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // remove the dir at J char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), (int)J); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // remove the dir at K sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), (int)K); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // seek after remove? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // we should be able to keep reading - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { if (i == J || i == K) { continue; } char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_dread_read_with_2_mvs] @@ -1284,56 +1284,56 @@ if = [ 'PARENT || NEIGHBORS == 0', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (PARENT) { - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (PARENT >= 2) { - lfsr_mkdir(&lfs, "quiabentia") => 0; + lfs3_mkdir(&lfs3, "quiabentia") => 0; } if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } @@ -1347,7 +1347,7 @@ code = ''' : ""), ((BEFORE) ? "0" : ""), (int)J); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // rename the dir at K sprintf(old_name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), (int)K); @@ -1357,38 +1357,38 @@ code = ''' : ""), ((BEFORE) ? "0" : ""), (int)K); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // seek after remove? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // we should be able to keep reading - for (lfs_size_t i = I; i < N; i++) { + for (lfs3_size_t i = I; i < N; i++) { if (i == J || i == K) { continue; } char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(err == LFS_ERR_NOENT || (!BEFORE && PARENT < 2)); - lfsr_dir_close(&lfs, &dir) => 0; + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(err == LFS3_ERR_NOENT || (!BEFORE && PARENT < 2)); + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test removing the directory we are iterating over @@ -1404,79 +1404,79 @@ defines.NEIGHBORS = [0x0, 0x1, 0x2, 0x3] # SEEK=2 => rewind then seek defines.SEEK = [0, 1, 2] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "pricklypear/dir%03x", i+1); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "pricklypear") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "pricklypear") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // remove the directory - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "pricklypear/dir%03x", i+1); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } - lfsr_remove(&lfs, "pricklypear") => 0; + lfs3_remove(&lfs3, "pricklypear") => 0; // seek after mkdir? if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // try to read, but this should return an error - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test removing and recreating the directory we are iterating over @@ -1492,96 +1492,96 @@ defines.NEIGHBORS = [0x0, 0x1, 0x2, 0x3] # SEEK=2 => rewind then seek defines.SEEK = [0, 1, 2] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; if (NEIGHBORS & 0x2) { - assert(lfs_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); - lfsr_mkdir(&lfs, "a_IplRNrPH") => 0; - lfsr_mkdir(&lfs, "a_IplRNrPH/a_child") => 0; + assert(lfs3_crc32c(0, "a_IplRNrPH", 10) == 0x00000000); + lfs3_mkdir(&lfs3, "a_IplRNrPH") => 0; + lfs3_mkdir(&lfs3, "a_IplRNrPH/a_child") => 0; } if (NEIGHBORS & 0x1) { - assert(lfs_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); - lfsr_mkdir(&lfs, "f_VtoMnwRH") => 0; - lfsr_mkdir(&lfs, "f_VtoMnwRH/f_child") => 0; + assert(lfs3_crc32c(0, "f_VtoMnwRH", 10) == 0xffffffff); + lfs3_mkdir(&lfs3, "f_VtoMnwRH") => 0; + lfs3_mkdir(&lfs3, "f_VtoMnwRH/f_child") => 0; } // create our directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "pricklypear/dir%03x", i+1); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // start reading - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "pricklypear") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "pricklypear") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // read until I - for (lfs_size_t i = 0; i < I; i++) { + for (lfs3_size_t i = 0; i < I; i++) { char name[256]; sprintf(name, "dir%03x", i+1); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } // remove the directory - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "pricklypear/dir%03x", i+1); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } - lfsr_remove(&lfs, "pricklypear") => 0; + lfs3_remove(&lfs3, "pricklypear") => 0; // recreate the directory, note this is technically a different // directory - lfsr_mkdir(&lfs, "pricklypear") => 0; + lfs3_mkdir(&lfs3, "pricklypear") => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "pricklypear/dir%03x", i+1); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // we should have ended up with the same did, which is what makes // this tricky - lfsr_dir_t dir_; - lfsr_dir_open(&lfs, &dir_, "pricklypear") => 0; + lfs3_dir_t dir_; + lfs3_dir_open(&lfs3, &dir_, "pricklypear") => 0; assert(dir.did == dir_.did); - lfsr_dir_close(&lfs, &dir_) => 0; + lfs3_dir_close(&lfs3, &dir_) => 0; // seek after mkdir? if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } // try to read, but this should return an error - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1605,118 +1605,118 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (PARENT) { - err = lfsr_mkdir(&lfs, "pricklypear"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "pricklypear"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // now remove directories recursively - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); char path[1024]; sprintf(path, "%s/%s", ((PARENT) ? "pricklypear" : ""), info.name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; // seek between removes? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check that our removes worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Recursive here just refers to renaming entries in a directory while @@ -1740,25 +1740,25 @@ if = '!TEST_PLS || N <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (PARENT) { - err = lfsr_mkdir(&lfs, "pricklypear"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "pricklypear"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); if (PARENT >= 2) { - err = lfsr_mkdir(&lfs, "quiabentia"); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, "quiabentia"); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } } // check if we have already started renaming, in case of powerloss - struct lfs_info info; - err = lfsr_stat(&lfs, + struct lfs3_info info; + err = lfs3_stat(&lfs3, ((PARENT == 1) ? ((BEFORE) ? "pricklypear/0mved000" : "pricklypear/mved000") @@ -1768,67 +1768,67 @@ code = ''' : ((BEFORE) ? "/0mved000" : "/mved000")), &info); - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } // now rename directories recursively - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, ((PARENT) ? "pricklypear" : "/")) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0;; i++) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t i = 0;; i++) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); // reached the end? - if (err == LFS_ERR_NOENT) { + if (err == LFS3_ERR_NOENT) { break; } // skip already moved? @@ -1836,7 +1836,7 @@ code = ''' continue; } assert(i < 2*N); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); char old_path[1024]; @@ -1848,28 +1848,28 @@ code = ''' : ""), ((BEFORE) ? "0" : ""), &info.name[strlen("dir")]); - err = lfsr_rename(&lfs, old_path, new_path); - assert(!err || (TEST_PLS && err == LFS_ERR_NOENT)); + err = lfs3_rename(&lfs3, old_path, new_path); + assert(!err || (TEST_PLS && err == LFS3_ERR_NOENT)); // seek between renames? this tests that the internal position is // updated correctly if (SEEK) { - lfs_ssize_t off = lfsr_dir_tell(&lfs, &dir); + lfs3_ssize_t off = lfs3_dir_tell(&lfs3, &dir); assert(off >= 0); if (SEEK >= 2) { - lfsr_dir_rewind(&lfs, &dir) => 0; + lfs3_dir_rewind(&lfs3, &dir) => 0; } - lfsr_dir_seek(&lfs, &dir, off) => 0; + lfs3_dir_seek(&lfs3, &dir, off) => 0; } } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // check that our renames worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%s/dir%03x", ((PARENT) ? "pricklypear" : ""), i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; sprintf(name, "%s/%smved%03x", ((PARENT == 1) ? "pricklypear" @@ -1877,37 +1877,37 @@ code = ''' : ""), ((BEFORE) ? "0" : ""), i); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "%smved%03x", ((BEFORE) ? "0" : ""), i); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_open(&lfs, &dir, + lfs3_dir_open(&lfs3, &dir, ((PARENT == 1) ? "pricklypear" : (PARENT >= 2) ? "quiabentia" : "/")) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "%smved%03x", ((BEFORE) ? "0" : ""), i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_exhaustion.toml b/tests/test_exhaustion.toml index ff8fb2c9..243d4925 100644 --- a/tests/test_exhaustion.toml +++ b/tests/test_exhaustion.toml @@ -25,18 +25,18 @@ after = [ defines.ERASE_CYCLES = 10 defines.BLOCK_RECYCLES = 4 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.SEED = 42 fuzz = 'SEED' -if = 'LFS_IFDEF_CKPROGS(true, !CKPROGS)' +if = 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)' code = ''' // run our test twice, once with 1/2 the storage, once with 2/2 the // storage, and compare how many operations we were able to perform @@ -46,28 +46,28 @@ code = ''' for (int run = 0; run < 2; run++) { // clear any wear from the previous run - for (lfs_block_t i = 0; i < BLOCK_COUNT; i++) { - lfs_emubd_setwear(CFG, i, 0) => 0; + for (lfs3_block_t i = 0; i < BLOCK_COUNT; i++) { + lfs3_emubd_setwear(CFG, i, 0) => 0; } // configure the filesystem size - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = run_bc[run]; // run the test - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), &cfg) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), &cfg) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; for (;; run_ops[run]++) { @@ -76,10 +76,10 @@ code = ''' if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -87,7 +87,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -98,55 +98,55 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -158,56 +158,56 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } } // check our simulation every power-of-2 ops - if (lfs_popc(run_ops[run]) == 1) { + if (lfs3_popc(run_ops[run]) == 1) { // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } dead:; - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // print how many ops printf("run %d, %dx%d, %d ec: %d ops\n", @@ -231,14 +231,14 @@ code = ''' defines.ERASE_CYCLES = 10 defines.BLOCK_RECYCLES = 4 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -252,7 +252,7 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' @@ -264,29 +264,29 @@ code = ''' for (int run = 0; run < 2; run++) { // clear any wear from the previous run - for (lfs_block_t i = 0; i < BLOCK_COUNT; i++) { - lfs_emubd_setwear(CFG, i, 0) => 0; + for (lfs3_block_t i = 0; i < BLOCK_COUNT; i++) { + lfs3_emubd_setwear(CFG, i, 0) => 0; } // configure the filesystem size - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = run_bc[run]; // run the test - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), &cfg) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), &cfg) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; for (;; run_ops[run]++) { @@ -296,12 +296,12 @@ code = ''' // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -310,7 +310,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -325,37 +325,37 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - int err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); + lfs3_file_t file; + int err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); if (err) { goto dead; } - lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; goto dead; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -363,9 +363,9 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } @@ -373,19 +373,19 @@ code = ''' } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -398,7 +398,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -406,7 +406,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -421,74 +421,74 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } } // check our simulation every power-of-2 ops - if (lfs_popc(run_ops[run]) == 1) { + if (lfs3_popc(run_ops[run]) == 1) { // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } } dead:; - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // print how many ops printf("run %d, %dx%d, %d ec: %d ops\n", @@ -512,14 +512,14 @@ code = ''' defines.ERASE_CYCLES = 10 defines.BLOCK_RECYCLES = 4 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.SIZE = [ 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', @@ -538,7 +538,7 @@ defines.SYNC = [false, true] defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', 'CHUNK <= SIZE', # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', @@ -552,130 +552,130 @@ code = ''' for (int run = 0; run < 2; run++) { // clear any wear from the previous run - for (lfs_block_t i = 0; i < BLOCK_COUNT; i++) { - lfs_emubd_setwear(CFG, i, 0) => 0; + for (lfs3_block_t i = 0; i < BLOCK_COUNT; i++) { + lfs3_emubd_setwear(CFG, i, 0) => 0; } // configure the filesystem size - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = run_bc[run]; // run the test - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), &cfg) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), &cfg) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } for (;; run_ops[run]++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfs_ssize_t d = lfsr_file_write(&lfs, &file, &sim[off], chunk); - assert(d == (lfs_ssize_t)chunk || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, &sim[off], chunk); + assert(d == (lfs3_ssize_t)chunk || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { goto dead; } // sync? if (SYNC) { - int err = lfsr_file_sync(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_sync(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } } // check our simulation every power-of-2 ops - if (lfs_popc(run_ops[run]) == 1 && SYNC) { + if (lfs3_popc(run_ops[run]) == 1 && SYNC) { // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "hello", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file_) => size; + lfs3_file_size(&lfs3, &file_) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file_, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file_, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } } dead:; - // clean up sim/lfs - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + // clean up sim/lfs3 + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // print how many ops printf("run %d, %dx%d, %d ec: %d ops\n", @@ -699,14 +699,14 @@ code = ''' defines.ERASE_CYCLES = 10 defines.BLOCK_RECYCLES = 4 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -720,7 +720,7 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' @@ -732,40 +732,40 @@ code = ''' for (int run = 0; run < 2; run++) { // clear any wear from the previous run - for (lfs_block_t i = 0; i < BLOCK_COUNT; i++) { - lfs_emubd_setwear(CFG, i, 0) => 0; + for (lfs3_block_t i = 0; i < BLOCK_COUNT; i++) { + lfs3_emubd_setwear(CFG, i, 0) => 0; } // configure the filesystem size - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = run_bc[run]; // run the test - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), &cfg) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), &cfg) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; for (;; run_ops[run]++) { @@ -779,13 +779,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -799,16 +799,16 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { free(sim_files[j]); goto dead; } @@ -817,14 +817,14 @@ code = ''' if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); goto dead; } @@ -838,7 +838,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -847,7 +847,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -867,27 +867,27 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { goto dead; } - int err = lfsr_file_sync(&lfs, &sim_files[j]->file); - assert(err == 0 || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_sync(&lfs3, &sim_files[j]->file); + assert(err == 0 || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } @@ -895,7 +895,7 @@ code = ''' sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -906,7 +906,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -922,8 +922,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -931,10 +931,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -945,7 +945,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -953,10 +953,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -974,21 +974,21 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -996,7 +996,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1009,9 +1009,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -1020,20 +1020,20 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1049,7 +1049,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1059,7 +1059,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1073,7 +1073,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -1086,83 +1086,83 @@ code = ''' } // check our simulation every power-of-2 ops - if (lfs_popc(run_ops[run]) == 1) { + if (lfs3_popc(run_ops[run]) == 1) { // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } @@ -1170,17 +1170,17 @@ code = ''' } dead:; - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // print how many ops printf("run %d, %dx%d, %d ec: %d ops\n", @@ -1204,14 +1204,14 @@ code = ''' defines.ERASE_CYCLES = 10 defines.BLOCK_RECYCLES = 4 defines.BADBLOCK_BEHAVIOR = [ - 'LFS_EMUBD_BADBLOCK_PROGERROR', - 'LFS_EMUBD_BADBLOCK_ERASEERROR', - 'LFS_EMUBD_BADBLOCK_READERROR', - 'LFS_EMUBD_BADBLOCK_PROGNOOP', - 'LFS_EMUBD_BADBLOCK_ERASENOOP', + 'LFS3_EMUBD_BADBLOCK_PROGERROR', + 'LFS3_EMUBD_BADBLOCK_ERASEERROR', + 'LFS3_EMUBD_BADBLOCK_READERROR', + 'LFS3_EMUBD_BADBLOCK_PROGNOOP', + 'LFS3_EMUBD_BADBLOCK_ERASENOOP', ] # we need prog checking to detect read errors -defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS_EMUBD_BADBLOCK_READERROR' +defines.CKPROGS = 'BADBLOCK_BEHAVIOR >= LFS3_EMUBD_BADBLOCK_READERROR' defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ '0', @@ -1225,7 +1225,7 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = [ - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', '(SIZE*N)/BLOCK_SIZE <= 16', ] code = ''' @@ -1237,41 +1237,41 @@ code = ''' for (int run = 0; run < 2; run++) { // clear any wear from the previous run - for (lfs_block_t i = 0; i < BLOCK_COUNT; i++) { - lfs_emubd_setwear(CFG, i, 0) => 0; + for (lfs3_block_t i = 0; i < BLOCK_COUNT; i++) { + lfs3_emubd_setwear(CFG, i, 0) => 0; } // configure the filesystem size - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = run_bc[run]; // run the test - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0), &cfg) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0), + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0), &cfg) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; for (;; run_ops[run]++) { @@ -1285,13 +1285,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -1308,16 +1308,16 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { free(sim_files[j]); goto dead; } @@ -1326,14 +1326,14 @@ code = ''' if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); goto dead; } @@ -1347,7 +1347,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1356,7 +1356,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1379,27 +1379,27 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { goto dead; } - int err = lfsr_file_sync(&lfs, &sim_files[j]->file); - assert(err == 0 || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_sync(&lfs3, &sim_files[j]->file); + assert(err == 0 || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } @@ -1407,7 +1407,7 @@ code = ''' sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -1418,7 +1418,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -1434,19 +1434,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -1457,7 +1457,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -1465,10 +1465,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -1488,21 +1488,21 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1512,7 +1512,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1525,14 +1525,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -1550,20 +1550,20 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1582,7 +1582,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1594,7 +1594,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1611,7 +1611,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -1625,9 +1625,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1640,18 +1640,18 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto dead; } // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1667,7 +1667,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1675,98 +1675,98 @@ code = ''' } // check our simulation every power-of-2 ops - if (lfs_popc(run_ops[run]) == 1) { + if (lfs3_popc(run_ops[run]) == 1) { // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } @@ -1774,18 +1774,18 @@ code = ''' } dead:; - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // print how many ops printf("run %d, %dx%d, %d ec: %d ops\n", diff --git a/tests/test_files.toml b/tests/test_files.toml index d079fc75..3e109cbe 100644 --- a/tests/test_files.toml +++ b/tests/test_files.toml @@ -5,651 +5,651 @@ after = ['test_dirs', 'test_btree'] # test creation/deletion [cases.test_files_create] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_size(&lfs3, &file) => 0; // try reading uint8_t rbuf[8192]; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can write some data, should be inlined [cases.test_files_hello] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Hello World!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can rewrite a file [cases.test_files_trunc] defines.REMOUNT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Oh no!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rewrite the file - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; strcpy((char*)wbuf, "Hello World!"); wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # check for ENOENT errors [cases.test_files_noent] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try to open a file that doesn't exist, this should error - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDWR) => LFS3_ERR_NOENT; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // make sure open didn't quietly create a file // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => LFS3_ERR_NOENT; // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => LFS3_ERR_NOENT; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # check for EEXIST errors [cases.test_files_excl] defines.REMOUNT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Hello World!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try to recreate file, this should error - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # a file is not a directory [cases.test_files_file_not_dir] defines.REMOUNT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Hello World!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // try to open our file as a directory - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "hello") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "hello") => LFS3_ERR_NOTDIR; // try to create a directory on top of our file - lfsr_mkdir(&lfs, "hello") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "hello") => LFS3_ERR_EXIST; // try to rename a directory onto our file - lfsr_mkdir(&lfs, "not_hello") => 0; - lfsr_rename(&lfs, "not_hello", "hello") => LFS_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "not_hello") => 0; + lfs3_rename(&lfs3, "not_hello", "hello") => LFS3_ERR_NOTDIR; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "not_hello") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # a directory is not a file [cases.test_files_dir_not_file] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a directory - lfsr_mkdir(&lfs, "hello") => 0; + lfs3_mkdir(&lfs3, "hello") => 0; // try reading our directory as a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => LFS3_ERR_ISDIR; // try writing our directory as a file - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_TRUNC) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_TRUNC) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => LFS3_ERR_ISDIR; // try rename a file on top of our directory - lfsr_file_open(&lfs, &file, "not_hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "not_hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Hello World!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_rename(&lfs, "not_hello", "hello") => LFS_ERR_ISDIR; + lfs3_rename(&lfs3, "not_hello", "hello") => LFS3_ERR_ISDIR; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our dir with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "not_hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // did we corrupt our renaming file? // try reading our file - lfsr_file_open(&lfs, &file, "not_hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "not_hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # root is also not a file [cases.test_files_root_not_file] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try reading our root as a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/", LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/", LFS3_O_RDONLY) => LFS3_ERR_ISDIR; // try writing our root as a file - lfsr_file_open(&lfs, &file, "/", LFS_O_WRONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_TRUNC) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/", LFS3_O_WRONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_TRUNC) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => LFS3_ERR_ISDIR; // try rename a file on top of our directory - lfsr_file_open(&lfs, &file, "not_hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "not_hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Hello World!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_rename(&lfs, "not_hello", "/") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "not_hello", "/") => LFS3_ERR_INVAL; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our root with stat - struct lfs_info info; - lfsr_stat(&lfs, "/", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "not_hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // did we corrupt our renaming file? // try reading our file - lfsr_file_open(&lfs, &file, "not_hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "not_hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # an invalid path is also not a file (kind of?) [cases.test_files_noent_not_file] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try reading our invalid path as a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "no/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "no/hello", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // try writing our root as a file - lfsr_file_open(&lfs, &file, "no/hello", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "no/hello", - LFS_O_WRONLY | LFS_O_TRUNC) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "no/hello", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "no/hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "no/hello", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "no/hello", + LFS3_O_WRONLY | LFS3_O_TRUNC) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "no/hello", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "no/hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => LFS3_ERR_NOENT; // try rename a file on top of our invalid path - lfsr_file_open(&lfs, &file, "not_hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "not_hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Hello World!"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_rename(&lfs, "not_hello", "no/hello") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "not_hello", "no/hello") => LFS3_ERR_NOENT; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our root with stat - struct lfs_info info; - lfsr_stat(&lfs, "/", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "not_hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // did we corrupt our renaming file? // try reading our file - lfsr_file_open(&lfs, &file, "not_hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "not_hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # try writing larger files @@ -671,66 +671,66 @@ defines.SIZE = [ ] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test creating multiple files @@ -754,21 +754,21 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } @@ -776,52 +776,52 @@ code = ''' // // file may exist from a previous run, but we need to check // for pesky zero-sized files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_ssize_t size = lfsr_file_size(&lfs, &file); + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_ssize_t size = lfs3_file_size(&lfs3, &file); assert(size == 0 || size == SIZE); if (size == 0) { - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz test file creation @@ -842,24 +842,24 @@ defines.SEED = 'range(20)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -868,7 +868,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -883,81 +883,81 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -965,375 +965,375 @@ code = ''' # able to read them if created by another impl [cases.test_files_zero_bnull] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // delete any bshrub/btree - lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, 0))) => 0; + lfs3_mdir_commit(&lfs3, &file.b.o.mdir, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, 0))) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_size(&lfs3, &file) => 0; // try reading uint8_t rbuf[8192]; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // try writing to said file - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Does this work?"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_files_zero_bshrub] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // create an empty bshrub - lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUBCOMMIT( - (&(lfsr_shrubcommit_t){ + lfs3_mdir_commit(&lfs3, &file.b.o.mdir, LFS3_RATTRS( + LFS3_RATTR_SHRUBCOMMIT( + (&(lfs3_shrubcommit_t){ .bshrub=&file.b, .rid=0, - .rattrs=((lfsr_rattr_t[]){ - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "?", 1)}), + .rattrs=((lfs3_rattr_t[]){ + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "?", 1)}), .rattr_count=1})))) => 0; - lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUBCOMMIT( - (&(lfsr_shrubcommit_t){ + lfs3_mdir_commit(&lfs3, &file.b.o.mdir, LFS3_RATTRS( + LFS3_RATTR_SHRUBCOMMIT( + (&(lfs3_shrubcommit_t){ .bshrub=&file.b, .rid=0, - .rattrs=((lfsr_rattr_t[]){ - LFSR_RATTR(LFSR_TAG_RM, -1)}), + .rattrs=((lfs3_rattr_t[]){ + LFS3_RATTR(LFS3_TAG_RM, -1)}), .rattr_count=1})))) => 0; - lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUB( - LFSR_TAG_MASK8 | LFSR_TAG_BSHRUB, 0, + lfs3_mdir_commit(&lfs3, &file.b.o.mdir, LFS3_RATTRS( + LFS3_RATTR_SHRUB( + LFS3_TAG_MASK8 | LFS3_TAG_BSHRUB, 0, &file.b.shrub_))) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_size(&lfs3, &file) => 0; // try reading uint8_t rbuf[8192]; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // try writing to said file - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Does this work?"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_files_zero_btree] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // create an empty btree - lfs_alloc_ckpoint(&lfs); - lfsr_rbyd_alloc(&lfs, &file.b.shrub) => 0; - lfsr_rbyd_commit(&lfs, &file.b.shrub, 0, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, "?", 1))) => 0; - lfsr_rbyd_commit(&lfs, &file.b.shrub, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_BTREE( - LFSR_TAG_MASK8 | LFSR_TAG_BTREE, 0, + lfs3_alloc_ckpoint(&lfs3); + lfs3_rbyd_alloc(&lfs3, &file.b.shrub) => 0; + lfs3_rbyd_commit(&lfs3, &file.b.shrub, 0, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "?", 1))) => 0; + lfs3_rbyd_commit(&lfs3, &file.b.shrub, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &file.b.o.mdir, LFS3_RATTRS( + LFS3_RATTR_BTREE( + LFS3_TAG_MASK8 | LFS3_TAG_BTREE, 0, &file.b.shrub))) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_size(&lfs3, &file) => 0; // try reading uint8_t rbuf[8192]; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // try writing to said file - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; uint8_t wbuf[8192]; strcpy((char*)wbuf, "Does this work?"); - lfs_size_t wsize = strlen((const char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((const char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => wsize; + lfs3_file_size(&lfs3, &file) => wsize; // try reading uint8_t rbuf[8192]; memset(rbuf, 0xaa, sizeof(rbuf)); - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) => wsize; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => wsize; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1355,57 +1355,57 @@ defines.SIZE = [ defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // remove our file - lfsr_remove(&lfs, "amethyst") => 0; + lfs3_remove(&lfs3, "amethyst") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => LFS3_ERR_NOENT; // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test creating and deleting multiple files @@ -1432,21 +1432,21 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } @@ -1454,67 +1454,67 @@ code = ''' // // file may exist from a previous run, but we need to check // for pesky zero-sized files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_ssize_t size = lfsr_file_size(&lfs, &file); + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_ssize_t size = lfs3_file_size(&lfs3, &file); assert(size == 0 || size == SIZE); if (size == 0) { - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // now remove some number of files - for (lfs_size_t i = 0; i < N-REMAINING; i++) { + for (lfs3_size_t i = 0; i < N-REMAINING; i++) { char name[256]; sprintf(name, "amethyst%03x", i); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our removes worked @@ -1522,45 +1522,45 @@ code = ''' // note we need to keep the prng in sync // prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); // keep prng in sync uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } if (i < N-REMAINING) { // check with stat - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; // and try to open - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_NOENT; } else { // check with stat - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz test file creation and deletion @@ -1581,29 +1581,29 @@ defines.SEED = 'range(20)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 2; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -1612,7 +1612,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -1627,24 +1627,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -1652,74 +1652,74 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming files of various sizes @@ -1737,90 +1737,90 @@ defines.N = [0, 128] defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a number of directories to distance our files - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; sprintf(path, "basalt%03x", i); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the file - lfsr_rename(&lfs, "amethyst", "calcite") => 0; + lfs3_rename(&lfs3, "amethyst", "calcite") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "calcite", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "calcite", &info) => 0; assert(strcmp(info.name, "calcite") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; sprintf(path, "basalt%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, path) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "calcite") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "calcite", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "calcite", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming files of various sizes over existing files @@ -1838,100 +1838,100 @@ defines.N = [0, 128] defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a number of directories to distance our files - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; sprintf(path, "basalt%03x", i); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create another file - lfsr_file_open(&lfs, &file, "calcite", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &file, "calcite", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf_[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf_[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf_, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf_, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the file - lfsr_rename(&lfs, "amethyst", "calcite") => 0; + lfs3_rename(&lfs3, "amethyst", "calcite") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "calcite", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "calcite", &info) => 0; assert(strcmp(info.name, "calcite") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char path[256]; sprintf(path, "basalt%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, path) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "calcite") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "calcite", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "calcite", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming a file to itself @@ -1948,75 +1948,75 @@ defines.SIZE = [ defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the file - lfsr_rename(&lfs, "amethyst", "amethyst") => 0; + lfs3_rename(&lfs3, "amethyst", "amethyst") => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming a file onto a dir @@ -2033,86 +2033,86 @@ defines.SIZE = [ defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create a dir - lfsr_mkdir(&lfs, "basalt") => 0; + lfs3_mkdir(&lfs3, "basalt") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the file - lfsr_rename(&lfs, "amethyst", "basalt") => LFS_ERR_ISDIR; + lfs3_rename(&lfs3, "amethyst", "basalt") => LFS3_ERR_ISDIR; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that nothing changed in our file/dir with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, "basalt", &info) => 0; + lfs3_stat(&lfs3, "basalt", &info) => 0; assert(strcmp(info.name, "basalt") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "basalt") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming a dir onto a file @@ -2129,86 +2129,86 @@ defines.SIZE = [ defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create a dir - lfsr_mkdir(&lfs, "basalt") => 0; + lfs3_mkdir(&lfs3, "basalt") => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the dir - lfsr_rename(&lfs, "basalt", "amethyst") => LFS_ERR_NOTDIR; + lfs3_rename(&lfs3, "basalt", "amethyst") => LFS3_ERR_NOTDIR; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that nothing changed in our file/dir with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, "basalt", &info) => 0; + lfs3_stat(&lfs3, "basalt", &info) => 0; assert(strcmp(info.name, "basalt") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "basalt") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming a file onto root @@ -2225,75 +2225,75 @@ defines.SIZE = [ defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the file - lfsr_rename(&lfs, "amethyst", "/") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "amethyst", "/") => LFS3_ERR_INVAL; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that nothing changed in our file/dir with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming a file onto an invalid path @@ -2310,75 +2310,75 @@ defines.SIZE = [ defines.REMOUNT = [false, true] defines.FILE_CACHE_SIZE = 64 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_WRONLY | LFS3_O_CREAT) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // rename the file - lfsr_rename(&lfs, "amethyst", "no/amethyst") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "amethyst", "no/amethyst") => LFS3_ERR_NOENT; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that nothing changed in our file/dir with stat - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "amethyst") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "amethyst", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "amethyst", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming multiple files @@ -2403,21 +2403,21 @@ if = [ reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } @@ -2425,102 +2425,102 @@ code = ''' // // file may exist from a previous run, but we need to check // for pesky zero-sized files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_ssize_t size = lfsr_file_size(&lfs, &file); + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_ssize_t size = lfs3_file_size(&lfs3, &file); assert(size == 0 || size == SIZE); if (size == 0) { - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // now rename our files - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char old_name[256]; sprintf(old_name, "amethyst%03x", i); char new_name[256]; sprintf(new_name, "basalt%03x", i); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our renames worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; sprintf(name, "basalt%03x", i); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # one particularly nasty case is renaming over an mdir split, since shrubs @@ -2542,66 +2542,66 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files while renaming uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // always create as first file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "amethyst", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "amethyst", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // rename! char name[256]; sprintf(name, "basalt%03x", i); - lfsr_rename(&lfs, "amethyst", name) => 0; + lfs3_rename(&lfs3, "amethyst", name) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that renames worked prng = 42; - struct lfs_info info; - lfsr_stat(&lfs, "amethyst", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + struct lfs3_info info; + lfs3_stat(&lfs3, "amethyst", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "basalt%03x", i); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_files_mv_split_backwards] @@ -2617,66 +2617,66 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files while renaming uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // always create as last file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cobalt", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cobalt", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // rename! char name[256]; sprintf(name, "basalt%03x", (uint32_t)(N-1-i)); - lfsr_rename(&lfs, "cobalt", name) => 0; + lfs3_rename(&lfs3, "cobalt", name) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that renames worked prng = 42; - struct lfs_info info; - lfsr_stat(&lfs, "cobalt", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + struct lfs3_info info; + lfs3_stat(&lfs3, "cobalt", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "basalt%03x", (uint32_t)(N-1-i)); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -2698,29 +2698,29 @@ defines.SEED = 'range(20)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 2; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2729,7 +2729,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -2744,33 +2744,33 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2783,7 +2783,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -2791,7 +2791,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -2806,74 +2806,74 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -2895,29 +2895,29 @@ defines.SEED = 'range(20)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2926,7 +2926,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -2941,24 +2941,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2966,25 +2966,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2997,7 +2997,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -3005,7 +3005,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -3020,74 +3020,74 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -3118,65 +3118,66 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDWR | LFS_O_CREAT) => 0; - lfs_ssize_t d = lfsr_file_read(&lfs, &state_file, &state, sizeof(state)); + lfs3_file_t state_file; + lfs3_file_open(&lfs3, &state_file, + "state", LFS3_O_RDWR | LFS3_O_CREAT) => 0; + lfs3_ssize_t d = lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)); assert(d == 0 || d == sizeof(state)); // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST); + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST); uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 0 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; uint32_t wprng = TEST_PRNG(&prng); // create a file here @@ -3184,7 +3185,7 @@ code = ''' sprintf(name, "test/amethyst%03x", x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -3193,45 +3194,45 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "test/%s", info.name); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % count; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t y = TEST_PRNG(&prng) % N; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this file char old_name[256]; @@ -3239,74 +3240,74 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // update our state file state.i = i; state.prng = prng; - lfsr_file_rewind(&lfs, &state_file) => 0; - lfsr_file_write(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_rewind(&lfs3, &state_file) => 0; + lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_sync(&lfs, &state_file) => 0; + lfs3_file_sync(&lfs3, &state_file) => 0; } // go ahead and close our state file in case we remount - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // at least try to read the files char name[256]; sprintf(name, "test/%s", info.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_fsync.toml b/tests/test_fsync.toml index 725bbe7e..fb84789a 100644 --- a/tests/test_fsync.toml +++ b/tests/test_fsync.toml @@ -5,1031 +5,1031 @@ after = 'test_fwrite' # Some specific tests [cases.test_fsync_sync_wrr] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - reader kept open, recvs updates from a // c - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_RDONLY) => 0; // write to a - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); // should not show up in b yet - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => 0; // or on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &c) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // lets rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // b should still have previous contents - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // lets rewrite a one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // b should still have previous contents - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // now our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; - lfsr_file_close(&lfs, &b) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &b) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected +# test that LFS3_O_SYNC/LFS3_O_FLUSH flags work as expected [cases.test_fsync_sync_o_wsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - writer // b - reader kept open, recvs updates from a // c - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_RDONLY) => 0; // write to a - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); // should immediately show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // lets rewrite a one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // should immediately show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; - lfsr_file_close(&lfs, &b) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &b) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_sync_wwrr] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - writer // c - reader kept open, recvs updates from a/b // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and b - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should not show up in c yet - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // or on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b's contents were clobbered, so we should see a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // now our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite a one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // now our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected +# test that LFS3_O_SYNC/LFS3_O_FLUSH flags work as expected [cases.test_fsync_sync_o_wswsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - synced writer // b - synced writer // c - reader kept open, recvs updates from a/b // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &b, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); // should immediately show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // write to b - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a's contents were clobbered, so we should see b - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a's contents were clobbered, so we should see b - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite a one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // should still have a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test one non-LFS_O_SYNC and one LFS_O_SYNC +# test one non-LFS3_O_SYNC and one LFS3_O_SYNC [cases.test_fsync_sync_o_wwsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - writer // b - synced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; + lfs3_file_open(&lfs3, &b, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); // write to b - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - // reopen a with LFS_O_TRUNC - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_TRUNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + // reopen a with LFS3_O_TRUNC + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_TRUNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - // reopen LFS_O_WRONLY and rewrite a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + // reopen LFS3_O_WRONLY and rewrite a + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite a and b one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "moshimoshi!", strlen("moshimoshi!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "moshimoshi!", strlen("moshimoshi!")) => strlen("moshimoshi!"); - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "czesc!", strlen("czesc!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "czesc!", strlen("czesc!")) => strlen("czesc!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // should still have b - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_sync_wwrr_zero] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - writer // c - reader kept open, recvs updates from a/b // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and b - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should not show up in c yet - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // or on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // truncate b, this gets tricky as we no longer have a struct - lfsr_file_truncate(&lfs, &b, 0) => 0; + lfs3_file_truncate(&lfs3, &b, 0) => 0; // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // now our truncate should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // now our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // truncate a one last time - lfsr_file_truncate(&lfs, &a, 0) => 0; + lfs3_file_truncate(&lfs3, &a, 0) => 0; // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // now our truncate should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_sync_wwrr_noop] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - writer // c - reader kept open, recvs updates from a/b // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and b - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should not show up in c yet - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // or on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b's contents were clobbered, so we should see a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a, this may be tricky since we haven't touched b - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b, this may be tricky since we haven't touched b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b's contents were clobbered, so we should see a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite b one last time, this time with sync - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // now our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_sync_wwrr_append] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - writer // c - reader kept open, recvs updates from a/b // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_APPEND) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY | LFS_O_APPEND) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_APPEND) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY | LFS3_O_APPEND) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and b - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should not show up in c yet - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // or on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b's contents were clobbered, so we should see a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // now our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite a one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // now our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!zdrasti!"); assert(memcmp(rbuf, "hello!ohayo!zdrasti!", strlen("hello!ohayo!zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!zdrasti!"); assert(memcmp(rbuf, "hello!ohayo!zdrasti!", strlen("hello!ohayo!zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1046,40 +1046,40 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // read R handles in parallel - lfsr_file_t readers[R]; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t readers[R]; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t r = 0; r < R; r++) { uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; assert(memcmp(rbuf, &before[i], CHUNK) == 0); } } - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_rrrr_fuzz] @@ -1097,60 +1097,60 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = SEED; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // read R handles in parallel - lfsr_file_t readers[R]; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t readers[R]; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < N; i++) { - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t i = 0; i < N; i++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; assert(memcmp(rbuf, &before[off], size) == 0); } } - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test one writer, multiple readers [cases.test_fsync_wrrr] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -1162,56 +1162,56 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writer, wbuf, CHUNK) => CHUNK; memcpy(&after[i], wbuf, CHUNK); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; if (SYNC == 0) { assert(memcmp(rbuf, &before[i], CHUNK) == 0); } else { @@ -1219,32 +1219,32 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_wrrr_fuzz] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.N = 20 defines.SIZE = [ @@ -1259,68 +1259,68 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writer, off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writer, off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, size) => size; + lfs3_file_write(&lfs3, &writer, wbuf, size) => size; memcpy(&after[off], wbuf, size); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; if (SYNC == 0) { assert(memcmp(rbuf, &before[off], size) == 0); } else { @@ -1328,33 +1328,33 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple writers [cases.test_fsync_wwww] defines.W = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -1366,84 +1366,84 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write W handles in parallel - lfsr_file_t writers[W]; - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_open(&lfs, &writers[w], "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t writers[W]; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_open(&lfs3, &writers[w], "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t w = 0; w < W; w++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t w = 0; w < W; w++) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writers[w], wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writers[w], wbuf, CHUNK) => CHUNK; if (SYNC == 0) { if (w == 0) { memcpy(&after[i], wbuf, CHUNK); } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writers[w]) => 0; + lfs3_file_flush(&lfs3, &writers[w]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writers[w]) => 0; + lfs3_file_sync(&lfs3, &writers[w]) => 0; } memcpy(&after[i], wbuf, CHUNK); } } } - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_close(&lfs, &writers[w]) => 0; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_close(&lfs3, &writers[w]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_wwww_fuzz] defines.W = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.N = 20 defines.SIZE = [ @@ -1458,77 +1458,77 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write W files in parallel - lfsr_file_t writers[W]; - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_open(&lfs, &writers[w], "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t writers[W]; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_open(&lfs3, &writers[w], "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t w = 0; w < W; w++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t w = 0; w < W; w++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writers[w], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writers[w], off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writers[w], wbuf, size) => size; + lfs3_file_write(&lfs3, &writers[w], wbuf, size) => size; if (SYNC == 0) { if (w == 0) { memcpy(&after[off], wbuf, size); } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writers[w]) => 0; + lfs3_file_flush(&lfs3, &writers[w]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writers[w]) => 0; + lfs3_file_sync(&lfs3, &writers[w]) => 0; } memcpy(&after[off], wbuf, size); } } } - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_close(&lfs, &writers[w]) => 0; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_close(&lfs3, &writers[w]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple writers and multiple readers @@ -1536,14 +1536,14 @@ code = ''' defines.W = 4 defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -1555,65 +1555,65 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write W handles, R handles in parallel - lfsr_file_t writers[W]; - lfsr_file_t readers[R]; - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_open(&lfs, &writers[w], "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t writers[W]; + lfs3_file_t readers[R]; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_open(&lfs3, &writers[w], "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t w = 0; w < W; w++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t w = 0; w < W; w++) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writers[w], wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writers[w], wbuf, CHUNK) => CHUNK; if (SYNC == 0) { if (w == 0) { memcpy(&after[i], wbuf, CHUNK); } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writers[w]) => 0; + lfs3_file_flush(&lfs3, &writers[w]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writers[w]) => 0; + lfs3_file_sync(&lfs3, &writers[w]) => 0; } memcpy(&after[i], wbuf, CHUNK); } } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; if (SYNC == 0) { assert(memcmp(rbuf, &before[i], CHUNK) == 0); } else { @@ -1621,35 +1621,35 @@ code = ''' } } } - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_close(&lfs, &writers[w]) => 0; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_close(&lfs3, &writers[w]) => 0; } - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_wwrr_fuzz] defines.W = 4 defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.N = 20 defines.SIZE = [ @@ -1664,77 +1664,77 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write W files in parallel - lfsr_file_t writers[W]; - lfsr_file_t readers[R]; - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_open(&lfs, &writers[w], "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t writers[W]; + lfs3_file_t readers[R]; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_open(&lfs3, &writers[w], "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t w = 0; w < W; w++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t w = 0; w < W; w++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writers[w], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writers[w], off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writers[w], wbuf, size) => size; + lfs3_file_write(&lfs3, &writers[w], wbuf, size) => size; if (SYNC == 0) { if (w == 0) { memcpy(&after[off], wbuf, size); } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writers[w]) => 0; + lfs3_file_flush(&lfs3, &writers[w]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writers[w]) => 0; + lfs3_file_sync(&lfs3, &writers[w]) => 0; } memcpy(&after[off], wbuf, size); } } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; if (SYNC == 0) { assert(memcmp(rbuf, &before[off], size) == 0); } else { @@ -1742,35 +1742,35 @@ code = ''' } } } - for (lfs_size_t w = 0; w < W; w++) { - lfsr_file_close(&lfs, &writers[w]) => 0; + for (lfs3_size_t w = 0; w < W; w++) { + lfs3_file_close(&lfs3, &writers[w]) => 0; } - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple rd/wrers [cases.test_fsync_rwrw] defines.RW = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -1782,49 +1782,49 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t between[RW][SIZE]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { memcpy(between[rw], before, SIZE); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &rdwrs[rw], i, LFS_SEEK_SET) => i; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &rdwrs[rw], i, LFS3_SEEK_SET) => i; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, CHUNK) => CHUNK; memcpy(&between[rw][i], wbuf, CHUNK); if (SYNC == 0) { if (rw == 0) { @@ -1832,18 +1832,18 @@ code = ''' } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } memcpy(&after[i], wbuf, CHUNK); } } - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_seek(&lfs, &rdwrs[rw], i, LFS_SEEK_SET) => i; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_seek(&lfs3, &rdwrs[rw], i, LFS3_SEEK_SET) => i; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => CHUNK; if (SYNC == 0) { assert(memcmp(rbuf, &between[rw][i], CHUNK) == 0); } else { @@ -1851,31 +1851,31 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_rwrw_fuzz] defines.RW = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.N = 20 defines.SIZE = [ @@ -1890,54 +1890,54 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t between[RW][SIZE]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { memcpy(between[rw], before, SIZE); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; memcpy(&between[rw][off], wbuf, size); if (SYNC == 0) { if (rw == 0) { @@ -1945,23 +1945,23 @@ code = ''' } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } memcpy(&after[off], wbuf, size); } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; if (SYNC == 0) { assert(memcmp(rbuf, &between[rw][off], size) == 0); } else { @@ -1969,32 +1969,32 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple rw files without fixed size [cases.test_fsync_rwrw_sparse_fuzz] defines.RW = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.N = 40 defines.SIZE = [ @@ -2009,58 +2009,58 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(100)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; uint32_t prng = 42; uint8_t between[RW][SIZE]; - lfs_size_t between_size[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_size_t between_size[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { between_size[rw] = 0; } uint8_t after[SIZE]; - lfs_size_t after_size = 0; + lfs3_size_t after_size = 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { // open files - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_CREAT - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_CREAT + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 2; // writing? if (op == 0) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } // write - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } // update sim @@ -2070,20 +2070,20 @@ code = ''' off - between_size[rw]); } memcpy(&between[rw][off], wbuf, size); - between_size[rw] = lfs_max(off + size, between_size[rw]); + between_size[rw] = lfs3_max(off + size, between_size[rw]); // reading? } else if (op == 1) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, between_size[rw] - off); + lfs3_size_t size = lfs3_min(CHUNK, between_size[rw] - off); // read - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; assert(memcmp(rbuf, &between[rw][off], size) == 0); } @@ -2092,50 +2092,50 @@ code = ''' memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; } } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // close files - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; // broadcast sim one last time? memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; } } // check that file was written as expected - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => after_size; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => after_size; assert(memcmp(rbuf, after, after_size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple rw files while also truncating/fruncating [cases.test_fsync_rwtfrwtf_sparse_fuzz] defines.RW = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [0, 1, 2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 1, 2, 3] defines.N = 40 defines.SIZE = [ @@ -2150,35 +2150,35 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(100)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; uint32_t prng = 42; uint8_t between[RW][SIZE]; - lfs_size_t between_size[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_size_t between_size[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { between_size[rw] = 0; } uint8_t after[SIZE]; - lfs_size_t after_size = 0; + lfs3_size_t after_size = 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { // open files - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_CREAT - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_CREAT + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 4; bool broadcast = false; @@ -2186,23 +2186,23 @@ code = ''' // writing? if (op == 0) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } // write - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } // update sim @@ -2212,7 +2212,7 @@ code = ''' off - between_size[rw]); } memcpy(&between[rw][off], wbuf, size); - between_size[rw] = lfs_max(off + size, between_size[rw]); + between_size[rw] = lfs3_max(off + size, between_size[rw]); if (SYNC) { broadcast = true; } @@ -2220,29 +2220,29 @@ code = ''' // reading? } else if (op == 1) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, between_size[rw] - off); + lfs3_size_t size = lfs3_min(CHUNK, between_size[rw] - off); // read - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; assert(memcmp(rbuf, &between[rw][off], size) == 0); // truncating? } else if (op == 2) { // choose a random new file size - lfs_off_t size = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size = TEST_PRNG(&prng) % SIZE; // truncate - lfsr_file_truncate(&lfs, &rdwrs[rw], size) => 0; + lfs3_file_truncate(&lfs3, &rdwrs[rw], size) => 0; if (FLUSH == 1) { // (flush does nothing) - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } // update the sim @@ -2252,7 +2252,7 @@ code = ''' size - between_size[rw]); } between_size[rw] = size; - // note LFS_O_SYNC does _not_ sync truncates + // note LFS3_O_SYNC does _not_ sync truncates if (SYNC == 1) { broadcast = true; } @@ -2260,15 +2260,15 @@ code = ''' // fruncating? } else if (op == 3) { // choose a random new file size - lfs_off_t size = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size = TEST_PRNG(&prng) % SIZE; // fruncate - lfsr_file_fruncate(&lfs, &rdwrs[rw], size) => 0; + lfs3_file_fruncate(&lfs3, &rdwrs[rw], size) => 0; if (FLUSH == 1) { // (flush does nothing) - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } // update the sim @@ -2285,7 +2285,7 @@ code = ''' size); } between_size[rw] = size; - // note LFS_O_SYNC does _not_ sync fruncates + // note LFS3_O_SYNC does _not_ sync fruncates if (SYNC == 1) { broadcast = true; } @@ -2296,36 +2296,36 @@ code = ''' memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; } } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // close files - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; // broadcast sim one last time? memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; } } // check that file was written as expected - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => after_size; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => after_size; assert(memcmp(rbuf, after, after_size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -2334,1040 +2334,1040 @@ code = ''' # Some specific tests [cases.test_fsync_desync_wdrr] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - desynced writer // b - reader kept open, recvs updates from a // c - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // now mark as desync, rewrite, and close - lfsr_file_desync(&lfs, &a) => 0; - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_desync(&lfs3, &a) => 0; + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // b should still have previous contents - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // reopen a, mark as desync, rewrite a, and sync - lfsr_file_open(&lfs, &a, "jello", LFS_O_WRONLY) => 0; - lfsr_file_desync(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_open(&lfs3, &a, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_desync(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // this sync should clear the desync - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // now our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // rewrite a, close, desync flag should have been cleared - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; - lfsr_file_close(&lfs, &b) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &b) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_desync_wrrd] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - reader kept open, recvs updates from a // c - desynced reader - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // but not in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // reopen c, should now be up to date - lfsr_file_close(&lfs, &c) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY | LFS_O_DESYNC) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_close(&lfs3, &c) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // rewrite and sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // but not in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // reopen c, should now be up to date - lfsr_file_close(&lfs, &c) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY | LFS_O_DESYNC) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_close(&lfs3, &c) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // rewrite and close - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // but not in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // reopen c, should now be up to date - lfsr_file_close(&lfs, &c) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY | LFS_O_DESYNC) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_close(&lfs3, &c) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &b) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &b) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_desync_wwdrr] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, rewrite, and close - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // reopen b, mark as desync, rewrite - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // rewrite a, sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b should show up in c, without a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b, close, desync flag should have been cleared - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a, close - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "czesc!", strlen("czesc!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "czesc!", strlen("czesc!")) => strlen("czesc!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected +# test that LFS3_O_SYNC/LFS3_O_FLUSH flags work as expected [cases.test_fsync_desync_o_wsdwsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - desynced writer // b - writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0) - | LFS_O_DESYNC) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0) + | LFS3_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &b, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to b - lfsr_file_write(&lfs, &b, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &b, "hello!", strlen("hello!")) => strlen("hello!"); // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // should still have a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // reopen a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0) - | LFS_O_DESYNC) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0) + | LFS3_O_DESYNC) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // desync a - lfsr_file_desync(&lfs, &a) => 0; + lfs3_file_desync(&lfs3, &a) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite a one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "czesc!", strlen("czesc!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "czesc!", strlen("czesc!")) => strlen("czesc!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // should still have a - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test one non-LFS_O_SYNC and one LFS_O_SYNC +# test one non-LFS3_O_SYNC and one LFS3_O_SYNC [cases.test_fsync_desync_o_wdwsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - desynced writer // b - synced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | LFS_O_DESYNC) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | LFS3_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &b, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); // write to b - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - // reopen a with LFS_O_TRUNC - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_TRUNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | LFS_O_DESYNC) => 0; + // reopen a with LFS3_O_TRUNC + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_TRUNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | LFS3_O_DESYNC) => 0; // c should still have a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; - // reopen LFS_O_WRONLY and rewrite a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + // reopen LFS3_O_WRONLY and rewrite a + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // c should still have a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // lets rewrite a and b one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "moshimoshi!", strlen("moshimoshi!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "moshimoshi!", strlen("moshimoshi!")) => strlen("moshimoshi!"); - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "czesc!", strlen("czesc!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "czesc!", strlen("czesc!")) => strlen("czesc!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // should still have b - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!i!"); assert(memcmp(rbuf, "czesc!i!", strlen("czesc!i!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_desync_wwdrr_zero] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, truncate, and close, this gets tricky as we no // longer have a struct - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_truncate(&lfs, &b, 0) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_truncate(&lfs3, &b, 0) => 0; + lfs3_file_close(&lfs3, &b) => 0; // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // reopen b, mark as desync, truncate - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_truncate(&lfs, &b, 0) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_truncate(&lfs3, &b, 0) => 0; // rewrite a, sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b should show up in c, without a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b, close, desync flag should have been cleared - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // truncate a, close - lfsr_file_truncate(&lfs, &a, 0) => 0; - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_truncate(&lfs3, &a, 0) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our truncate should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_desync_wwdrr_noop] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, this should freeze its contents - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // rewrite a, sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b, this may be tricky since we haven't touched b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b should show up in c, without a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b, close, desync flag should have been cleared - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a, close - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_desync_wwdrr_append] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_APPEND) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY | LFS_O_APPEND) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_APPEND) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY | LFS3_O_APPEND) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, write, and close - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // c should still have previous contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // reopen b, mark as desync, write - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY | LFS_O_APPEND) => 0; - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY | LFS3_O_APPEND) => 0; + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // write a, sync - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!zdrasti!"); assert(memcmp(rbuf, "hello!zdrasti!", strlen("hello!zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!zdrasti!"); assert(memcmp(rbuf, "hello!zdrasti!", strlen("hello!zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // b should show up in c, without a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // write b, close, desync flag should have been cleared - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!annyeong!"); assert(memcmp(rbuf, "hello!ohayo!annyeong!", strlen("hello!ohayo!annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!annyeong!"); assert(memcmp(rbuf, "hello!ohayo!annyeong!", strlen("hello!ohayo!annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // write a, close - lfsr_file_write(&lfs, &a, "czesc!", strlen("czesc!")) + lfs3_file_write(&lfs3, &a, "czesc!", strlen("czesc!")) => strlen("czesc!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!annyeong!czesc!"); assert(memcmp(rbuf, "hello!ohayo!annyeong!czesc!", strlen("hello!ohayo!annyeong!czesc!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!annyeong!czesc!"); assert(memcmp(rbuf, "hello!ohayo!annyeong!czesc!", strlen("hello!ohayo!annyeong!czesc!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -3375,12 +3375,12 @@ code = ''' [cases.test_fsync_drrr] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -3392,53 +3392,53 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | LFS_O_DESYNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | LFS3_O_DESYNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writer, wbuf, CHUNK) => CHUNK; memcpy(&after[i], wbuf, CHUNK); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; if (SYNC == 0) { assert(memcmp(rbuf, &before[i], CHUNK) == 0); } else { @@ -3446,34 +3446,34 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; if (SYNC == 0) { assert(memcmp(rbuf, before, SIZE) == 0); } else { assert(memcmp(rbuf, after, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_drrr_fuzz] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 20 defines.SIZE = [ @@ -3488,65 +3488,65 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | LFS_O_DESYNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | LFS3_O_DESYNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writer, off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writer, off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, size) => size; + lfs3_file_write(&lfs3, &writer, wbuf, size) => size; memcpy(&after[off], wbuf, size); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; if (SYNC == 0) { assert(memcmp(rbuf, &before[off], size) == 0); } else { @@ -3554,35 +3554,35 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; if (SYNC == 0) { assert(memcmp(rbuf, before, SIZE) == 0); } else { assert(memcmp(rbuf, after, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test one writer, multiple desynced readers [cases.test_fsync_wddd] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -3594,80 +3594,80 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", - LFS_O_RDONLY | LFS_O_DESYNC) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", + LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writer, wbuf, CHUNK) => CHUNK; memcpy(&after[i], wbuf, CHUNK); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; assert(memcmp(rbuf, &before[i], CHUNK) == 0); } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_wddd_fuzz] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 20 defines.SIZE = [ @@ -3682,93 +3682,93 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", - LFS_O_RDONLY | LFS_O_DESYNC) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", + LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writer, off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writer, off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, size) => size; + lfs3_file_write(&lfs3, &writer, wbuf, size) => size; memcpy(&after[off], wbuf, size); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; assert(memcmp(rbuf, &before[off], size) == 0); } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple desynced rd/wrers [cases.test_fsync_rwdrwd] defines.RW = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -3780,46 +3780,46 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t between[RW][SIZE]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { memcpy(between[rw], before, SIZE); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_DESYNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_DESYNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &rdwrs[rw], i, LFS_SEEK_SET) => i; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &rdwrs[rw], i, LFS3_SEEK_SET) => i; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, CHUNK) => CHUNK; memcpy(&between[rw][i], wbuf, CHUNK); if (SYNC == 0) { if (rw == 0) { @@ -3827,10 +3827,10 @@ code = ''' } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } if (i == 0) { memcpy(after, between[rw], SIZE); @@ -3839,10 +3839,10 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_seek(&lfs, &rdwrs[rw], i, LFS_SEEK_SET) => i; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_seek(&lfs3, &rdwrs[rw], i, LFS3_SEEK_SET) => i; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => CHUNK; if (SYNC == 0) { assert(memcmp(rbuf, &between[rw][i], CHUNK) == 0); } else { @@ -3850,33 +3850,33 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; if (SYNC == 0) { assert(memcmp(rbuf, before, SIZE) == 0); } else { assert(memcmp(rbuf, after, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_rwdrwd_fuzz] defines.RW = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 20 defines.SIZE = [ @@ -3891,51 +3891,51 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t between[RW][SIZE]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { memcpy(between[rw], before, SIZE); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_DESYNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_DESYNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; memcpy(&between[rw][off], wbuf, size); if (SYNC == 0) { if (rw == 0) { @@ -3943,10 +3943,10 @@ code = ''' } } else { if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; } if (i == 0) { memcpy(after, between[rw], SIZE); @@ -3955,15 +3955,15 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; if (SYNC == 0) { assert(memcmp(rbuf, &between[rw][off], size) == 0); } else { @@ -3971,30 +3971,30 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + for (lfs3_size_t rw = 0; rw < RW; rw++) { + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; if (SYNC == 0) { assert(memcmp(rbuf, before, SIZE) == 0); } else { assert(memcmp(rbuf, after, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple rwd files without fixed size [cases.test_fsync_rwdrwd_sparse_fuzz] defines.RW = 4 # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 40 defines.SIZE = [ @@ -4009,32 +4009,32 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(100)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; uint8_t between[RW][SIZE]; - lfs_size_t between_size[RW]; + lfs3_size_t between_size[RW]; bool between_desync[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { between_size[rw] = 0; between_desync[rw] = false; } uint8_t after[SIZE]; - lfs_size_t after_size = 0; + lfs3_size_t after_size = 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { // open files - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_CREAT - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_CREAT + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 2; // choose a random sync state @@ -4043,20 +4043,20 @@ code = ''' // writing? if (op == 0) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } // write - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } // update sim @@ -4066,38 +4066,38 @@ code = ''' off - between_size[rw]); } memcpy(&between[rw][off], wbuf, size); - between_size[rw] = lfs_max(off + size, between_size[rw]); + between_size[rw] = lfs3_max(off + size, between_size[rw]); // reading? } else if (op == 1) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, between_size[rw] - off); + lfs3_size_t size = lfs3_min(CHUNK, between_size[rw] - off); // read - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; assert(memcmp(rbuf, &between[rw][off], size) == 0); } // desync? if (sync == 0) { - lfsr_file_desync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_desync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = true; // sync? } else if (sync == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // broadcast sim memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -4110,16 +4110,16 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // close files - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; // broadcast sim one last time? if (!between_desync[rw]) { memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -4129,22 +4129,22 @@ code = ''' } // check that file was written as expected - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => after_size; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => after_size; assert(memcmp(rbuf, after, after_size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple rwd files while also truncating/fruncating [cases.test_fsync_rwtfdrwtfd_sparse_fuzz] defines.RW = 4 # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 40 defines.SIZE = [ @@ -4159,32 +4159,32 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(100)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; uint8_t between[RW][SIZE]; - lfs_size_t between_size[RW]; + lfs3_size_t between_size[RW]; bool between_desync[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { between_size[rw] = 0; between_desync[rw] = false; } uint8_t after[SIZE]; - lfs_size_t after_size = 0; + lfs3_size_t after_size = 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { // open files - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_CREAT - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_CREAT + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 4; // choose a random sync state @@ -4193,20 +4193,20 @@ code = ''' // writing? if (op == 0) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } // write - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } // update sim @@ -4216,29 +4216,29 @@ code = ''' off - between_size[rw]); } memcpy(&between[rw][off], wbuf, size); - between_size[rw] = lfs_max(off + size, between_size[rw]); + between_size[rw] = lfs3_max(off + size, between_size[rw]); // reading? } else if (op == 1) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, between_size[rw] - off); + lfs3_size_t size = lfs3_min(CHUNK, between_size[rw] - off); // read - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; assert(memcmp(rbuf, &between[rw][off], size) == 0); // truncating? } else if (op == 2) { // choose a random new file size - lfs_off_t size = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size = TEST_PRNG(&prng) % SIZE; // truncate - lfsr_file_truncate(&lfs, &rdwrs[rw], size) => 0; + lfs3_file_truncate(&lfs3, &rdwrs[rw], size) => 0; // update the sim if (size > between_size[rw]) { @@ -4251,10 +4251,10 @@ code = ''' // fruncating? } else if (op == 3) { // choose a random new file size - lfs_off_t size = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size = TEST_PRNG(&prng) % SIZE; // fruncate - lfsr_file_fruncate(&lfs, &rdwrs[rw], size) => 0; + lfs3_file_fruncate(&lfs3, &rdwrs[rw], size) => 0; // update the sim if (size > between_size[rw]) { @@ -4274,19 +4274,19 @@ code = ''' // desync? if (sync == 0) { - lfsr_file_desync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_desync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = true; // sync? } else if (sync == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // broadcast sim memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -4295,7 +4295,7 @@ code = ''' // resync? } else if (sync == 2) { - lfsr_file_resync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_resync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // update sim @@ -4308,16 +4308,16 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // close files - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; // broadcast sim one last time? if (!between_desync[rw]) { memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -4327,14 +4327,14 @@ code = ''' } // check that file was written as expected - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => after_size; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => after_size; assert(memcmp(rbuf, after, after_size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4343,1070 +4343,1070 @@ code = ''' # Some specific tests [cases.test_fsync_resync_rwyrr] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - reader kept open, recvs updates from a // c - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // our write should show up in a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_read(&lfs, &a, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_read(&lfs3, &a, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // b should still have previous contents - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // resync a - lfsr_file_resync(&lfs, &a) => 0; + lfs3_file_resync(&lfs3, &a) => 0; // a should have reverted to previous contents - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_read(&lfs, &a, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_read(&lfs3, &a, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // b should still have previous contents - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // our write should show up in a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_read(&lfs, &a, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_read(&lfs3, &a, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // b should still have previous contents - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // now our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &c) => 0; + lfs3_file_close(&lfs3, &c) => 0; - lfsr_file_close(&lfs, &b) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &b) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_resync_wrrdy] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - reader kept open, recvs updates from a // c - desynced reader - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // but not in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // resync c, should now be up to date - lfsr_file_resync(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_resync(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // rewrite and sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and in c now that we resynced - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // desync c, rewrite a and sync - lfsr_file_desync(&lfs, &c) => 0; - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_desync(&lfs3, &c) => 0; + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // but not in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // resync c, should now be up to date - lfsr_file_resync(&lfs, &c) => 0; - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_resync(&lfs3, &c) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // desync c, rewrite a and close - lfsr_file_desync(&lfs, &c) => 0; - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + lfs3_file_desync(&lfs3, &c) => 0; + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // our write should show up in b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_read(&lfs, &b, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_read(&lfs3, &b, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // but not in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // resync c, should now be up to date - lfsr_file_resync(&lfs, &c) => 0; - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_resync(&lfs3, &c) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &b) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &b) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_resync_wwdyrr] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, rewrite - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // rewrite a, sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // c should still show a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // desync b - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // rewrite b, close - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // b should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // c should still show b's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test that LFS_O_SYNC/LFS_O_FLUSH flags work as expected +# test that LFS3_O_SYNC/LFS3_O_FLUSH flags work as expected [cases.test_fsync_resync_o_wsdywsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2, 3] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - desynced synced writer // b - synced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0) - | LFS_O_DESYNC) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0) + | LFS3_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &b, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to b - lfsr_file_write(&lfs, &b, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &b, "hello!", strlen("hello!")) => strlen("hello!"); // should immediately show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // reopen a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0) - | LFS_O_DESYNC) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0) + | LFS3_O_DESYNC) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // reopen a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0) - | LFS_O_DESYNC) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0) + | LFS3_O_DESYNC) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync a - lfsr_file_resync(&lfs, &a) => 0; + lfs3_file_resync(&lfs3, &a) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still show b's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // desync a - lfsr_file_desync(&lfs, &a) => 0; + lfs3_file_desync(&lfs3, &a) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("zdrasti!"); assert(memcmp(rbuf, "zdrasti!", strlen("zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should revert to a's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // desync b - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "czesc!", strlen("czesc!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "czesc!", strlen("czesc!")) => strlen("czesc!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close b - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // c should still show b's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test one non-LFS_O_SYNC and one LFS_O_SYNC +# test one non-LFS3_O_SYNC and one LFS3_O_SYNC [cases.test_fsync_resync_o_wdywsrr] # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC -# SYNC=3 => sync via LFS_M_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC +# SYNC=3 => sync via LFS3_M_SYNC defines.SYNC = [2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH -# FLUSH=3 => flush via LFS_M_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH +# FLUSH=3 => flush via LFS3_M_FLUSH defines.FLUSH = [0, 2, 3] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - LFS_M_RDWR - | ((FLUSH == 3) ? LFS_M_FLUSH : 0) - | ((SYNC == 3) ? LFS_M_SYNC : 0), + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + LFS3_M_RDWR + | ((FLUSH == 3) ? LFS3_M_FLUSH : 0) + | ((SYNC == 3) ? LFS3_M_SYNC : 0), CFG) => 0; // a - desynced writer // b - synced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | LFS_O_DESYNC) => 0; - lfsr_file_open(&lfs, &b, "jello", - LFS_O_WRONLY - | LFS_O_CREAT - | LFS_O_EXCL - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | LFS3_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &b, "jello", + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); // write to b - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // should immediately show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync a - lfsr_file_resync(&lfs, &a) => 0; + lfs3_file_resync(&lfs3, &a) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - // reopen a with LFS_O_TRUNC - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | LFS_O_TRUNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | LFS_O_DESYNC) => 0; + // reopen a with LFS3_O_TRUNC + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | LFS3_O_TRUNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | LFS3_O_DESYNC) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("bonjour!"); assert(memcmp(rbuf, "bonjour!", strlen("bonjour!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync a - lfsr_file_resync(&lfs, &a) => 0; + lfs3_file_resync(&lfs3, &a) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - // reopen LFS_O_WRONLY and rewrite a - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &a, "zdrasti!", strlen("zdrasti!")) + // reopen LFS3_O_WRONLY and rewrite a + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &a, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!r!"); assert(memcmp(rbuf, "ohayo!r!", strlen("ohayo!r!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite b - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync a - lfsr_file_resync(&lfs, &a) => 0; + lfs3_file_resync(&lfs3, &a) => 0; // sync a - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // c should still have b's contents - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("annyeong!"); assert(memcmp(rbuf, "annyeong!", strlen("annyeong!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // desync a - lfsr_file_desync(&lfs, &a) => 0; + lfs3_file_desync(&lfs3, &a) => 0; // lets rewrite a and b one last time - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "moshimoshi!", strlen("moshimoshi!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "moshimoshi!", strlen("moshimoshi!")) => strlen("moshimoshi!"); - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "czesc!", strlen("czesc!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "czesc!", strlen("czesc!")) => strlen("czesc!"); // resync a - lfsr_file_resync(&lfs, &a) => 0; + lfs3_file_resync(&lfs3, &a) => 0; // should immediately show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a and b - lfsr_file_close(&lfs, &a) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &a) => 0; + lfs3_file_close(&lfs3, &b) => 0; // should still have b - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("czesc!ng!"); assert(memcmp(rbuf, "czesc!ng!", strlen("czesc!ng!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_resync_wwdyrr_zero] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, rewrite - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // truncate a, sync, this gets tricky as we no longer have a struct - lfsr_file_truncate(&lfs, &a, 0) => 0; - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_truncate(&lfs3, &a, 0) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // c should still show a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // desync b - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // truncate b, close - lfsr_file_truncate(&lfs, &b, 0) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_truncate(&lfs3, &b, 0) => 0; + lfs3_file_close(&lfs3, &b) => 0; // b should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // c should still show b's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => 0; + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => 0; // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => 0; - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_resync_wwdyrr_noop] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, rewrite - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // rewrite a, sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync b, this may be tricky since we haven't touched b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // c should still show a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // desync b - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // resync b, close, this may be tricky since we haven't touched b - lfsr_file_resync(&lfs, &b) => 0; - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // b should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // c should still show b's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("ohayo!"); assert(memcmp(rbuf, "ohayo!", strlen("ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_resync_wwdyrr_append] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // a - writer // b - desynced writer // c - reader kept open, recvs updates from a // d - reader kept closed, checks disk state - lfsr_file_t a; - lfsr_file_t b; - lfsr_file_t c; - lfsr_file_t d; + lfs3_file_t a; + lfs3_file_t b; + lfs3_file_t c; + lfs3_file_t d; uint8_t rbuf[256]; - lfsr_file_open(&lfs, &a, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_APPEND) => 0; - lfsr_file_sync(&lfs, &a) => 0; - lfsr_file_open(&lfs, &b, "jello", LFS_O_WRONLY | LFS_O_APPEND) => 0; - lfsr_file_open(&lfs, &c, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &a, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_APPEND) => 0; + lfs3_file_sync(&lfs3, &a) => 0; + lfs3_file_open(&lfs3, &b, "jello", LFS3_O_WRONLY | LFS3_O_APPEND) => 0; + lfs3_file_open(&lfs3, &c, "jello", LFS3_O_RDONLY) => 0; // write to a and sync - lfsr_file_write(&lfs, &a, "hello!", strlen("hello!")) + lfs3_file_write(&lfs3, &a, "hello!", strlen("hello!")) => strlen("hello!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // our write should show up in c - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!"); assert(memcmp(rbuf, "hello!", strlen("hello!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // mark b as desync, rewrite - lfsr_file_desync(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "bonjour!", strlen("bonjour!")) + lfs3_file_desync(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "bonjour!", strlen("bonjour!")) => strlen("bonjour!"); // rewrite a, sync - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "ohayo!", strlen("ohayo!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "ohayo!", strlen("ohayo!")) => strlen("ohayo!"); - lfsr_file_sync(&lfs, &a) => 0; + lfs3_file_sync(&lfs3, &a) => 0; // a should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // sync b - lfsr_file_sync(&lfs, &b) => 0; + lfs3_file_sync(&lfs3, &b) => 0; // c should still show a's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!"); assert(memcmp(rbuf, "hello!ohayo!", strlen("hello!ohayo!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // rewrite a - lfsr_file_rewind(&lfs, &a) => 0; - lfsr_file_write(&lfs, &a, "annyeong!", strlen("annyeong!")) + lfs3_file_rewind(&lfs3, &a) => 0; + lfs3_file_write(&lfs3, &a, "annyeong!", strlen("annyeong!")) => strlen("annyeong!"); // desync b - lfsr_file_desync(&lfs, &b) => 0; + lfs3_file_desync(&lfs3, &b) => 0; // resync b - lfsr_file_resync(&lfs, &b) => 0; + lfs3_file_resync(&lfs3, &b) => 0; // rewrite b, close - lfsr_file_rewind(&lfs, &b) => 0; - lfsr_file_write(&lfs, &b, "zdrasti!", strlen("zdrasti!")) + lfs3_file_rewind(&lfs3, &b) => 0; + lfs3_file_write(&lfs3, &b, "zdrasti!", strlen("zdrasti!")) => strlen("zdrasti!"); - lfsr_file_close(&lfs, &b) => 0; + lfs3_file_close(&lfs3, &b) => 0; // b should show up in c - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!zdrasti!"); assert(memcmp(rbuf, "hello!ohayo!zdrasti!", strlen("hello!ohayo!zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!zdrasti!"); assert(memcmp(rbuf, "hello!ohayo!zdrasti!", strlen("hello!ohayo!zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; // close a - lfsr_file_close(&lfs, &a) => 0; + lfs3_file_close(&lfs3, &a) => 0; // c should still show b's changes - lfsr_file_rewind(&lfs, &c) => 0; - lfsr_file_read(&lfs, &c, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &c) => 0; + lfs3_file_read(&lfs3, &c, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!zdrasti!"); assert(memcmp(rbuf, "hello!ohayo!zdrasti!", strlen("hello!ohayo!zdrasti!")) == 0); // and on disk - lfsr_file_open(&lfs, &d, "jello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &d, rbuf, sizeof(rbuf)) + lfs3_file_open(&lfs3, &d, "jello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &d, rbuf, sizeof(rbuf)) => strlen("hello!ohayo!zdrasti!"); assert(memcmp(rbuf, "hello!ohayo!zdrasti!", strlen("hello!ohayo!zdrasti!")) == 0); - lfsr_file_close(&lfs, &d) => 0; + lfs3_file_close(&lfs3, &d) => 0; - lfsr_file_close(&lfs, &c) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &c) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -5414,12 +5414,12 @@ code = ''' [cases.test_fsync_yrrr] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -5431,55 +5431,55 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | LFS_O_DESYNC - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | LFS3_O_DESYNC + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writer, wbuf, CHUNK) => CHUNK; // resync - lfsr_file_resync(&lfs, &writer) => 0; + lfs3_file_resync(&lfs3, &writer) => 0; memcpy(&after[i], wbuf, CHUNK); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; if (SYNC == 0 || SYNC == 1) { assert(memcmp(rbuf, &before[i], CHUNK) == 0); } else { @@ -5487,34 +5487,34 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; if (SYNC == 0 || SYNC == 1) { assert(memcmp(rbuf, before, SIZE) == 0); } else { assert(memcmp(rbuf, after, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_yrrr_fuzz] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 20 defines.SIZE = [ @@ -5529,66 +5529,66 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", LFS_O_RDONLY) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", LFS3_O_RDONLY) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writer, off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writer, off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, size) => size; + lfs3_file_write(&lfs3, &writer, wbuf, size) => size; // resync - lfsr_file_resync(&lfs, &writer) => 0; + lfs3_file_resync(&lfs3, &writer) => 0; memcpy(&after[off], wbuf, size); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; if (SYNC == 0 || SYNC == 1) { assert(memcmp(rbuf, &before[off], size) == 0); } else { @@ -5596,35 +5596,35 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; if (SYNC == 0 || SYNC == 1) { assert(memcmp(rbuf, before, SIZE) == 0); } else { assert(memcmp(rbuf, after, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test one writer, multiple resyncing readers [cases.test_fsync_wyyy] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -5636,57 +5636,57 @@ defines.SIZE = [ ] defines.CHUNK = '(SIZE+16-1) / 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", - LFS_O_RDONLY | LFS_O_DESYNC) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", + LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &writer, wbuf, CHUNK) => CHUNK; memcpy(&after[i], wbuf, CHUNK); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // resync desync readers - lfsr_file_resync(&lfs, &readers[r]) => 0; - lfsr_file_desync(&lfs, &readers[r]) => 0; + lfs3_file_resync(&lfs3, &readers[r]) => 0; + lfs3_file_desync(&lfs3, &readers[r]) => 0; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => CHUNK; if (SYNC == 0) { assert(memcmp(rbuf, &before[i], CHUNK) == 0); } else { @@ -5694,30 +5694,30 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fsync_wyyy_fuzz] defines.R = 4 # SYNC=0 => no sync, readers not updated -# SYNC=1 => sync via lfsr_file_sync -# SYNC=2 => sync via LFS_O_SYNC +# SYNC=1 => sync via lfs3_file_sync +# SYNC=2 => sync via LFS3_O_SYNC defines.SYNC = [0, 1, 2] # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 20 defines.SIZE = [ @@ -5732,69 +5732,69 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(20)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file uint32_t prng = 42; uint8_t before[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { before[i] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t after[SIZE]; memcpy(after, before, SIZE); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, before, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, before, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // write 1 handle, read R handles in parallel - lfsr_file_t writer; - lfsr_file_t readers[R]; - lfsr_file_open(&lfs, &writer, "jello", - LFS_O_WRONLY - | ((FLUSH == 2) ? LFS_O_FLUSH : 0) - | ((SYNC == 2) ? LFS_O_SYNC : 0)) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_open(&lfs, &readers[r], "jello", - LFS_O_RDONLY | LFS_O_DESYNC) => 0; + lfs3_file_t writer; + lfs3_file_t readers[R]; + lfs3_file_open(&lfs3, &writer, "jello", + LFS3_O_WRONLY + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0) + | ((SYNC == 2) ? LFS3_O_SYNC : 0)) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_open(&lfs3, &readers[r], "jello", + LFS3_O_RDONLY | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &writer, off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &writer, off, LFS3_SEEK_SET) => off; // write uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &writer, wbuf, size) => size; + lfs3_file_write(&lfs3, &writer, wbuf, size) => size; memcpy(&after[off], wbuf, size); if (FLUSH == 1) { - lfsr_file_flush(&lfs, &writer) => 0; + lfs3_file_flush(&lfs3, &writer) => 0; } if (SYNC == 1) { - lfsr_file_sync(&lfs, &writer) => 0; + lfs3_file_sync(&lfs3, &writer) => 0; } - for (lfs_size_t r = 0; r < R; r++) { + for (lfs3_size_t r = 0; r < R; r++) { // choose a random offset - lfs_off_t off = TEST_PRNG(&prng) % SIZE; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); - lfsr_file_seek(&lfs, &readers[r], off, LFS_SEEK_SET) => off; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); + lfs3_file_seek(&lfs3, &readers[r], off, LFS3_SEEK_SET) => off; // resync desync readers - lfsr_file_resync(&lfs, &readers[r]) => 0; - lfsr_file_desync(&lfs, &readers[r]) => 0; + lfs3_file_resync(&lfs3, &readers[r]) => 0; + lfs3_file_desync(&lfs3, &readers[r]) => 0; // read uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &readers[r], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &readers[r], rbuf, CHUNK) => size; if (SYNC == 0) { assert(memcmp(rbuf, &before[off], size) == 0); } else { @@ -5802,19 +5802,19 @@ code = ''' } } } - lfsr_file_close(&lfs, &writer) => 0; - for (lfs_size_t r = 0; r < R; r++) { - lfsr_file_close(&lfs, &readers[r]) => 0; + lfs3_file_close(&lfs3, &writer) => 0; + for (lfs3_size_t r = 0; r < R; r++) { + lfs3_file_close(&lfs3, &readers[r]) => 0; } // check that file was written as expected - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, after, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -5822,8 +5822,8 @@ code = ''' [cases.test_fsync_rwdyrwdy_sparse_fuzz] defines.RW = 4 # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 40 defines.SIZE = [ @@ -5838,32 +5838,32 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(100)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; uint8_t between[RW][SIZE]; - lfs_size_t between_size[RW]; + lfs3_size_t between_size[RW]; bool between_desync[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { between_size[rw] = 0; between_desync[rw] = false; } uint8_t after[SIZE]; - lfs_size_t after_size = 0; + lfs3_size_t after_size = 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { // open files - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_CREAT - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_CREAT + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 2; // choose a random sync state @@ -5872,20 +5872,20 @@ code = ''' // writing? if (op == 0) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } // write - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } // update sim @@ -5895,38 +5895,38 @@ code = ''' off - between_size[rw]); } memcpy(&between[rw][off], wbuf, size); - between_size[rw] = lfs_max(off + size, between_size[rw]); + between_size[rw] = lfs3_max(off + size, between_size[rw]); // reading? } else if (op == 1) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, between_size[rw] - off); + lfs3_size_t size = lfs3_min(CHUNK, between_size[rw] - off); // read - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; assert(memcmp(rbuf, &between[rw][off], size) == 0); } // desync? if (sync == 0) { - lfsr_file_desync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_desync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = true; // sync? } else if (sync == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // broadcast sim memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -5935,7 +5935,7 @@ code = ''' // resync? } else if (sync == 2) { - lfsr_file_resync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_resync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // update sim @@ -5948,16 +5948,16 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // close files - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; // broadcast sim one last time? if (!between_desync[rw]) { memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -5967,22 +5967,22 @@ code = ''' } // check that file was written as expected - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => after_size; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => after_size; assert(memcmp(rbuf, after, after_size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Test multiple rwd files while also truncating/fruncating [cases.test_fsync_rwtfdyrwtfdy_sparse_fuzz] defines.RW = 4 # FLUSH=0 => no flush -# FLUSH=1 => flush via lfsr_file_flush -# FLUSH=2 => flush via LFS_O_FLUSH +# FLUSH=1 => flush via lfs3_file_flush +# FLUSH=2 => flush via LFS3_O_FLUSH defines.FLUSH = [0, 1, 2] defines.N = 40 defines.SIZE = [ @@ -5997,32 +5997,32 @@ defines.CHUNK = '(SIZE+16-1) / 16' defines.SEED = 'range(100)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; uint8_t between[RW][SIZE]; - lfs_size_t between_size[RW]; + lfs3_size_t between_size[RW]; bool between_desync[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { between_size[rw] = 0; between_desync[rw] = false; } uint8_t after[SIZE]; - lfs_size_t after_size = 0; + lfs3_size_t after_size = 0; // write RW rdwrs in parallel - lfsr_file_t rdwrs[RW]; - for (lfs_size_t rw = 0; rw < RW; rw++) { + lfs3_file_t rdwrs[RW]; + for (lfs3_size_t rw = 0; rw < RW; rw++) { // open files - lfsr_file_open(&lfs, &rdwrs[rw], "jello", - LFS_O_RDWR - | LFS_O_CREAT - | ((FLUSH == 2) ? LFS_O_FLUSH : 0)) => 0; + lfs3_file_open(&lfs3, &rdwrs[rw], "jello", + LFS3_O_RDWR + | LFS3_O_CREAT + | ((FLUSH == 2) ? LFS3_O_FLUSH : 0)) => 0; } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // choose a random operation uint8_t op = TEST_PRNG(&prng) % 4; // choose a random sync state @@ -6031,20 +6031,20 @@ code = ''' // writing? if (op == 0) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, SIZE - off); + lfs3_size_t size = lfs3_min(CHUNK, SIZE - off); uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < size; j++) { + for (lfs3_size_t j = 0; j < size; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } // write - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &rdwrs[rw], wbuf, size) => size; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &rdwrs[rw], wbuf, size) => size; if (FLUSH == 1) { - lfsr_file_flush(&lfs, &rdwrs[rw]) => 0; + lfs3_file_flush(&lfs3, &rdwrs[rw]) => 0; } // update sim @@ -6054,29 +6054,29 @@ code = ''' off - between_size[rw]); } memcpy(&between[rw][off], wbuf, size); - between_size[rw] = lfs_max(off + size, between_size[rw]); + between_size[rw] = lfs3_max(off + size, between_size[rw]); // reading? } else if (op == 1) { // choose a random offset - lfs_off_t off = (between_size[rw] > 0) + lfs3_off_t off = (between_size[rw] > 0) ? TEST_PRNG(&prng) % between_size[rw] : 0; - lfs_size_t size = lfs_min(CHUNK, between_size[rw] - off); + lfs3_size_t size = lfs3_min(CHUNK, between_size[rw] - off); // read - lfsr_file_seek(&lfs, &rdwrs[rw], off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &rdwrs[rw], off, LFS3_SEEK_SET) => off; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &rdwrs[rw], rbuf, CHUNK) => size; + lfs3_file_read(&lfs3, &rdwrs[rw], rbuf, CHUNK) => size; assert(memcmp(rbuf, &between[rw][off], size) == 0); // truncating? } else if (op == 2) { // choose a random new file size - lfs_off_t size = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size = TEST_PRNG(&prng) % SIZE; // truncate - lfsr_file_truncate(&lfs, &rdwrs[rw], size) => 0; + lfs3_file_truncate(&lfs3, &rdwrs[rw], size) => 0; // update the sim if (size > between_size[rw]) { @@ -6089,10 +6089,10 @@ code = ''' // fruncating? } else if (op == 3) { // choose a random new file size - lfs_off_t size = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size = TEST_PRNG(&prng) % SIZE; // fruncate - lfsr_file_fruncate(&lfs, &rdwrs[rw], size) => 0; + lfs3_file_fruncate(&lfs3, &rdwrs[rw], size) => 0; // update the sim if (size > between_size[rw]) { @@ -6112,19 +6112,19 @@ code = ''' // desync? if (sync == 0) { - lfsr_file_desync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_desync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = true; // sync? } else if (sync == 1) { - lfsr_file_sync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_sync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // broadcast sim memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -6133,7 +6133,7 @@ code = ''' // resync? } else if (sync == 2) { - lfsr_file_resync(&lfs, &rdwrs[rw]) => 0; + lfs3_file_resync(&lfs3, &rdwrs[rw]) => 0; between_desync[rw] = false; // update sim @@ -6146,16 +6146,16 @@ code = ''' } } } - for (lfs_size_t rw = 0; rw < RW; rw++) { + for (lfs3_size_t rw = 0; rw < RW; rw++) { // close files - lfsr_file_close(&lfs, &rdwrs[rw]) => 0; + lfs3_file_close(&lfs3, &rdwrs[rw]) => 0; // broadcast sim one last time? if (!between_desync[rw]) { memcpy(after, between[rw], SIZE); after_size = between_size[rw]; - for (lfs_size_t rw_ = 0; rw_ < RW; rw_++) { + for (lfs3_size_t rw_ = 0; rw_ < RW; rw_++) { if (!between_desync[rw_]) { memcpy(between[rw_], between[rw], SIZE); between_size[rw_] = between_size[rw]; @@ -6165,12 +6165,12 @@ code = ''' } // check that file was written as expected - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jello", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jello", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => after_size; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => after_size; assert(memcmp(rbuf, after, after_size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml index c3298156..4c5f38e7 100644 --- a/tests/test_fwrite.toml +++ b/tests/test_fwrite.toml @@ -32,73 +32,73 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that simple fragment-aligned writes are optimal @@ -109,119 +109,119 @@ defines.SIZE = 'N*FRAGMENT_SIZE' defines.INLINE_SIZE = 0 defines.CRYSTAL_THRESH = -1 defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of fragments? we need our internal btree traversal // API to check this // - lfs_size_t fragments = 0; + lfs3_size_t fragments = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many fragments we've seen fragments += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // we disabled block crystallization so this shouldn't // happen @@ -235,13 +235,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of fragments? assert(fragments == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that simple block-aligned writes always end up as compact blocks @@ -249,120 +249,120 @@ code = ''' defines.N = [0, 1, 2, 3, 4] defines.SIZE = 'N*BLOCK_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of branches/blocks? we need our internal btree // traversal API to check this // - lfs_block_t blocks = 0; + lfs3_block_t blocks = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // if block crystallization is working we shouldn't be // left with any inlined data fragments assert(false); - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many data blocks we've seen blocks += 1; @@ -375,13 +375,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of blocks? assert(blocks == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # write files incrementally @@ -404,84 +404,84 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfsr_file_write(&lfs, &file, &wbuf[i], CHUNK) => CHUNK; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_file_write(&lfs3, &file, &wbuf[i], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // note the switch to append here - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_APPEND) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_APPEND) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that incremental fragment-aligned writes are optimal @@ -495,131 +495,131 @@ defines.CRYSTAL_THRESH = -1 defines.SYNC = [false, true] defines.REMOUNT = [false, true] if = 'CHUNK <= SIZE' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfsr_file_write(&lfs, &file, &wbuf[i], lfs_min(CHUNK, SIZE-i)) - => lfs_min(CHUNK, SIZE-i); + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_file_write(&lfs3, &file, &wbuf[i], lfs3_min(CHUNK, SIZE-i)) + => lfs3_min(CHUNK, SIZE-i); // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // note the switch to append here - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_APPEND) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_APPEND) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of fragments? we need our internal btree traversal // API to check this // - lfs_size_t fragments = 0; + lfs3_size_t fragments = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many fragments we've seen fragments += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // we disabled block crystallization so this shouldn't // happen @@ -633,13 +633,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of fragments? assert(fragments == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that incremental block-aligned writes always end up as compact blocks @@ -650,132 +650,132 @@ defines.CHUNK = [32, 8, 1] defines.SYNC = [false, true] defines.REMOUNT = [false, true] if = 'CHUNK <= SIZE' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfsr_file_write(&lfs, &file, &wbuf[i], lfs_min(CHUNK, SIZE-i)) - => lfs_min(CHUNK, SIZE-i); + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_file_write(&lfs3, &file, &wbuf[i], lfs3_min(CHUNK, SIZE-i)) + => lfs3_min(CHUNK, SIZE-i); // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // note the switch to append here - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_APPEND) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_APPEND) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of branches/blocks? we need our internal btree // traversal API to check this // - lfs_block_t blocks = 0; + lfs3_block_t blocks = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // if block crystallization is working we shouldn't be // left with any inlined data fragments assert(false); - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many data blocks we've seen blocks += 1; @@ -788,13 +788,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of blocks? assert(blocks == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # overwrite files @@ -825,158 +825,160 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // write first chunk? if (MASK & 0x1) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } // write second chunk? if (MASK & 0x2) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE/2-CHUNK/2+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE/2 - CHUNK/2, LFS_SEEK_SET) + lfs3_file_seek(&lfs3, &file, SIZE/2 - CHUNK/2, LFS3_SEEK_SET) => SIZE/2 - CHUNK/2; - lfsr_file_write(&lfs, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } // write third chunk? if (MASK & 0x4) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; // does our file match our simulation? assert(memcmp(rbuf, sim, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # similar to overwrite files, but without underlying data @@ -1005,20 +1007,20 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; uint32_t prng = 42; memset(sim, 0, SIZE); // we may not write the entire file - lfs_off_t size + lfs3_off_t size = (MASK & ((ORDER == 0) ? 0x4 : 0x1)) ? SIZE : (MASK & ((ORDER == 0) ? 0x2 : 0x2)) ? SIZE/2 + (CHUNK+2-1)/2 : (MASK & ((ORDER == 0) ? 0x1 : 0x4)) ? CHUNK @@ -1026,140 +1028,142 @@ code = ''' // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // write first chunk? if (MASK & 0x1) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } // write second chunk? if (MASK & 0x2) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE/2-CHUNK/2+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE/2 - CHUNK/2, LFS_SEEK_SET) + lfs3_file_seek(&lfs3, &file, SIZE/2 - CHUNK/2, LFS3_SEEK_SET) => SIZE/2 - CHUNK/2; - lfsr_file_write(&lfs, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } // write third chunk? if (MASK & 0x4) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # simple truncate test @@ -1190,90 +1194,90 @@ if = [ 'TO / FRAGMENT_SIZE <= 4096', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram - uint8_t sim[lfs_max(FROM,TO)]; - memset(sim, 0, lfs_max(FROM,TO)); + uint8_t sim[lfs3_max(FROM,TO)]; + memset(sim, 0, lfs3_max(FROM,TO)); uint32_t prng = 42; - for (lfs_size_t i = 0; i < FROM; i++) { + for (lfs3_size_t i = 0; i < FROM; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, FROM) => FROM; + lfs3_file_write(&lfs3, &file, sim, FROM) => FROM; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // truncate to new size - lfsr_file_truncate(&lfs, &file, TO) => 0; + lfs3_file_truncate(&lfs3, &file, TO) => 0; if (TO < FROM) { memset(sim+TO, 0, FROM-TO); } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => TO; + lfs3_file_size(&lfs3, &file) => TO; // try reading uint8_t rbuf[2*TO]; memset(rbuf, 0xaa, 2*TO); - lfsr_file_read(&lfs, &file, rbuf, 2*TO) => TO; + lfs3_file_read(&lfs3, &file, rbuf, 2*TO) => TO; assert(memcmp(rbuf, sim, TO) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # one purpose of this test is to check that data is not hidden @@ -1315,109 +1319,109 @@ if = [ 'TO / FRAGMENT_SIZE <= 4096', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram - uint8_t sim[lfs_max(FROM,lfs_max(AND,TO))]; - memset(sim, 0, lfs_max(FROM,lfs_max(AND,TO))); + uint8_t sim[lfs3_max(FROM,lfs3_max(AND,TO))]; + memset(sim, 0, lfs3_max(FROM,lfs3_max(AND,TO))); uint32_t prng = 42; - for (lfs_size_t i = 0; i < FROM; i++) { + for (lfs3_size_t i = 0; i < FROM; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, FROM) => FROM; + lfs3_file_write(&lfs3, &file, sim, FROM) => FROM; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // truncate to intermediate size - lfsr_file_truncate(&lfs, &file, AND) => 0; + lfs3_file_truncate(&lfs3, &file, AND) => 0; if (AND < FROM) { memset(sim+AND, 0, FROM-AND); } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // truncate to new size - lfsr_file_truncate(&lfs, &file, TO) => 0; + lfs3_file_truncate(&lfs3, &file, TO) => 0; if (TO < AND) { memset(sim+TO, 0, AND-TO); } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => TO; + lfs3_file_size(&lfs3, &file) => TO; // try reading uint8_t rbuf[2*TO]; memset(rbuf, 0xaa, 2*TO); - lfsr_file_read(&lfs, &file, rbuf, 2*TO) => TO; + lfs3_file_read(&lfs3, &file, rbuf, 2*TO) => TO; assert(memcmp(rbuf, sim, TO) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # simple fruncate test @@ -1448,38 +1452,38 @@ if = [ 'TO / FRAGMENT_SIZE <= 4096', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram - uint8_t sim[lfs_max(FROM,TO)]; - memset(sim, 0, lfs_max(FROM,TO)); + uint8_t sim[lfs3_max(FROM,TO)]; + memset(sim, 0, lfs3_max(FROM,TO)); uint32_t prng = 42; - for (lfs_size_t i = 0; i < FROM; i++) { + for (lfs3_size_t i = 0; i < FROM; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, FROM) => FROM; + lfs3_file_write(&lfs3, &file, sim, FROM) => FROM; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // fruncate to new size - lfsr_file_fruncate(&lfs, &file, TO) => 0; + lfs3_file_fruncate(&lfs3, &file, TO) => 0; if (TO > FROM) { memmove(sim+TO-FROM, sim, FROM); memset(sim, 0, TO-FROM); @@ -1489,53 +1493,53 @@ code = ''' } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => TO; + lfs3_file_size(&lfs3, &file) => TO; // try reading uint8_t rbuf[2*TO]; memset(rbuf, 0xaa, 2*TO); - lfsr_file_read(&lfs, &file, rbuf, 2*TO) => TO; + lfs3_file_read(&lfs3, &file, rbuf, 2*TO) => TO; assert(memcmp(rbuf, sim, TO) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # one purpose of this test is to check that data is not hidden @@ -1577,38 +1581,38 @@ if = [ 'TO / FRAGMENT_SIZE <= 4096', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram - uint8_t sim[lfs_max(FROM,lfs_max(AND,TO))]; - memset(sim, 0, lfs_max(FROM,lfs_max(AND,TO))); + uint8_t sim[lfs3_max(FROM,lfs3_max(AND,TO))]; + memset(sim, 0, lfs3_max(FROM,lfs3_max(AND,TO))); uint32_t prng = 42; - for (lfs_size_t i = 0; i < FROM; i++) { + for (lfs3_size_t i = 0; i < FROM; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, FROM) => FROM; + lfs3_file_write(&lfs3, &file, sim, FROM) => FROM; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // fruncate to intermediate size - lfsr_file_fruncate(&lfs, &file, AND) => 0; + lfs3_file_fruncate(&lfs3, &file, AND) => 0; if (AND > FROM) { memmove(sim+AND-FROM, sim, FROM); memset(sim, 0, AND-FROM); @@ -1619,19 +1623,19 @@ code = ''' // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // fruncate to new size - lfsr_file_fruncate(&lfs, &file, TO) => 0; + lfs3_file_fruncate(&lfs3, &file, TO) => 0; if (TO > AND) { memmove(sim+TO-AND, sim, AND); memset(sim, 0, TO-AND); @@ -1641,53 +1645,53 @@ code = ''' } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TO); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => TO; + lfs3_file_size(&lfs3, &file) => TO; // try reading uint8_t rbuf[2*TO]; memset(rbuf, 0xaa, 2*TO); - lfsr_file_read(&lfs, &file, rbuf, 2*TO) => TO; + lfs3_file_read(&lfs3, &file, rbuf, 2*TO) => TO; assert(memcmp(rbuf, sim, TO) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # truncate should not affect pos @@ -1695,50 +1699,50 @@ code = ''' defines.POS = ['1', 'SIZE/2', 'SIZE-1', '2*SIZE'] defines.SIZE = '4*BLOCK_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // seek - lfsr_file_seek(&lfs, &file, POS, LFS_SEEK_SET) => POS; + lfs3_file_seek(&lfs3, &file, POS, LFS3_SEEK_SET) => POS; // truncate - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; // should not affect pos - lfsr_file_tell(&lfs, &file) => POS; - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_tell(&lfs3, &file) => POS; + lfs3_file_size(&lfs3, &file) => SIZE; // truncate - lfsr_file_truncate(&lfs, &file, 1) => 0; + lfs3_file_truncate(&lfs3, &file, 1) => 0; // should not affect pos - lfsr_file_tell(&lfs, &file) => POS; - lfsr_file_size(&lfs, &file) => 1; + lfs3_file_tell(&lfs3, &file) => POS; + lfs3_file_size(&lfs3, &file) => 1; // truncate - lfsr_file_truncate(&lfs, &file, SIZE-1) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE-1) => 0; // should not affect pos - lfsr_file_tell(&lfs, &file) => POS; - lfsr_file_size(&lfs, &file) => SIZE-1; + lfs3_file_tell(&lfs3, &file) => POS; + lfs3_file_size(&lfs3, &file) => SIZE-1; // truncate - lfsr_file_truncate(&lfs, &file, 0) => 0; + lfs3_file_truncate(&lfs3, &file, 0) => 0; // should not affect pos - lfsr_file_tell(&lfs, &file) => POS; - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_tell(&lfs3, &file) => POS; + lfs3_file_size(&lfs3, &file) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fruncate should update pos relative to end @@ -1746,59 +1750,59 @@ code = ''' defines.POS = ['1', 'SIZE/2', 'SIZE-1', '2*SIZE'] defines.SIZE = '4*BLOCK_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // seek - lfsr_file_seek(&lfs, &file, POS, LFS_SEEK_SET) => POS; + lfs3_file_seek(&lfs3, &file, POS, LFS3_SEEK_SET) => POS; // fruncate - lfsr_file_fruncate(&lfs, &file, SIZE) => 0; + lfs3_file_fruncate(&lfs3, &file, SIZE) => 0; // should update pos - lfsr_file_tell(&lfs, &file) => POS + SIZE; - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_tell(&lfs3, &file) => POS + SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // seek - lfsr_file_seek(&lfs, &file, POS, LFS_SEEK_SET) => POS; + lfs3_file_seek(&lfs3, &file, POS, LFS3_SEEK_SET) => POS; // fruncate - lfsr_file_fruncate(&lfs, &file, 1) => 0; + lfs3_file_fruncate(&lfs3, &file, 1) => 0; // should update pos - lfsr_file_tell(&lfs, &file) => lfs_smax(POS - (SIZE-1), 0); - lfsr_file_size(&lfs, &file) => 1; + lfs3_file_tell(&lfs3, &file) => lfs3_smax(POS - (SIZE-1), 0); + lfs3_file_size(&lfs3, &file) => 1; // seek - lfsr_file_seek(&lfs, &file, POS, LFS_SEEK_SET) => POS; + lfs3_file_seek(&lfs3, &file, POS, LFS3_SEEK_SET) => POS; // fruncate - lfsr_file_fruncate(&lfs, &file, SIZE-1) => 0; + lfs3_file_fruncate(&lfs3, &file, SIZE-1) => 0; // should update pos - lfsr_file_tell(&lfs, &file) => POS + (SIZE-2); - lfsr_file_size(&lfs, &file) => SIZE-1; + lfs3_file_tell(&lfs3, &file) => POS + (SIZE-2); + lfs3_file_size(&lfs3, &file) => SIZE-1; // seek - lfsr_file_seek(&lfs, &file, POS, LFS_SEEK_SET) => POS; + lfs3_file_seek(&lfs3, &file, POS, LFS3_SEEK_SET) => POS; // fruncate - lfsr_file_fruncate(&lfs, &file, 0) => 0; + lfs3_file_fruncate(&lfs3, &file, 0) => 0; // should update pos - lfsr_file_tell(&lfs, &file) => lfs_smax(POS - (SIZE-1), 0); - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_tell(&lfs3, &file) => lfs3_smax(POS - (SIZE-1), 0); + lfs3_file_size(&lfs3, &file) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that truncating to zero drops the bshrub/btree @@ -1806,82 +1810,82 @@ code = ''' defines.N = [1, 2, 8] defines.SIZE = 'N*BLOCK_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // truncate down to zero, this should drop any bshrub/btree - lfsr_file_truncate(&lfs, &file, 0) => 0; + lfs3_file_truncate(&lfs3, &file, 0) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_size(&lfs3, &file) => 0; // try reading uint8_t rbuf[2]; memset(rbuf, 0xaa, 2); - lfsr_file_read(&lfs, &file, rbuf, 2) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, 2) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, did the file drop bshrubs/btrees? - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - assert(lfsr_bshrub_isbnull(&file.b)); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + assert(lfs3_bshrub_isbnull(&file.b)); + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that fruncating to zero drops the bshrub/btree @@ -1889,82 +1893,82 @@ code = ''' defines.N = [1, 2, 8] defines.SIZE = 'N*BLOCK_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // fruncate down to zero, this should drop any bshrub/btree - lfsr_file_fruncate(&lfs, &file, 0) => 0; + lfs3_file_fruncate(&lfs3, &file, 0) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => 0; + lfs3_file_size(&lfs3, &file) => 0; // try reading uint8_t rbuf[2]; memset(rbuf, 0xaa, 2); - lfsr_file_read(&lfs, &file, rbuf, 2) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, 2) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, did the file drop bshrubs/btrees? - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - assert(lfsr_bshrub_isbnull(&file.b)); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + assert(lfs3_bshrub_isbnull(&file.b)); + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that carving below fragment_thresh breaks blocks into fragments @@ -1975,122 +1979,122 @@ defines.SIZE = 'N*BLOCK_SIZE' defines.FRAGMENTS = [1, 2, 3] defines.TSIZE = 'FRAGMENTS*FRAGMENT_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // truncate down to truncate size, this should fragment our blocks - lfsr_file_truncate(&lfs, &file, TSIZE) => 0; + lfs3_file_truncate(&lfs3, &file, TSIZE) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TSIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TSIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => TSIZE; + lfs3_file_size(&lfs3, &file) => TSIZE; // try reading uint8_t rbuf[2*TSIZE]; memset(rbuf, 0xaa, 2*TSIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*TSIZE) => TSIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*TSIZE) => TSIZE; assert(memcmp(rbuf, wbuf, TSIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of fragments? we need our internal btree traversal // API to check this // - lfs_size_t fragments = 0; + lfs3_size_t fragments = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many fragments we've seen fragments += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // all blocks should have been fragmented assert(false); @@ -2103,13 +2107,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of fragments? assert(fragments == FRAGMENTS); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fwrite_fruncate_litmus_fragment] @@ -2119,122 +2123,122 @@ defines.SIZE = 'N*BLOCK_SIZE' defines.FRAGMENTS = [1, 2, 3] defines.TSIZE = 'FRAGMENTS*FRAGMENT_SIZE' defines.SYNC = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // fruncate down to fruncate size, this should fragment our blocks - lfsr_file_fruncate(&lfs, &file, TSIZE) => 0; + lfs3_file_fruncate(&lfs3, &file, TSIZE) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TSIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == TSIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => TSIZE; + lfs3_file_size(&lfs3, &file) => TSIZE; // try reading uint8_t rbuf[2*TSIZE]; memset(rbuf, 0xaa, 2*TSIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*TSIZE) => TSIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*TSIZE) => TSIZE; assert(memcmp(rbuf, wbuf+(SIZE-TSIZE), TSIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of fragments? we need our internal btree traversal // API to check this // - lfs_size_t fragments = 0; + lfs3_size_t fragments = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many fragments we've seen fragments += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // all blocks should have been fragmented assert(false); @@ -2247,13 +2251,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of fragments? assert(fragments == FRAGMENTS); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # writing any data structure backwards always reveals issues @@ -2281,108 +2285,109 @@ if = [ 'SIZE <= 4*1024*CHUNK', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; if (INIT == 0) { // do nothing } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; } else { - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // write to file incrementally and backwards - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfsr_file_seek(&lfs, &file, SIZE-i-CHUNK, LFS_SEEK_SET) => SIZE-i-CHUNK; - lfsr_file_write(&lfs, &file, &wbuf[SIZE-i-CHUNK], CHUNK) => CHUNK; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_file_seek(&lfs3, &file, SIZE-i-CHUNK, LFS3_SEEK_SET) + => SIZE-i-CHUNK; + lfs3_file_write(&lfs3, &file, &wbuf[SIZE-i-CHUNK], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that reversed fragment-aligned writes are optimal @@ -2400,131 +2405,131 @@ if = [ # writing backwards is expected to be a bit slow 'SIZE <= 4*1024*CHUNK', ] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfs_off_t chunk_ = lfs_min(CHUNK, SIZE-i); - lfs_off_t i_ = SIZE-i-chunk_; - lfsr_file_seek(&lfs, &file, i_, LFS_SEEK_SET) => i_; - lfsr_file_write(&lfs, &file, &wbuf[i_], chunk_) => chunk_; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_off_t chunk_ = lfs3_min(CHUNK, SIZE-i); + lfs3_off_t i_ = SIZE-i-chunk_; + lfs3_file_seek(&lfs3, &file, i_, LFS3_SEEK_SET) => i_; + lfs3_file_write(&lfs3, &file, &wbuf[i_], chunk_) => chunk_; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of fragments? we need our internal btree traversal // API to check this // - lfs_size_t fragments = 0; + lfs3_size_t fragments = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many fragments we've seen fragments += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // we disabled block crystallization so this shouldn't // happen @@ -2538,13 +2543,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of fragments? assert(fragments == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that reversed block-aligned writes always end up as compact blocks @@ -2559,132 +2564,132 @@ if = [ # writing backwards is expected to be a bit slow 'SIZE <= 4*1024*CHUNK', ] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfs_off_t chunk_ = lfs_min(CHUNK, SIZE-i); - lfs_off_t i_ = SIZE-i-chunk_; - lfsr_file_seek(&lfs, &file, i_, LFS_SEEK_SET) => i_; - lfsr_file_write(&lfs, &file, &wbuf[i_], chunk_) => chunk_; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_off_t chunk_ = lfs3_min(CHUNK, SIZE-i); + lfs3_off_t i_ = SIZE-i-chunk_; + lfs3_file_seek(&lfs3, &file, i_, LFS3_SEEK_SET) => i_; + lfs3_file_write(&lfs3, &file, &wbuf[i_], chunk_) => chunk_; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of branches/blocks? we need our internal btree // traversal API to check this // - lfs_block_t blocks = 0; + lfs3_block_t blocks = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // if block crystallization is working we shouldn't be // left with any inlined data fragments assert(false); - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many data blocks we've seen blocks += 1; @@ -2697,16 +2702,16 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of blocks? assert(blocks == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# with lfsr_file_fruncate, we can write to a file in true reversed order +# with lfs3_file_fruncate, we can write to a file in true reversed order [cases.test_fwrite_freversed] defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -2727,102 +2732,102 @@ if = [ 'SIZE <= 4*1024*CHUNK', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // write to file incrementally and backwards - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfs_off_t pos = lfsr_file_tell(&lfs, &file); - lfsr_file_fruncate(&lfs, &file, i+CHUNK) => 0; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_off_t pos = lfs3_file_tell(&lfs3, &file); + lfs3_file_fruncate(&lfs3, &file, i+CHUNK) => 0; // pos shouldn't move when we fruncate - lfsr_file_tell(&lfs, &file) => pos + CHUNK; - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &wbuf[SIZE-i-CHUNK], CHUNK) => CHUNK; + lfs3_file_tell(&lfs3, &file) => pos + CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &wbuf[SIZE-i-CHUNK], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that reversed fragment-aligned writes are optimal @@ -2840,135 +2845,135 @@ if = [ # writing backwards is expected to be a bit slow 'SIZE <= 4*1024*CHUNK', ] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfs_off_t chunk_ = lfs_min(CHUNK, SIZE-i); - lfs_off_t i_ = SIZE-i-chunk_; - lfs_off_t pos = lfsr_file_tell(&lfs, &file); - lfsr_file_fruncate(&lfs, &file, i+chunk_) => 0; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_off_t chunk_ = lfs3_min(CHUNK, SIZE-i); + lfs3_off_t i_ = SIZE-i-chunk_; + lfs3_off_t pos = lfs3_file_tell(&lfs3, &file); + lfs3_file_fruncate(&lfs3, &file, i+chunk_) => 0; // pos shouldn't move when we fruncate - lfsr_file_tell(&lfs, &file) => pos + chunk_; - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &wbuf[i_], chunk_) => chunk_; + lfs3_file_tell(&lfs3, &file) => pos + chunk_; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &wbuf[i_], chunk_) => chunk_; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of fragments? we need our internal btree traversal // API to check this // - lfs_size_t fragments = 0; + lfs3_size_t fragments = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many fragments we've seen fragments += 1; - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // we disabled block crystallization so this shouldn't // happen @@ -2982,13 +2987,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of fragments? assert(fragments == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that reversed block-aligned writes always end up as compact blocks @@ -3003,136 +3008,136 @@ if = [ # writing backwards is expected to be a bit slow 'SIZE <= 4*1024*CHUNK', ] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - for (lfs_size_t i = 0; i < SIZE; i += CHUNK) { - lfs_off_t chunk_ = lfs_min(CHUNK, SIZE-i); - lfs_off_t i_ = SIZE-i-chunk_; - lfs_off_t pos = lfsr_file_tell(&lfs, &file); - lfsr_file_fruncate(&lfs, &file, i+chunk_) => 0; + for (lfs3_size_t i = 0; i < SIZE; i += CHUNK) { + lfs3_off_t chunk_ = lfs3_min(CHUNK, SIZE-i); + lfs3_off_t i_ = SIZE-i-chunk_; + lfs3_off_t pos = lfs3_file_tell(&lfs3, &file); + lfs3_file_fruncate(&lfs3, &file, i+chunk_) => 0; // pos shouldn't move when we fruncate - lfsr_file_tell(&lfs, &file) => pos + chunk_; - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &wbuf[i_], chunk_) => chunk_; + lfs3_file_tell(&lfs3, &file) => pos + chunk_; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &wbuf[i_], chunk_) => chunk_; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // here's our main test, do we end up with the expected // number of branches/blocks? we need our internal btree // traversal API to check this // - lfs_block_t blocks = 0; + lfs3_block_t blocks = 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_btraversal_t bt; - lfsr_btraversal_init(&bt); - for (lfs_block_t i = 0;; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_btraversal_t bt; + lfs3_btraversal_init(&bt); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_bid_t bid; - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_file_traverse(&lfs, &file, &bt, + lfs3_bid_t bid; + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_file_traverse(&lfs3, &file, &bt, &bid, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: %d 0x%x btree 0x%x.%x\n", bid, tag, rbyd->blocks[0], rbyd->trunk); - } else if (tag == LFSR_TAG_DATA) { + } else if (tag == LFS3_TAG_DATA) { printf("traversal: %d 0x%x data %d\n", bid, tag, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // if block crystallization is working we shouldn't be // left with any inlined data fragments assert(false); - } else if (tag == LFSR_TAG_BLOCK) { + } else if (tag == LFS3_TAG_BLOCK) { printf("traversal: %d 0x%x block 0x%x.%x %d\n", bid, tag, bptr.data.u.disk.block, bptr.data.u.disk.off, - lfsr_data_size(bptr.data)); + lfs3_data_size(bptr.data)); // keep track of how many data blocks we've seen blocks += 1; @@ -3145,13 +3150,13 @@ code = ''' assert(false); } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // correct number of blocks? assert(blocks == N); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # these are like the overwrite/hole tests, but with enough rewrites to @@ -3185,164 +3190,166 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // write first chunk? if (MASK & 0x1) { - for (lfs_size_t w = 0; w < WRITES; w++) { + for (lfs3_size_t w = 0; w < WRITES; w++) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } } // write second chunk? if (MASK & 0x2) { - for (lfs_size_t w = 0; w < WRITES; w++) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t w = 0; w < WRITES; w++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE/2-CHUNK/2+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE/2 - CHUNK/2, LFS_SEEK_SET) + lfs3_file_seek(&lfs3, &file, SIZE/2 - CHUNK/2, LFS3_SEEK_SET) => SIZE/2 - CHUNK/2; - lfsr_file_write(&lfs, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } } // write third chunk? if (MASK & 0x4) { - for (lfs_size_t w = 0; w < WRITES; w++) { + for (lfs3_size_t w = 0; w < WRITES; w++) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE; + lfs3_file_size(&lfs3, &file) => SIZE; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE; // does our file match our simulation? assert(memcmp(rbuf, sim, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_fwrite_hole_compaction] @@ -3374,20 +3381,20 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; uint32_t prng = 42; memset(sim, 0, SIZE); // we may not write the entire file - lfs_off_t size + lfs3_off_t size = (MASK & ((ORDER == 0) ? 0x4 : 0x1)) ? SIZE : (MASK & ((ORDER == 0) ? 0x2 : 0x2)) ? SIZE/2 + (CHUNK+2-1)/2 : (MASK & ((ORDER == 0) ? 0x1 : 0x4)) ? CHUNK @@ -3395,146 +3402,148 @@ code = ''' // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } // write first chunk? if (MASK & 0x1) { - for (lfs_size_t w = 0; w < WRITES; w++) { + for (lfs3_size_t w = 0; w < WRITES; w++) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } } // write second chunk? if (MASK & 0x2) { - for (lfs_size_t w = 0; w < WRITES; w++) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t w = 0; w < WRITES; w++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE/2-CHUNK/2+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE/2 - CHUNK/2, LFS_SEEK_SET) + lfs3_file_seek(&lfs3, &file, SIZE/2 - CHUNK/2, LFS3_SEEK_SET) => SIZE/2 - CHUNK/2; - lfsr_file_write(&lfs, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE/2-CHUNK/2], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } } // write third chunk? if (MASK & 0x4) { - for (lfs_size_t w = 0; w < WRITES; w++) { + for (lfs3_size_t w = 0; w < WRITES; w++) { if (ORDER == 0) { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[SIZE-CHUNK+i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, SIZE-CHUNK, LFS_SEEK_SET) => SIZE-CHUNK; - lfsr_file_write(&lfs, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, SIZE-CHUNK, LFS3_SEEK_SET) + => SIZE-CHUNK; + lfs3_file_write(&lfs3, &file, &sim[SIZE-CHUNK], CHUNK) => CHUNK; } else { - for (lfs_size_t i = 0; i < CHUNK; i++) { + for (lfs3_size_t i = 0; i < CHUNK; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfsr_file_write(&lfs, &file, &sim[0], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, 0, LFS3_SEEK_SET) => 0; + lfs3_file_write(&lfs3, &file, &sim[0], CHUNK) => CHUNK; } } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz testing @@ -3563,121 +3572,121 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random chunk-aligned location - lfs_off_t off = (TEST_PRNG(&prng) % (SIZE/CHUNK)) * CHUNK; + lfs3_off_t off = (TEST_PRNG(&prng) % (SIZE/CHUNK)) * CHUNK; // update sim - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+CHUNK); + size = lfs3_max(size, off+CHUNK); // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], CHUNK) => CHUNK; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], CHUNK) => CHUNK; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz testing @@ -3707,132 +3716,132 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # more seek testing [cases.test_fwrite_r_seek] defines.N = 20 -defines.WHENCE = ['LFS_SEEK_SET', 'LFS_SEEK_CUR', 'LFS_SEEK_END'] +defines.WHENCE = ['LFS3_SEEK_SET', 'LFS3_SEEK_CUR', 'LFS3_SEEK_END'] defines.SIZE = [ 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', @@ -3851,67 +3860,67 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfs_soff_t off_ = 0; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_soff_t off_ = 0; + for (lfs3_size_t i = 0; i < N; i++) { // choose a random location - lfs_soff_t off = TEST_PRNG(&prng) % SIZE; + lfs3_soff_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // test different seek methods - if (WHENCE == LFS_SEEK_SET) { - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - } else if (WHENCE == LFS_SEEK_CUR) { - lfsr_file_seek(&lfs, &file, off-off_, LFS_SEEK_CUR) => off; - } else if (WHENCE == LFS_SEEK_END) { - lfsr_file_seek(&lfs, &file, off-SIZE, LFS_SEEK_END) => off; + if (WHENCE == LFS3_SEEK_SET) { + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + } else if (WHENCE == LFS3_SEEK_CUR) { + lfs3_file_seek(&lfs3, &file, off-off_, LFS3_SEEK_CUR) => off; + } else if (WHENCE == LFS3_SEEK_END) { + lfs3_file_seek(&lfs3, &file, off-SIZE, LFS3_SEEK_END) => off; } // tell should always report the correct position - lfsr_file_tell(&lfs, &file) => off; + lfs3_file_tell(&lfs3, &file) => off; // read the file and assert we got the correct data uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, chunk) => chunk; + lfs3_file_read(&lfs3, &file, rbuf, chunk) => chunk; assert(memcmp(rbuf, &sim[off], chunk) == 0); // tell should report the new position - lfsr_file_tell(&lfs, &file) => off + chunk; + lfs3_file_tell(&lfs3, &file) => off + chunk; - // keep track of previous off for LFS_SEEK_CUR + // keep track of previous off for LFS3_SEEK_CUR off_ = off + chunk; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # this is pretty much the same as earlier fuzz testing, except we test # different seek methods [cases.test_fwrite_w_seek] defines.N = 10 -defines.WHENCE = ['LFS_SEEK_SET', 'LFS_SEEK_CUR', 'LFS_SEEK_END'] +defines.WHENCE = ['LFS3_SEEK_SET', 'LFS3_SEEK_CUR', 'LFS3_SEEK_END'] defines.SIZE = [ 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', @@ -3935,130 +3944,130 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; - lfs_soff_t off_ = 0; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; + lfs3_soff_t off_ = 0; + for (lfs3_size_t i = 0; i < N; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // test different seek methods - if (WHENCE == LFS_SEEK_SET) { - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - } else if (WHENCE == LFS_SEEK_CUR) { - lfsr_file_seek(&lfs, &file, off-off_, LFS_SEEK_CUR) => off; - } else if (WHENCE == LFS_SEEK_END) { - lfsr_file_seek(&lfs, &file, off-size, LFS_SEEK_END) => off; + if (WHENCE == LFS3_SEEK_SET) { + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + } else if (WHENCE == LFS3_SEEK_CUR) { + lfs3_file_seek(&lfs3, &file, off-off_, LFS3_SEEK_CUR) => off; + } else if (WHENCE == LFS3_SEEK_END) { + lfs3_file_seek(&lfs3, &file, off-size, LFS3_SEEK_END) => off; } // tell should always report the correct position - lfsr_file_tell(&lfs, &file) => off; + lfs3_file_tell(&lfs3, &file) => off; // update the sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update the file - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // tell should report the new position - lfsr_file_tell(&lfs, &file) => off + chunk; + lfs3_file_tell(&lfs3, &file) => off + chunk; - // keep track of previous off for LFS_SEEK_CUR + // keep track of previous off for LFS3_SEEK_CUR off_ = off + chunk; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # the above was just warmup, here's the real seek test [cases.test_fwrite_rw_seek] defines.N = 10 -defines.WHENCE = ['LFS_SEEK_SET', 'LFS_SEEK_CUR', 'LFS_SEEK_END'] +defines.WHENCE = ['LFS3_SEEK_SET', 'LFS3_SEEK_CUR', 'LFS3_SEEK_END'] defines.SIZE = [ 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', @@ -4082,155 +4091,155 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDWR) => 0; - lfs_soff_t off_ = 0; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDWR) => 0; + lfs3_soff_t off_ = 0; + for (lfs3_size_t i = 0; i < N; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // and if we are reading or writing uint8_t op = TEST_PRNG(&prng) % 2; // test different seek methods - if (WHENCE == LFS_SEEK_SET) { - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - } else if (WHENCE == LFS_SEEK_CUR) { - lfsr_file_seek(&lfs, &file, off-off_, LFS_SEEK_CUR) => off; - } else if (WHENCE == LFS_SEEK_END) { - lfsr_file_seek(&lfs, &file, off-size, LFS_SEEK_END) => off; + if (WHENCE == LFS3_SEEK_SET) { + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + } else if (WHENCE == LFS3_SEEK_CUR) { + lfs3_file_seek(&lfs3, &file, off-off_, LFS3_SEEK_CUR) => off; + } else if (WHENCE == LFS3_SEEK_END) { + lfs3_file_seek(&lfs3, &file, off-size, LFS3_SEEK_END) => off; } // tell should always report the correct position - lfsr_file_tell(&lfs, &file) => off; + lfs3_file_tell(&lfs3, &file) => off; // writing? if (op == 0) { // update the sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update the file - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // tell should report the new position - lfsr_file_tell(&lfs, &file) => off + chunk; + lfs3_file_tell(&lfs3, &file) => off + chunk; - // keep track of previous off for LFS_SEEK_CUR + // keep track of previous off for LFS3_SEEK_CUR off_ = off + chunk; // reading? } else if (op == 1) { // we may read less than chunk if we're past eof - lfs_off_t expected = lfs_min( + lfs3_off_t expected = lfs3_min( chunk, - size - lfs_min(off, size)); + size - lfs3_min(off, size)); // read the file and assert we got the correct data uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, chunk) => expected; + lfs3_file_read(&lfs3, &file, rbuf, chunk) => expected; assert(memcmp(rbuf, &sim[off], expected) == 0); // tell should report the new position - lfsr_file_tell(&lfs, &file) => off + expected; + lfs3_file_tell(&lfs3, &file) => off + expected; - // keep track of previous off for LFS_SEEK_CUR + // keep track of previous off for LFS3_SEEK_CUR off_ = off + expected; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test other corner conditions # test that seeking to a negative offset errors [cases.test_fwrite_seek_negative] -defines.WHENCE = ['LFS_SEEK_SET', 'LFS_SEEK_CUR', 'LFS_SEEK_END'] +defines.WHENCE = ['LFS3_SEEK_SET', 'LFS3_SEEK_CUR', 'LFS3_SEEK_END'] defines.SIZE = [ 'FILE_CACHE_SIZE/2', '2*FILE_CACHE_SIZE', @@ -4243,97 +4252,98 @@ defines.SIZE = [ # INIT=1 => fill with data # INIT=2 => truncate to size defines.INIT = [0, 1, 2] -defines.MODE = ['LFS_O_RDONLY', 'LFS_O_WRONLY', 'LFS_O_RDWR'] +defines.MODE = ['LFS3_O_RDONLY', 'LFS3_O_WRONLY', 'LFS3_O_RDWR'] if = [ # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = 42; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // try to seek before the beginning of the file, this should fail - lfsr_file_open(&lfs, &file, "hello", MODE) => 0; - if (WHENCE == LFS_SEEK_SET) { - lfsr_file_seek(&lfs, &file, -1, LFS_SEEK_SET) => LFS_ERR_INVAL; - } else if (WHENCE == LFS_SEEK_CUR) { - lfsr_file_seek(&lfs, &file, -1, LFS_SEEK_CUR) => LFS_ERR_INVAL; - } else if (WHENCE == LFS_SEEK_END) { - lfsr_file_seek(&lfs, &file, -(size+1), LFS_SEEK_END) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "hello", MODE) => 0; + if (WHENCE == LFS3_SEEK_SET) { + lfs3_file_seek(&lfs3, &file, -1, LFS3_SEEK_SET) => LFS3_ERR_INVAL; + } else if (WHENCE == LFS3_SEEK_CUR) { + lfs3_file_seek(&lfs3, &file, -1, LFS3_SEEK_CUR) => LFS3_ERR_INVAL; + } else if (WHENCE == LFS3_SEEK_END) { + lfs3_file_seek(&lfs3, &file, -(size+1), LFS3_SEEK_END) + => LFS3_ERR_INVAL; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that write overflow errors @@ -4350,98 +4360,98 @@ defines.SIZE = [ # INIT=1 => fill with data # INIT=2 => truncate to size defines.INIT = [0, 1, 2] -defines.MODE = ['LFS_O_WRONLY', 'LFS_O_RDWR'] +defines.MODE = ['LFS3_O_WRONLY', 'LFS3_O_RDWR'] if = [ # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = 42; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // seek to near the file limit - lfsr_file_open(&lfs, &file, "hello", MODE) => 0; - lfsr_file_seek(&lfs, &file, LFS_FILE_MAX-(SIZE/2), LFS_SEEK_SET) - => LFS_FILE_MAX-(SIZE/2); + lfs3_file_open(&lfs3, &file, "hello", MODE) => 0; + lfs3_file_seek(&lfs3, &file, LFS3_FILE_MAX-(SIZE/2), LFS3_SEEK_SET) + => LFS3_FILE_MAX-(SIZE/2); // try to write past the file limit, this should fail uint8_t wbuf[SIZE]; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => LFS_ERR_FBIG; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => LFS3_ERR_FBIG; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that truncate overflow errors @@ -4458,91 +4468,91 @@ defines.SIZE = [ # INIT=1 => fill with data # INIT=2 => truncate to size defines.INIT = [0, 1, 2] -defines.MODE = ['LFS_O_WRONLY', 'LFS_O_RDWR'] +defines.MODE = ['LFS3_O_WRONLY', 'LFS3_O_RDWR'] if = [ # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = 42; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // try to truncate the file past the file limit, this should fail - lfsr_file_open(&lfs, &file, "hello", MODE) => 0; - lfsr_file_truncate(&lfs, &file, LFS_FILE_MAX+(SIZE/2)) => LFS_ERR_FBIG; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", MODE) => 0; + lfs3_file_truncate(&lfs3, &file, LFS3_FILE_MAX+(SIZE/2)) => LFS3_ERR_FBIG; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that fruncate overflow errors @@ -4559,91 +4569,91 @@ defines.SIZE = [ # INIT=1 => fill with data # INIT=2 => truncate to size defines.INIT = [0, 1, 2] -defines.MODE = ['LFS_O_WRONLY', 'LFS_O_RDWR'] +defines.MODE = ['LFS3_O_WRONLY', 'LFS3_O_RDWR'] if = [ # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = 42; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // try to truncate the file past the file limit, this should fail - lfsr_file_open(&lfs, &file, "hello", MODE) => 0; - lfsr_file_fruncate(&lfs, &file, LFS_FILE_MAX+(SIZE/2)) => LFS_ERR_FBIG; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", MODE) => 0; + lfs3_file_fruncate(&lfs3, &file, LFS3_FILE_MAX+(SIZE/2)) => LFS3_ERR_FBIG; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4674,111 +4684,111 @@ if = [ 'SIZE <= 4*1024*FRAGMENT_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDWR) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDWR) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // and if we are reading, writing, truncating, or fruncating uint8_t op = TEST_PRNG(&prng) % 4; // writing? if (op == 0) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // seek - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; // update the sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update the file - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // remount? if (REMOUNT) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDWR) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDWR) => 0; } // reading? } else if (op == 1) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // seek - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; // we may read less than chunk if we're past eof - lfs_off_t expected = lfs_min( + lfs3_off_t expected = lfs3_min( chunk, - size - lfs_min(off, size)); + size - lfs3_min(off, size)); // read the file and assert we got the correct data uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, chunk) => expected; + lfs3_file_read(&lfs3, &file, rbuf, chunk) => expected; assert(memcmp(rbuf, &sim[off], expected) == 0); // truncating? } else if (op == 2) { // choose a random new file size - lfs_off_t size_ = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size_ = TEST_PRNG(&prng) % SIZE; // update the sim if (size_ < size) { @@ -4787,12 +4797,12 @@ code = ''' size = size_; // truncate the file - lfsr_file_truncate(&lfs, &file, size_) => 0; + lfs3_file_truncate(&lfs3, &file, size_) => 0; // fruncating? } else if (op == 3) { // choose a random new file size - lfs_off_t size_ = TEST_PRNG(&prng) % SIZE; + lfs3_off_t size_ = TEST_PRNG(&prng) % SIZE; // update the sim if (size_ > size) { @@ -4805,57 +4815,57 @@ code = ''' size = size_; // truncate the file - lfsr_file_fruncate(&lfs, &file, size_) => 0; + lfs3_file_fruncate(&lfs3, &file, size_) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4873,102 +4883,102 @@ if = [ 'CHUNK <= SIZE', 'FRAGMENT_SIZE > 1', ] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // reduce the weight of each btree entry // // this should normally never happen, so we need to use the // internal bshrub APIs to force this - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; - lfs_off_t pos = 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; + lfs3_off_t pos = 0; while (true) { - lfsr_tag_t tag; - lfsr_bid_t weight; - lfsr_data_t data; - int err = lfsr_bshrub_lookupnext(&lfs, &file.b, pos, + lfs3_tag_t tag; + lfs3_bid_t weight; + lfs3_data_t data; + int err = lfs3_bshrub_lookupnext(&lfs3, &file.b, pos, &pos, &tag, &weight, &data); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("pos = %d, %d\n", pos, weight); - lfsr_bshrub_commit(&lfs, &file.b, pos, LFSR_RATTRS( - LFSR_RATTR_DATA( - LFSR_TAG_GROW | tag, -(weight/2), + lfs3_bshrub_commit(&lfs3, &file.b, pos, LFS3_RATTRS( + LFS3_RATTR_DATA( + LFS3_TAG_GROW | tag, -(weight/2), &data))) => 0; pos = pos - (weight/2) + 1; } - file.b.o.flags |= LFS_o_UNSYNC; - lfsr_file_close(&lfs, &file) => 0; + file.b.o.flags |= LFS3_o_UNSYNC; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE/2); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE/2); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE/2; + lfs3_file_size(&lfs3, &file) => SIZE/2; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE/2; - for (lfs_size_t i = 0; i < SIZE/FRAGMENT_SIZE; i++) { + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE/2; + for (lfs3_size_t i = 0; i < SIZE/FRAGMENT_SIZE; i++) { assert(memcmp( &rbuf[i*FRAGMENT_SIZE/2], &wbuf[i*FRAGMENT_SIZE], FRAGMENT_SIZE/2) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we don't error on blocks > weight @@ -4983,100 +4993,100 @@ if = [ 'CHUNK <= SIZE', 'BLOCK_SIZE > 1', ] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { wbuf[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // reduce the weight of each btree entry // // this should normally never happen, so we need to use the // internal bshrub APIs to force this - lfsr_file_open(&lfs, &file, "hello", LFS_O_WRONLY) => 0; - lfs_off_t pos = 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; + lfs3_off_t pos = 0; while (true) { - lfsr_tag_t tag; - lfsr_bid_t weight; - lfsr_data_t data; - int err = lfsr_bshrub_lookupnext(&lfs, &file.b, pos, + lfs3_tag_t tag; + lfs3_bid_t weight; + lfs3_data_t data; + int err = lfs3_bshrub_lookupnext(&lfs3, &file.b, pos, &pos, &tag, &weight, &data); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("pos = %d, %d\n", pos, weight); - lfsr_bshrub_commit(&lfs, &file.b, pos, LFSR_RATTRS( - LFSR_RATTR_DATA( - LFSR_TAG_GROW | tag, -(weight/2), + lfs3_bshrub_commit(&lfs3, &file.b, pos, LFS3_RATTRS( + LFS3_RATTR_DATA( + LFS3_TAG_GROW | tag, -(weight/2), &data))) => 0; pos = pos - (weight/2) + 1; } - file.b.o.flags |= LFS_o_UNSYNC; - lfsr_file_close(&lfs, &file) => 0; + file.b.o.flags |= LFS3_o_UNSYNC; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE/2); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE/2); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => SIZE/2; + lfs3_file_size(&lfs3, &file) => SIZE/2; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => SIZE/2; - for (lfs_size_t i = 0; i < SIZE/BLOCK_SIZE; i++) { + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => SIZE/2; + for (lfs3_size_t i = 0; i < SIZE/BLOCK_SIZE; i++) { assert(memcmp( &rbuf[i*BLOCK_SIZE/2], &wbuf[i*BLOCK_SIZE], BLOCK_SIZE/2) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_gc.toml b/tests/test_gc.toml index ea00c5f4..05856926 100644 --- a/tests/test_gc.toml +++ b/tests/test_gc.toml @@ -9,9 +9,9 @@ after = ['test_traversal'] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - LFS_GC_LOOKAHEAD - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + LFS3_GC_LOOKAHEAD + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] defines.SIZE = [ @@ -22,52 +22,52 @@ defines.SIZE = [ '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // expect dirty initial state or else our test doesn't work - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_LOOKAHEAD); - assert(lfs.omdirs != &lfs.gc.t.b.o); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_LOOKAHEAD); + assert(lfs3.omdirs != &lfs3.gc.t.b.o); // run GC until we make progress - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - if (!(fsinfo.flags & LFS_I_LOOKAHEAD)) { + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + if (!(fsinfo.flags & LFS3_I_LOOKAHEAD)) { break; } } // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that lookahead dirtying still works with the GC API @@ -75,9 +75,9 @@ code = ''' defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - LFS_GC_LOOKAHEAD - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + LFS3_GC_LOOKAHEAD + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.SIZE = [ 'FILE_CACHE_SIZE/2', @@ -89,61 +89,61 @@ defines.SIZE = [ ] # we need something to keep the traversal running if = 'CKMETA || CKDATA' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // expect dirty initial state or else our test doesn't work - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_LOOKAHEAD); - assert(lfs.omdirs != &lfs.gc.t.b.o); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_LOOKAHEAD); + assert(lfs3.omdirs != &lfs3.gc.t.b.o); // run GC one step - lfsr_fs_gc(&lfs) => 0; - assert(lfs.omdirs == &lfs.gc.t.b.o); + lfs3_fs_gc(&lfs3) => 0; + assert(lfs3.omdirs == &lfs3.gc.t.b.o); // mutate the filesystem - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // run GC until our traversal is done - while (lfs.omdirs == &lfs.gc.t.b.o) { - lfsr_fs_gc(&lfs) => 0; + while (lfs3.omdirs == &lfs3.gc.t.b.o) { + lfs3_fs_gc(&lfs3) => 0; } // we should _not_ make progress - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_LOOKAHEAD); + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_LOOKAHEAD); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -153,10 +153,10 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - LFS_GC_COMPACT - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + LFS3_GC_COMPACT + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -169,45 +169,45 @@ defines.SIZE = [ '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // write to our mdir until >gc_compact_thresh full - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // hack, don't use the internals like this uint8_t wbuf[SIZE]; while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } // expect dirty initial state or else our test doesn't work - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_COMPACT); - assert(lfs.omdirs != &lfs.gc.t.b.o); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_COMPACT); + assert(lfs3.omdirs != &lfs3.gc.t.b.o); // run GC until we make progress - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - if (!(fsinfo.flags & LFS_I_COMPACT)) { + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + if (!(fsinfo.flags & LFS3_I_COMPACT)) { break; } } @@ -219,20 +219,20 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that compact dirtying still works with the GC API @@ -241,10 +241,10 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - LFS_GC_COMPACT - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + LFS3_GC_COMPACT + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' @@ -258,83 +258,83 @@ defines.SIZE = [ ] # we need something to keep the traversal running if = 'CKMETA || CKDATA' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // write to our mdir until >gc_compact_thresh full - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // hack, don't use the internals like this uint8_t wbuf[SIZE]; while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } // expect dirty initial state or else our test doesn't work - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_COMPACT); - assert(lfs.omdirs != &lfs.gc.t.b.o); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_COMPACT); + assert(lfs3.omdirs != &lfs3.gc.t.b.o); // run GC one traversal + one step while (true) { - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // internal traversal done? - if (lfs.omdirs != &lfs.gc.t.b.o) { + if (lfs3.omdirs != &lfs3.gc.t.b.o) { break; } } - lfsr_fs_gc(&lfs) => 0; - assert(lfs.omdirs == &lfs.gc.t.b.o); + lfs3_fs_gc(&lfs3) => 0; + assert(lfs3.omdirs == &lfs3.gc.t.b.o); // mutate the filesystem - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; // run GC until our traversal is done (twice for compact) - while (lfs.omdirs == &lfs.gc.t.b.o) { - lfsr_fs_gc(&lfs) => 0; + while (lfs3.omdirs == &lfs3.gc.t.b.o) { + lfs3_fs_gc(&lfs3) => 0; } // we should _not_ make progress - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_COMPACT); + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_COMPACT); // check we can still read the file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -345,45 +345,45 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - LFS_GC_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + LFS3_GC_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] defines.SIZE = 'FILE_CACHE_SIZE/2' # <=2 => grm-able # >2 => requires orphans defines.ORPHANS = [1, 2, 3, 100] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create this many orphaned files // @@ -392,32 +392,35 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // expect dirty initial state or else our test doesn't work - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_MKCONSISTENT); - assert(lfs.omdirs != &lfs.gc.t.b.o); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_MKCONSISTENT); + assert(lfs3.omdirs != &lfs3.gc.t.b.o); // run GC until we make progress - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - if (!(fsinfo.flags & LFS_I_MKCONSISTENT)) { + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + if (!(fsinfo.flags & LFS3_I_MKCONSISTENT)) { break; } } @@ -426,30 +429,30 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test that an explicit lfsr_fs_mkconsistent call also works, this calls +# test that an explicit lfs3_fs_mkconsistent call also works, this calls # the same logic internally [cases.test_gc_mkconsistent_explicit] defines.SIZE = 'FILE_CACHE_SIZE/2' @@ -457,32 +460,32 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' # >2 => requires orphans defines.ORPHANS = [1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create this many orphaned files // @@ -491,57 +494,60 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // expect dirty initial state or else our test doesn't work - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_MKCONSISTENT); - #ifdef LFS_GC - assert(lfs.omdirs != &lfs.gc.t.b.o); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_MKCONSISTENT); + #ifdef LFS3_GC + assert(lfs3.omdirs != &lfs3.gc.t.b.o); #endif - // call lfsr_fs_mkconsistent - lfsr_fs_mkconsistent(&lfs) => 0; + // call lfs3_fs_mkconsistent + lfs3_fs_mkconsistent(&lfs3) => 0; // we should have made progress - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_MKCONSISTENT)); + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_MKCONSISTENT)); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that mkconsistent dirtying still works with the GC API @@ -551,11 +557,11 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - LFS_GC_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + LFS3_GC_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.SIZE = 'FILE_CACHE_SIZE/2' # <=2 => grm-able @@ -563,102 +569,108 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' defines.ORPHANS = [3, 100] # we need something to keep the traversal running if = 'CKMETA || CKDATA' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create at least 3 orphans so GC will start - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < 3; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < 3; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < 3; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < 3; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // run GC one step - assert(lfs.omdirs != &lfs.gc.t.b.o); - lfsr_fs_gc(&lfs) => 0; - assert(lfs.omdirs == &lfs.gc.t.b.o); + assert(lfs3.omdirs != &lfs3.gc.t.b.o); + lfs3_fs_gc(&lfs3) => 0; + assert(lfs3.omdirs == &lfs3.gc.t.b.o); // create the rest of the orphans after GC has started - for (lfs_size_t i = 0; i < ORPHANS; i++) { + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // we should now have dirty state - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_MKCONSISTENT); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_MKCONSISTENT); // run GC until our traversal is done - while (lfs.omdirs == &lfs.gc.t.b.o) { - lfsr_fs_gc(&lfs) => 0; + while (lfs3.omdirs == &lfs3.gc.t.b.o) { + lfs3_fs_gc(&lfs3) => 0; } // we should _not_ make progress - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(fsinfo.flags & LFS_I_MKCONSISTENT); + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(fsinfo.flags & LFS3_I_MKCONSISTENT); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -666,7 +678,7 @@ code = ''' # # these are tested more thoroughly in test_ck [cases.test_gc_ckmeta] -defines.GC_FLAGS = 'LFS_GC_CKMETA' +defines.GC_FLAGS = 'LFS3_GC_CKMETA' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -679,55 +691,55 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] if = '(SIZE*N)/BLOCK_SIZE <= 32' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -736,9 +748,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -747,26 +759,26 @@ code = ''' } clobbered:; - // running lfsr_fs_gc should eventually find the clobbered block - for (lfs_block_t i = 0;; i++) { + // running lfs3_fs_gc should eventually find the clobbered block + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - int err = lfsr_fs_gc(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); + int err = lfs3_fs_gc(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); // found it - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' [cases.test_gc_ckdata] -defines.GC_FLAGS = 'LFS_GC_CKDATA' +defines.GC_FLAGS = 'LFS3_GC_CKDATA' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -779,56 +791,56 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] if = '(SIZE*N)/BLOCK_SIZE <= 32' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -837,9 +849,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -848,27 +860,27 @@ code = ''' } clobbered:; - // running lfsr_fs_gc should eventually find the clobbered block + // running lfs3_fs_gc should eventually find the clobbered block // - // note LFS_GC_CKDATA implies LFS_GC_CKMETA - for (lfs_block_t i = 0;; i++) { + // note LFS3_GC_CKDATA implies LFS3_GC_CKMETA + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - int err = lfsr_fs_gc(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); + int err = lfs3_fs_gc(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); // found it - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' -# test that our explicit functions (lfsr_fs_ckmeta/ckdata) work as well, +# test that our explicit functions (lfs3_fs_ckmeta/ckdata) work as well, # these call the same logic internally [cases.test_gc_ckmeta_explicit] defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -883,53 +895,53 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -938,9 +950,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -949,10 +961,10 @@ code = ''' } clobbered:; - // lfsr_fs_ckmeta should find the clobbered block - lfsr_fs_ckmeta(&lfs) => LFS_ERR_CORRUPT; + // lfs3_fs_ckmeta should find the clobbered block + lfs3_fs_ckmeta(&lfs3) => LFS3_ERR_CORRUPT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -970,54 +982,54 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1026,9 +1038,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -1037,24 +1049,24 @@ code = ''' } clobbered:; - // lfsr_fs_ckdata should find the clobbered block - lfsr_fs_ckdata(&lfs) => LFS_ERR_CORRUPT; + // lfs3_fs_ckdata should find the clobbered block + lfs3_fs_ckdata(&lfs3) => LFS3_ERR_CORRUPT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' # test we can detect fully clobbered blocks after a ck pass, if we call -# lfsr_fs_unck +# lfs3_fs_unck [cases.test_gc_ckmeta_unck] -# AFTER=0 => after running lfsr_fs_gc once -# AFTER=1 => after running lfsr_fs_gc to completion -# AFTER=2 => after running lfsr_traversal_t -# AFTER=3 => after lfsr_fs_ckmeta -# AFTER=4 => after remounting with LFS_M_CKMETA +# AFTER=0 => after running lfs3_fs_gc once +# AFTER=1 => after running lfs3_fs_gc to completion +# AFTER=2 => after running lfs3_traversal_t +# AFTER=3 => after lfs3_fs_ckmeta +# AFTER=4 => after remounting with LFS3_M_CKMETA defines.AFTER = [0, 1, 2, 3, 4] -defines.GC_FLAGS = 'LFS_GC_CKMETA' +defines.GC_FLAGS = 'LFS3_GC_CKMETA' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -1067,109 +1079,109 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] if = '(SIZE*N)/BLOCK_SIZE <= 32' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } - // run lfsr_fs_gc before clobbering, this should not find + // run lfs3_fs_gc before clobbering, this should not find // anything - // run lfsr_fs_gc once + // run lfs3_fs_gc once if (AFTER == 0) { - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; - // run lfsr_fs_gc to completion + // run lfs3_fs_gc to completion } else if (AFTER == 1) { while (true) { - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - if (!(fsinfo.flags & LFS_I_CKMETA)) { + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + if (!(fsinfo.flags & LFS3_I_CKMETA)) { break; } - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } - // run lfsr_traversal_t + // run lfs3_traversal_t } else if (AFTER == 2) { - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDWR | GC_FLAGS) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - // run lfsr_fs_ckmeta + // run lfs3_fs_ckmeta } else if (AFTER == 3) { - lfsr_fs_ckmeta(&lfs) => 0; + lfs3_fs_ckmeta(&lfs3) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_CKMETA)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_CKMETA)); - // remount with LFS_M_CKMETA + // remount with LFS3_M_CKMETA } else if (AFTER == 4) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKMETA, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKMETA, CFG) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_CKMETA)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_CKMETA)); } else { assert(false); } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1178,9 +1190,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -1190,34 +1202,34 @@ code = ''' clobbered:; // clear relevant ck flags - lfsr_fs_unck(&lfs, LFS_I_CKMETA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA) => 0; - // running lfsr_fs_gc should eventually find the clobbered block - for (lfs_block_t i = 0;; i++) { + // running lfs3_fs_gc should eventually find the clobbered block + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - int err = lfsr_fs_gc(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); + int err = lfs3_fs_gc(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); // found it - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' [cases.test_gc_ckdata_unck] -# AFTER=0 => after running lfsr_fs_gc once -# AFTER=1 => after running lfsr_fs_gc to completion -# AFTER=2 => after running lfsr_traversal_t -# AFTER=3 => after lfsr_fs_ckdata -# AFTER=4 => after remounting with LFS_M_CKDATA +# AFTER=0 => after running lfs3_fs_gc once +# AFTER=1 => after running lfs3_fs_gc to completion +# AFTER=2 => after running lfs3_traversal_t +# AFTER=3 => after lfs3_fs_ckdata +# AFTER=4 => after remounting with LFS3_M_CKDATA defines.AFTER = [0, 1, 2, 3, 4] -defines.GC_FLAGS = 'LFS_GC_CKDATA' +defines.GC_FLAGS = 'LFS3_GC_CKDATA' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] defines.N = [1, 2, 4, 8, 16, 32, 64] defines.SIZE = [ @@ -1230,110 +1242,110 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] if = '(SIZE*N)/BLOCK_SIZE <= 32' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } - // run lfsr_fs_gc before clobbering, this should not find + // run lfs3_fs_gc before clobbering, this should not find // anything - // run lfsr_fs_gc once + // run lfs3_fs_gc once if (AFTER == 0) { - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; - // run lfsr_fs_gc to completion + // run lfs3_fs_gc to completion } else if (AFTER == 1) { while (true) { - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - if (!(fsinfo.flags & LFS_I_CKDATA)) { + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + if (!(fsinfo.flags & LFS3_I_CKDATA)) { break; } - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } - // run lfsr_traversal_t + // run lfs3_traversal_t } else if (AFTER == 2) { - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDWR | GC_FLAGS) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - // run lfsr_fs_ckdata + // run lfs3_fs_ckdata } else if (AFTER == 3) { - lfsr_fs_ckdata(&lfs) => 0; + lfs3_fs_ckdata(&lfs3) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_CKDATA)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_CKDATA)); - // remount with LFS_M_CKDATA + // remount with LFS3_M_CKDATA } else if (AFTER == 4) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | LFS_M_CKDATA, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | LFS3_M_CKDATA, CFG) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_CKDATA)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_CKDATA)); } else { assert(false); } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1342,9 +1354,9 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -1354,33 +1366,33 @@ code = ''' clobbered:; // clear relevant ck flags - lfsr_fs_unck(&lfs, LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKDATA) => 0; - // running lfsr_fs_gc should eventually find the clobbered block + // running lfs3_fs_gc should eventually find the clobbered block // - // note LFS_GC_CKDATA implies LFS_GC_CKMETA - for (lfs_block_t i = 0;; i++) { + // note LFS3_GC_CKDATA implies LFS3_GC_CKMETA + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops - LFS_ASSERT(i < 2*BLOCK_COUNT); + LFS3_ASSERT(i < 2*BLOCK_COUNT); - int err = lfsr_fs_gc(&lfs); - assert(!err || err == LFS_ERR_CORRUPT); + int err = lfs3_fs_gc(&lfs3); + assert(!err || err == LFS3_ERR_CORRUPT); // found it - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' -# test that gc work clears flags in lfsr_fs_stat +# test that gc work clears flags in lfs3_fs_stat [cases.test_gc_iflags] -# AFTER=0 => after running lfsr_fs_gc -# AFTER=1 => after running lfsr_traversal_t +# AFTER=0 => after running lfs3_fs_gc +# AFTER=1 => after running lfs3_traversal_t # AFTER=2 => after explicit operations # AFTER=3 => after remounting defines.AFTER = [0, 1, 2, 3] @@ -1390,11 +1402,11 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1409,78 +1421,78 @@ defines.SIZE = [ ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, AFTER != 0)', + 'LFS3_IFDEF_GC(true, AFTER != 0)', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // remount to reset flags - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check that flags were reset - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // run gc if (AFTER == 0) { - #ifdef LFS_GC - lfsr_fs_gc(&lfs) => 0; + #ifdef LFS3_GC + lfs3_fs_gc(&lfs3) => 0; #else assert(false); #endif - // run lfsr_traversal_t + // run lfs3_traversal_t } else if (AFTER == 1) { while (true) { // it may take multiple traversals to do all pending work - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; if (!(fsinfo.flags & ( - ((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_I_COMPACT : 0) - | ((CKMETA) ? LFS_I_CKMETA : 0) - | ((CKDATA) ? LFS_I_CKDATA : 0)))) { + ((MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_I_COMPACT : 0) + | ((CKMETA) ? LFS3_I_CKMETA : 0) + | ((CKDATA) ? LFS3_I_CKDATA : 0)))) { break; } - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDWR | GC_FLAGS) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } // run explicit operations @@ -1489,87 +1501,87 @@ code = ''' } else if (AFTER == 2) { while (true) { // it may take multiple traversals to do all pending work - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; if (!(fsinfo.flags & ( - ((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_I_COMPACT : 0) - | ((CKMETA) ? LFS_I_CKMETA : 0) - | ((CKDATA) ? LFS_I_CKDATA : 0)))) { + ((MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_I_COMPACT : 0) + | ((CKMETA) ? LFS3_I_CKMETA : 0) + | ((CKDATA) ? LFS3_I_CKDATA : 0)))) { break; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } if (LOOKAHEAD) { // we need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR | LFS_T_LOOKAHEAD) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } if (COMPACT) { // we need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR | LFS_T_COMPACT) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR | LFS3_T_COMPACT) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } if (CKMETA) { - lfsr_fs_ckmeta(&lfs) => 0; + lfs3_fs_ckmeta(&lfs3) => 0; } if (CKDATA) { - lfsr_fs_ckdata(&lfs) => 0; + lfs3_fs_ckdata(&lfs3) => 0; } } // remount with gc flags } else if (AFTER == 3) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | GC_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | GC_FLAGS, CFG) => 0; } else { assert(false); } // did these clear the right flags? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((!COMPACT) ? LFS_I_COMPACT : 0) + ((!MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((!COMPACT) ? LFS3_I_COMPACT : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# test that gc work clears flags in lfsr_fs_stat after lfsr_fs_unck +# test that gc work clears flags in lfs3_fs_stat after lfs3_fs_unck [cases.test_gc_iflags_unck] -# AFTER=0 => after running lfsr_fs_gc -# AFTER=1 => after running lfsr_traversal_t +# AFTER=0 => after running lfs3_fs_gc +# AFTER=1 => after running lfs3_traversal_t # AFTER=2 => after explicit operations # AFTER=3 => after remounting defines.AFTER = [0, 1, 2, 3] @@ -1579,11 +1591,11 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = -1 defines.N = [1, 2, 4, 8, 16, 32, 64] @@ -1598,78 +1610,78 @@ defines.SIZE = [ ] if = [ '(SIZE*N)/BLOCK_SIZE <= 32', - 'LFS_IFDEF_GC(true, AFTER != 0)', + 'LFS3_IFDEF_GC(true, AFTER != 0)', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // remount to reset flags - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check that flags were reset - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // run gc if (AFTER == 0) { - #ifdef LFS_GC - lfsr_fs_gc(&lfs) => 0; + #ifdef LFS3_GC + lfs3_fs_gc(&lfs3) => 0; #else assert(false); #endif - // run lfsr_traversal_t + // run lfs3_traversal_t } else if (AFTER == 1) { while (true) { // it may take multiple traversals to do all pending work - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; if (!(fsinfo.flags & ( - ((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_I_COMPACT : 0) - | ((CKMETA) ? LFS_I_CKMETA : 0) - | ((CKDATA) ? LFS_I_CKDATA : 0)))) { + ((MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_I_COMPACT : 0) + | ((CKMETA) ? LFS3_I_CKMETA : 0) + | ((CKDATA) ? LFS3_I_CKDATA : 0)))) { break; } - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDWR | GC_FLAGS) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } // run explicit operations @@ -1678,127 +1690,127 @@ code = ''' } else if (AFTER == 2) { while (true) { // it may take multiple traversals to do all pending work - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; if (!(fsinfo.flags & ( - ((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_I_COMPACT : 0) - | ((CKMETA) ? LFS_I_CKMETA : 0) - | ((CKDATA) ? LFS_I_CKDATA : 0)))) { + ((MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_I_COMPACT : 0) + | ((CKMETA) ? LFS3_I_CKMETA : 0) + | ((CKDATA) ? LFS3_I_CKDATA : 0)))) { break; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } if (LOOKAHEAD) { // we need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR | LFS_T_LOOKAHEAD) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } if (COMPACT) { // we need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR | LFS_T_COMPACT) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR | LFS3_T_COMPACT) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } if (CKMETA) { - lfsr_fs_ckmeta(&lfs) => 0; + lfs3_fs_ckmeta(&lfs3) => 0; } if (CKDATA) { - lfsr_fs_ckdata(&lfs) => 0; + lfs3_fs_ckdata(&lfs3) => 0; } } // remount with gc flags } else if (AFTER == 3) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | GC_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | GC_FLAGS, CFG) => 0; } else { assert(false); } // did these clear the right flags? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((!COMPACT) ? LFS_I_COMPACT : 0) + ((!MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((!COMPACT) ? LFS3_I_COMPACT : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); - // test that we can reset flags with lfsr_fs_unck - lfsr_fs_unck(&lfs, GC_FLAGS) => 0; + // test that we can reset flags with lfs3_fs_unck + lfs3_fs_unck(&lfs3, GC_FLAGS) => 0; // check that flags were reset - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT // note ckdata implies ckmeta, but uncking ckdata does // _not_ imply uncking ckmeta - | ((!(CKDATA && !CKMETA)) ? LFS_I_CKMETA : 0) - | LFS_I_CKDATA)); + | ((!(CKDATA && !CKMETA)) ? LFS3_I_CKMETA : 0) + | LFS3_I_CKDATA)); // run gc if (AFTER == 0) { - #ifdef LFS_GC - lfsr_fs_gc(&lfs) => 0; + #ifdef LFS3_GC + lfs3_fs_gc(&lfs3) => 0; #else assert(false); #endif - // run lfsr_traversal_t + // run lfs3_traversal_t } else if (AFTER == 1) { while (true) { // it may take multiple traversals to do all pending work - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; if (!(fsinfo.flags & ( - ((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_I_COMPACT : 0) - | ((CKMETA) ? LFS_I_CKMETA : 0) - | ((CKDATA) ? LFS_I_CKDATA : 0)))) { + ((MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_I_COMPACT : 0) + | ((CKMETA) ? LFS3_I_CKMETA : 0) + | ((CKDATA) ? LFS3_I_CKDATA : 0)))) { break; } - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDWR | GC_FLAGS) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDWR | GC_FLAGS) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } // run explicit operations @@ -1807,81 +1819,81 @@ code = ''' } else if (AFTER == 2) { while (true) { // it may take multiple traversals to do all pending work - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; if (!(fsinfo.flags & ( - ((MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_I_COMPACT : 0) - | ((CKMETA) ? LFS_I_CKMETA : 0) - | ((CKDATA) ? LFS_I_CKDATA : 0)))) { + ((MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_I_COMPACT : 0) + | ((CKMETA) ? LFS3_I_CKMETA : 0) + | ((CKDATA) ? LFS3_I_CKDATA : 0)))) { break; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } if (LOOKAHEAD) { // we need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR | LFS_T_LOOKAHEAD) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR | LFS3_T_LOOKAHEAD) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } if (COMPACT) { // we need an explicit traversal for this - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR | LFS_T_COMPACT) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR | LFS3_T_COMPACT) => 0; while (true) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(err == 0 || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(err == 0 || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; } if (CKMETA) { - lfsr_fs_ckmeta(&lfs) => 0; + lfs3_fs_ckmeta(&lfs3) => 0; } if (CKDATA) { - lfsr_fs_ckdata(&lfs) => 0; + lfs3_fs_ckdata(&lfs3) => 0; } } // remount with gc flags } else if (AFTER == 3) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | GC_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | GC_FLAGS, CFG) => 0; } else { assert(false); } // did these clear the right flags? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((!COMPACT) ? LFS_I_COMPACT : 0) + ((!MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((!COMPACT) ? LFS3_I_COMPACT : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1894,11 +1906,11 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -1911,50 +1923,50 @@ defines.SIZE = [ '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; for (uint32_t i = 0; i < N; i++) { // rewrite the file every gc cycle - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' -# pseudo-fuzz test that spamming lfsr_fs_unck doesn't break anything +# pseudo-fuzz test that spamming lfs3_fs_unck doesn't break anything [cases.test_gc_mutation_unck] defines.N = 100 defines.MKCONSISTENT = [false, true] @@ -1963,11 +1975,11 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -1980,51 +1992,51 @@ defines.SIZE = [ '2*BLOCK_SIZE', '8*BLOCK_SIZE', ] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; for (uint32_t i = 0; i < N; i++) { // rewrite the file every gc cycle - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // choose a random set of flags to unck every cycle uint32_t flags = GC_FLAGS & TEST_PRNG(&prng); - lfsr_fs_unck(&lfs, flags) => 0; + lfs3_fs_unck(&lfs3, flags) => 0; // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; } // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -2040,100 +2052,100 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test creating directories - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_gc_spam_dir_fuzz] @@ -2144,11 +2156,11 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -2157,27 +2169,27 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.OPS = '2*N' defines.SEED = 42 fuzz = 'SEED' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test fuzz with dirs - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2185,7 +2197,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -2196,47 +2208,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -2248,67 +2260,67 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_gc_spam_file_many] @@ -2319,11 +2331,11 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -2339,74 +2351,74 @@ defines.SIZE = [ '4*BLOCK_SIZE', ] if = '(SIZE*N)/BLOCK_SIZE <= 32' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test creating files - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_gc_spam_file_fuzz] @@ -2417,11 +2429,11 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -2440,32 +2452,32 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test fuzz with files - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -2474,7 +2486,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -2489,24 +2501,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2514,25 +2526,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -2545,7 +2557,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -2553,7 +2565,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -2568,82 +2580,82 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_gc_spam_fwrite_fuzz] @@ -2654,11 +2666,11 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -2686,121 +2698,121 @@ if = [ # this just saves testing time 'SIZE <= 4*1024*FRAGMENT_SIZE', ] -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test with complex file writes - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_gc_spam_uz_fuzz] @@ -2811,11 +2823,11 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -2834,31 +2846,31 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test with uncreats, zombies, etc - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -2869,13 +2881,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -2889,23 +2901,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -2917,7 +2929,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -2926,7 +2938,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -2946,26 +2958,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -2976,7 +2988,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -2992,8 +3004,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -3001,10 +3013,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -3015,7 +3027,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -3023,10 +3035,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -3044,17 +3056,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3062,7 +3074,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -3075,9 +3087,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -3086,16 +3098,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3111,7 +3123,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3121,7 +3133,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3135,7 +3147,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -3148,103 +3160,103 @@ code = ''' } // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_gc_spam_uzd_fuzz] @@ -3255,11 +3267,11 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.UNCK = [false, true] defines.GC_FLAGS = ''' - ((MKCONSISTENT) ? LFS_GC_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_GC_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_GC_COMPACT : 0) - | ((CKMETA) ? LFS_GC_CKMETA : 0) - | ((CKDATA) ? LFS_GC_CKDATA : 0) + ((MKCONSISTENT) ? LFS3_GC_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_GC_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_GC_COMPACT : 0) + | ((CKMETA) ? LFS3_GC_CKMETA : 0) + | ((CKDATA) ? LFS3_GC_CKDATA : 0) ''' defines.GC_STEPS = [-1, 1, 2, 10, 100, 1000] # set compact thresh to minimum @@ -3278,32 +3290,32 @@ defines.SIZE = [ defines.SEED = 42 fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' -ifdef = 'LFS_GC' +ifdef = 'LFS3_GC' code = ''' // test with uncreats, zombies, dirs, etc - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -3314,13 +3326,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -3337,23 +3349,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -3365,7 +3377,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -3374,7 +3386,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3397,26 +3409,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -3427,7 +3439,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -3443,19 +3455,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -3466,7 +3478,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -3474,10 +3486,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -3497,17 +3509,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3517,7 +3529,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -3530,14 +3542,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -3555,16 +3567,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3583,7 +3595,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -3595,7 +3607,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3612,7 +3624,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -3626,9 +3638,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -3641,14 +3653,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -3664,7 +3676,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -3672,118 +3684,118 @@ code = ''' } // gc! - lfsr_fs_gc(&lfs) => 0; + lfs3_fs_gc(&lfs3) => 0; // unck to keep things interesting? if (UNCK) { - lfsr_fs_unck(&lfs, LFS_I_CKMETA | LFS_I_CKDATA) => 0; + lfs3_fs_unck(&lfs3, LFS3_I_CKMETA | LFS3_I_CKDATA) => 0; } } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_grow.toml b/tests/test_grow.toml index fa2f1b99..70a31ad3 100644 --- a/tests/test_grow.toml +++ b/tests/test_grow.toml @@ -26,106 +26,106 @@ defines.BIGGER_BLOCK_COUNT = [ if = 'BIGGER_BLOCK_COUNT > SMALLER_BLOCK_COUNT' code = ''' // create a smaller fs - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = SMALLER_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // do some work - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[1024] = "Hello World!"; - lfs_size_t wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); uint8_t rbuf[1024]; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // try to mount with a bigger block count cfg = *CFG; cfg.block_count = BIGGER_BLOCK_COUNT; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // file still exists? - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); // do some work - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; strcpy((char*)wbuf, "Chris was here!"); wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // stays after a mount? - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // file still exists? - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we _can't_ mount a filesystem with more blocks @@ -145,48 +145,48 @@ defines.BIGGER_BLOCK_COUNT = [ if = 'BIGGER_BLOCK_COUNT > SMALLER_BLOCK_COUNT' code = ''' // create a bigger fs - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = BIGGER_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == BIGGER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // do some work - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[1024] = "Hello World!"; - lfs_size_t wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); uint8_t rbuf[1024]; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // try to mount with a smaller block count cfg = *CFG; cfg.block_count = SMALLER_BLOCK_COUNT; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => LFS3_ERR_NOTSUP; ''' # test we can grow a filesystem @@ -206,108 +206,108 @@ defines.BIGGER_BLOCK_COUNT = [ if = 'BIGGER_BLOCK_COUNT > SMALLER_BLOCK_COUNT' code = ''' // create a smaller fs - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = SMALLER_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // do some work - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[1024] = "Hello World!"; - lfs_size_t wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); uint8_t rbuf[1024]; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // try to grow our filesystem cfg = *CFG; cfg.block_count = BIGGER_BLOCK_COUNT; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; - lfsr_fs_grow(&lfs, BIGGER_BLOCK_COUNT) => 0; + lfs3_fs_grow(&lfs3, BIGGER_BLOCK_COUNT) => 0; // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == BIGGER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // file still exists? - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); // do some work - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; strcpy((char*)wbuf, "Chris was here!"); wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // stays after a mount? - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == BIGGER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // file still exists? - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # growing to the same size should do nothing @@ -321,114 +321,114 @@ defines.SMALLER_BLOCK_COUNT = [ ] code = ''' // create a smaller fs - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = SMALLER_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // do some work - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[1024] = "Hello World!"; - lfs_size_t wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_size_t wsize = strlen((char*)wbuf); + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); uint8_t rbuf[1024]; - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ////// // try to grow to same size cfg = *CFG; cfg.block_count = SMALLER_BLOCK_COUNT; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; - lfsr_fs_grow(&lfs, SMALLER_BLOCK_COUNT) => 0; + lfs3_fs_grow(&lfs3, SMALLER_BLOCK_COUNT) => 0; // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // file still exists? - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); // do some work - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; strcpy((char*)wbuf, "Chris was here!"); wsize = strlen((char*)wbuf); - lfsr_file_write(&lfs, &file, wbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // stays after a mount? - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == SMALLER_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // file still exists? - lfsr_stat(&lfs, "hello", &info) => 0; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == wsize); - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, wsize) => wsize; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, wsize) => wsize; + lfs3_file_close(&lfs3, &file) => 0; assert(memcmp(rbuf, wbuf, wsize) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # These tests try various fuzz tests while incrementally growing the -# filesystem. When encountering LFS_ERR_NOSPC, the filesystem is grown by +# filesystem. When encountering LFS3_ERR_NOSPC, the filesystem is grown by # one block. Hopefully this will catch most grow-related bugs. # @@ -438,29 +438,29 @@ defines.REMOUNT = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { again:; char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -468,21 +468,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -495,16 +495,16 @@ code = ''' // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } @@ -512,64 +512,64 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_grow_incr_spam_dir_fuzz] @@ -581,27 +581,27 @@ defines.SEED = 'range(10)' fuzz = 'SEED' code = ''' // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { again:; uint32_t prng_ = prng; // choose a pseudo-random op, either mkdir, remove, or rename @@ -609,19 +609,19 @@ code = ''' if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -629,7 +629,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -639,59 +639,59 @@ code = ''' } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng_) % N; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng_) % N; // rename this directory char old_name[256]; sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -704,21 +704,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - int err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -731,16 +731,16 @@ code = ''' // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } @@ -748,52 +748,52 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_grow_incr_spam_file_many] @@ -812,23 +812,23 @@ defines.SIZE = [ if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { again:; uint32_t prng_ = prng; // create this many files @@ -836,26 +836,26 @@ code = ''' sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_t file; - int err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + lfs3_file_t file; + int err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; goto grow; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -864,21 +864,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -891,16 +891,16 @@ code = ''' // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } @@ -908,38 +908,38 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_grow_incr_spam_file_fuzz] @@ -961,28 +961,28 @@ fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { again:; uint32_t prng_ = prng; // choose which operation to do @@ -991,7 +991,7 @@ code = ''' // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng_); @@ -1000,31 +1000,31 @@ code = ''' sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_t file; - int err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + lfs3_file_t file; + int err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; goto grow; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -1033,7 +1033,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -1047,21 +1047,21 @@ code = ''' // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -1070,9 +1070,9 @@ code = ''' } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng_) % N; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng_) % N; uint32_t wprng = sim_prngs[j]; // rename this file @@ -1080,20 +1080,20 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -1106,7 +1106,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -1114,7 +1114,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -1130,21 +1130,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - int err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -1157,16 +1157,16 @@ code = ''' // remount? if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } @@ -1174,67 +1174,67 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_grow_incr_spam_uz_fuzz] @@ -1255,39 +1255,39 @@ fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { again:; uint32_t prng_ = prng; nonsense:; @@ -1300,13 +1300,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -1320,16 +1320,16 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { free(sim_files[j]); goto grow; } @@ -1338,14 +1338,14 @@ code = ''' if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - LFS_ASSERT(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + LFS3_ASSERT(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); goto grow; } @@ -1359,7 +1359,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1368,7 +1368,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1388,27 +1388,27 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng_) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng_); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { goto grow; } - int err = lfsr_file_sync(&lfs, &sim_files[j]->file); - assert(err == 0 || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_sync(&lfs3, &sim_files[j]->file); + assert(err == 0 || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -1416,7 +1416,7 @@ code = ''' sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -1427,7 +1427,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -1443,8 +1443,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng_) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -1452,10 +1452,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -1466,7 +1466,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -1474,10 +1474,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -1495,21 +1495,21 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1517,7 +1517,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1530,9 +1530,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng_) % N; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng_) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -1541,20 +1541,20 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1570,7 +1570,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1580,7 +1580,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1594,7 +1594,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -1611,21 +1611,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - int err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -1637,104 +1637,104 @@ code = ''' used, block_count_); // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_grow_incr_spam_uzd_fuzz] @@ -1755,40 +1755,40 @@ fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { again:; uint32_t prng_ = prng; nonsense:; @@ -1801,13 +1801,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -1824,16 +1824,16 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { free(sim_files[j]); goto grow; } @@ -1842,15 +1842,15 @@ code = ''' if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { free(sim_files[j]); - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; goto grow; } } @@ -1863,7 +1863,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1872,7 +1872,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1895,27 +1895,27 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng_) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng_); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfs_ssize_t d = lfsr_file_write(&lfs, &sim_files[j]->file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { goto grow; } - int err = lfsr_file_sync(&lfs, &sim_files[j]->file); - assert(err == 0 || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_file_sync(&lfs3, &sim_files[j]->file); + assert(err == 0 || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -1923,7 +1923,7 @@ code = ''' sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -1934,7 +1934,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -1950,19 +1950,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng_) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -1973,7 +1973,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -1981,10 +1981,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -2004,21 +2004,21 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -2028,7 +2028,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -2041,14 +2041,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng_) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng_) % N; + lfs3_size_t j = TEST_PRNG(&prng_) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng_) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -2066,20 +2066,20 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -2098,7 +2098,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -2110,7 +2110,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -2127,7 +2127,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -2141,9 +2141,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -2156,18 +2156,18 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -2183,7 +2183,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -2195,21 +2195,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - int err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + int err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -2221,120 +2221,120 @@ code = ''' used, block_count_); // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # A general purpose powerloss fuzz test @@ -2365,86 +2365,86 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - err = lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDONLY); - assert(!err || err == LFS_ERR_NOENT); + lfs3_file_t state_file; + err = lfs3_file_open(&lfs3, &state_file, "state", LFS3_O_RDONLY); + assert(!err || err == LFS3_ERR_NOENT); if (!err) { - lfsr_file_read(&lfs, &state_file, + lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; } uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { again:; uint32_t prng_ = prng; // choose which operation to do uint8_t op = TEST_PRNG(&prng_) % 3; // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 0 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; uint32_t wprng = TEST_PRNG(&prng_); // create a file here @@ -2452,7 +2452,7 @@ code = ''' sprintf(name, "test/amethyst%03x", x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -2461,45 +2461,45 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; goto grow; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng_) % count; + lfs3_size_t j = TEST_PRNG(&prng_) % count; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "test/%s", info.name); - err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -2507,16 +2507,16 @@ code = ''' } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng_) % count; - lfs_size_t y = TEST_PRNG(&prng_) % N; + lfs3_size_t j = TEST_PRNG(&prng_) % count; + lfs3_size_t y = TEST_PRNG(&prng_) % N; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this file char old_name[256]; @@ -2524,9 +2524,9 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/amethyst%03x", y); - err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } } @@ -2534,22 +2534,22 @@ code = ''' // update our state file state.i = i; state.prng = prng_; - err = lfsr_file_open(&lfs, &state_file, "state", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_open(&lfs3, &state_file, "state", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - lfs_ssize_t d = lfsr_file_write(&lfs, &state_file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)); - assert(d == sizeof(state) || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &state_file) => 0; + assert(d == sizeof(state) || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &state_file) => 0; goto grow; } - err = lfsr_file_close(&lfs, &state_file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &state_file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -2558,21 +2558,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -2584,11 +2584,11 @@ code = ''' used, block_count_); // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } @@ -2596,57 +2596,57 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // at least try to read the files char name[256]; sprintf(name, "test/%s", info.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # A general purpose powerloss fuzz test, with directories! @@ -2678,120 +2678,120 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { // start with a small number of blocks - struct lfs_config cfg = *CFG; + struct lfs3_config cfg = *CFG; cfg.block_count = INIT_BLOCK_COUNT; - lfsr_format(&lfs, LFS_F_RDWR, &cfg) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, &cfg) => 0; // mount with maximum block count - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // fsstat up to date? - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == INIT_BLOCK_COUNT); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - err = lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDONLY); - assert(!err || err == LFS_ERR_NOENT); + lfs3_file_t state_file; + err = lfs3_file_open(&lfs3, &state_file, "state", LFS3_O_RDONLY); + assert(!err || err == LFS3_ERR_NOENT); if (!err) { - lfsr_file_read(&lfs, &state_file, + lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; } uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { again:; uint32_t prng_ = prng; // choose which operation to do uint8_t op = TEST_PRNG(&prng_) % 6; // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // how many dirs do we have? - lfs_size_t dir_count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t dir_count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("quartz...")); assert(memcmp(info.name, "quartz", strlen("quartz")) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); dir_count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // dir op? if (op < 3 || dir_count == 0) { // creating a new dir? if (op == 0 || dir_count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % N; + lfs3_size_t x = TEST_PRNG(&prng_) % N; // create a dir here char name[256]; sprintf(name, "test/quartz%03x", x); - err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // deleting a dir? } else if (op == 1) { // choose a random dir to delete - lfs_size_t j = TEST_PRNG(&prng_) % dir_count; + lfs3_size_t j = TEST_PRNG(&prng_) % dir_count; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // try to delete this dir, ignore non-empty dirs! char name[256]; assert(strlen(info.name) == strlen("quartz...")); sprintf(name, "test/%s", info.name); - err = lfsr_remove(&lfs, name); + err = lfs3_remove(&lfs3, name); assert(!err - || err == LFS_ERR_NOTEMPTY - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_NOTEMPTY + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -2799,16 +2799,16 @@ code = ''' } else { // choose a random dir to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng_) % dir_count; - lfs_size_t y = TEST_PRNG(&prng_) % N; + lfs3_size_t j = TEST_PRNG(&prng_) % dir_count; + lfs3_size_t y = TEST_PRNG(&prng_) % N; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this dir, ignore conflicts! char old_name[256]; @@ -2816,11 +2816,11 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/quartz%03x", y); - err = lfsr_rename(&lfs, old_name, new_name); + err = lfs3_rename(&lfs3, old_name, new_name); assert(!err - || err == LFS_ERR_NOTEMPTY - || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + || err == LFS3_ERR_NOTEMPTY + || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } } @@ -2828,49 +2828,49 @@ code = ''' // file op? } else { // choose a pseudo-random dir - lfs_size_t dir_i = TEST_PRNG(&prng_) % dir_count; + lfs3_size_t dir_i = TEST_PRNG(&prng_) % dir_count; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= dir_i; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= dir_i; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; char dir_path[256]; sprintf(dir_path, "test/%s", info.name); // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp( info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 3 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng_) % M; + lfs3_size_t x = TEST_PRNG(&prng_) % M; uint32_t wprng = TEST_PRNG(&prng_); // create a file here @@ -2878,7 +2878,7 @@ code = ''' sprintf(name, "%s/amethyst%03x", dir_path, x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -2887,75 +2887,75 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - lfs_ssize_t d = lfsr_file_write(&lfs, &file, wbuf, SIZE); - assert(d == SIZE || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_ssize_t d = lfs3_file_write(&lfs3, &file, wbuf, SIZE); + assert(d == SIZE || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &file) => 0; goto grow; } - err = lfsr_file_close(&lfs, &file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // deleting a file? } else if (op == 4) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng_) % count; + lfs3_size_t j = TEST_PRNG(&prng_) % count; // find the file - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "%s/%s", dir_path, info.name); - err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } // renaming a file? } else { // choose a random file to rename - lfs_size_t j = TEST_PRNG(&prng_) % count; + lfs3_size_t j = TEST_PRNG(&prng_) % count; // find the file - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // choose a random dir to rename to - lfs_size_t dir_j = TEST_PRNG(&prng_) % dir_count; + lfs3_size_t dir_j = TEST_PRNG(&prng_) % dir_count; // find the dir - struct lfs_info info_; - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info_) => 0; - lfsr_dir_read(&lfs, &dir, &info_) => 0; - for (lfs_size_t k = 0; k <= dir_j; k++) { - lfsr_dir_read(&lfs, &dir, &info_) => 0; + struct lfs3_info info_; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info_) => 0; + lfs3_dir_read(&lfs3, &dir, &info_) => 0; + for (lfs3_size_t k = 0; k <= dir_j; k++) { + lfs3_dir_read(&lfs3, &dir, &info_) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // choose a random file to rename to - lfs_size_t y = TEST_PRNG(&prng_) % M; + lfs3_size_t y = TEST_PRNG(&prng_) % M; // rename this file char old_name[256]; @@ -2963,9 +2963,9 @@ code = ''' sprintf(old_name, "%s/%s", dir_path, info.name); char new_name[256]; sprintf(new_name, "test/%s/amethyst%03x", info_.name, y); - err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } } @@ -2974,22 +2974,22 @@ code = ''' // update our state file state.i = i; state.prng = prng_; - err = lfsr_file_open(&lfs, &state_file, "state", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_open(&lfs3, &state_file, "state", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } - lfs_ssize_t d = lfsr_file_write(&lfs, &state_file, + lfs3_ssize_t d = lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)); - assert(d == sizeof(state) || d == LFS_ERR_NOSPC); - if (d == LFS_ERR_NOSPC) { - lfsr_file_close(&lfs, &state_file) => 0; + assert(d == sizeof(state) || d == LFS3_ERR_NOSPC); + if (d == LFS3_ERR_NOSPC) { + lfs3_file_close(&lfs3, &state_file) => 0; goto grow; } - err = lfsr_file_close(&lfs, &state_file); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_file_close(&lfs3, &state_file); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { goto grow; } @@ -2998,21 +2998,21 @@ code = ''' grow:; // try growing the filesystem - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_count >= INIT_BLOCK_COUNT); assert(fsinfo.block_count <= BLOCK_COUNT); - lfs_ssize_t used = lfsr_fs_usage(&lfs); + lfs3_ssize_t used = lfs3_fs_usage(&lfs3); assert(used >= 0); // we may need to grow multiple blocks before the system gets unstuck - lfs_size_t block_count_ = fsinfo.block_count; + lfs3_size_t block_count_ = fsinfo.block_count; while (true) { assert(block_count_ < BLOCK_COUNT); block_count_ += 1; - err = lfsr_fs_grow(&lfs, block_count_); - assert(!err || err == LFS_ERR_NOSPC); - if (err == LFS_ERR_NOSPC) { + err = lfs3_fs_grow(&lfs3, block_count_); + assert(!err || err == LFS3_ERR_NOSPC); + if (err == LFS3_ERR_NOSPC) { continue; } @@ -3024,11 +3024,11 @@ code = ''' used, block_count_); // fsstat up to date? - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.block_size == BLOCK_SIZE); assert(fsinfo.block_count == block_count_); - assert(fsinfo.name_limit == LFS_NAME_MAX); - assert(fsinfo.file_limit == LFS_FILE_MAX); + assert(fsinfo.name_limit == LFS3_NAME_MAX); + assert(fsinfo.file_limit == LFS3_FILE_MAX); goto again; } @@ -3036,85 +3036,85 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("quartz...")); assert(memcmp(info.name, "quartz", strlen("quartz")) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // check that our dirs look more-or-less ok char name[256]; sprintf(name, "test/%s", info.name); - lfsr_dir_t dir_; - lfsr_dir_open(&lfs, &dir_, name) => 0; - struct lfs_info info_; - lfsr_dir_read(&lfs, &dir_, &info_) => 0; + lfs3_dir_t dir_; + lfs3_dir_open(&lfs3, &dir_, name) => 0; + struct lfs3_info info_; + lfs3_dir_read(&lfs3, &dir_, &info_) => 0; assert(strcmp(info_.name, ".") == 0); - assert(info_.type == LFS_TYPE_DIR); + assert(info_.type == LFS3_TYPE_DIR); assert(info_.size == 0); - lfsr_dir_read(&lfs, &dir_, &info_) => 0; + lfs3_dir_read(&lfs3, &dir_, &info_) => 0; assert(strcmp(info_.name, "..") == 0); - assert(info_.type == LFS_TYPE_DIR); + assert(info_.type == LFS3_TYPE_DIR); assert(info_.size == 0); while (true) { - err = lfsr_dir_read(&lfs, &dir_, &info_); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + err = lfs3_dir_read(&lfs3, &dir_, &info_); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info_.name) == strlen("amethyst...")); assert(memcmp( info_.name, "amethyst", strlen("amethyst")) == 0); - assert(info_.type == LFS_TYPE_REG); + assert(info_.type == LFS3_TYPE_REG); assert(info_.size == SIZE); // at least try to read the files sprintf(name, "test/%s/%s", info.name, info_.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir_) => 0; + lfs3_dir_close(&lfs3, &dir_) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_mount.toml b/tests/test_mount.toml index c61f6701..4c3ce1a7 100644 --- a/tests/test_mount.toml +++ b/tests/test_mount.toml @@ -5,14 +5,14 @@ after = ['test_mtree', 'test_traversal'] # test we can mount [cases.test_mount_simple] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that various mount flags don't assert and are returned by -# lfsr_fs_stat +# lfs3_fs_stat [cases.test_mount_flags] defines.RDONLY = [false, true] defines.FLUSH = [false, true] @@ -29,66 +29,66 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = [ - 'LFS_IFDEF_REVDBG(true, !REVDBG)', - 'LFS_IFDEF_REVNOISE(true, !REVNOISE)', + 'LFS3_IFDEF_REVDBG(true, !REVDBG)', + 'LFS3_IFDEF_REVNOISE(true, !REVNOISE)', '!REVDBG || !REVNOISE', - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', '!RDONLY || !MKCONSISTENT', '!RDONLY || !LOOKAHEAD', '!RDONLY || !COMPACT', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, - ((RDONLY) ? LFS_M_RDONLY : LFS_M_RDWR) - | ((FLUSH) ? LFS_M_FLUSH : 0) - | ((SYNC) ? LFS_M_SYNC : 0) - | ((REVDBG) ? LFS_IFDEF_REVDBG(LFS_M_REVDBG, -1) : 0) - | ((REVNOISE) ? LFS_IFDEF_REVNOISE(LFS_M_REVNOISE, -1) : 0) - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_M_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_M_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, + ((RDONLY) ? LFS3_M_RDONLY : LFS3_M_RDWR) + | ((FLUSH) ? LFS3_M_FLUSH : 0) + | ((SYNC) ? LFS3_M_SYNC : 0) + | ((REVDBG) ? LFS3_IFDEF_REVDBG(LFS3_M_REVDBG, -1) : 0) + | ((REVNOISE) ? LFS3_IFDEF_REVNOISE(LFS3_M_REVNOISE, -1) : 0) + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_M_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_M_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_M_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_M_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_M_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_M_CKDATACKSUMREADS, -1) : 0) - | ((MKCONSISTENT) ? LFS_M_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_M_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_M_COMPACT : 0) - | ((CKMETA) ? LFS_M_CKMETA : 0) - | ((CKDATA) ? LFS_M_CKDATA : 0), + | ((MKCONSISTENT) ? LFS3_M_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_M_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_M_COMPACT : 0) + | ((CKMETA) ? LFS3_M_CKMETA : 0) + | ((CKDATA) ? LFS3_M_CKDATA : 0), CFG) => 0; - // lfsr_fs_stat only returns some flags - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + // lfs3_fs_stat only returns some flags + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((RDONLY) ? LFS_I_RDONLY : 0) - | ((FLUSH) ? LFS_I_FLUSH : 0) - | ((SYNC) ? LFS_I_SYNC : 0) - | ((REVDBG) ? LFS_IFDEF_REVDBG(LFS_M_REVDBG, -1) : 0) - | ((REVNOISE) ? LFS_IFDEF_REVNOISE(LFS_M_REVNOISE, -1) : 0) - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_I_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_I_CKFETCHES, -1) : 0) + ((RDONLY) ? LFS3_I_RDONLY : 0) + | ((FLUSH) ? LFS3_I_FLUSH : 0) + | ((SYNC) ? LFS3_I_SYNC : 0) + | ((REVDBG) ? LFS3_IFDEF_REVDBG(LFS3_M_REVDBG, -1) : 0) + | ((REVNOISE) ? LFS3_IFDEF_REVNOISE(LFS3_M_REVNOISE, -1) : 0) + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_I_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_I_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_I_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_I_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_I_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_I_CKDATACKSUMREADS, -1) : 0) - | ((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((!COMPACT) ? LFS_I_COMPACT : 0) + | ((!MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((!COMPACT) ? LFS3_I_COMPACT : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that various format flags don't, uh, assert or anything @@ -104,34 +104,34 @@ defines.CKDATACKSUMREADS = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = [ - 'LFS_IFDEF_REVDBG(true, !REVDBG)', - 'LFS_IFDEF_REVNOISE(true, !REVNOISE)', + 'LFS3_IFDEF_REVDBG(true, !REVDBG)', + 'LFS3_IFDEF_REVNOISE(true, !REVNOISE)', '!REVDBG || !REVNOISE', - 'LFS_IFDEF_CKPROGS(true, !CKPROGS)', - 'LFS_IFDEF_CKFETCHES(true, !CKFETCHES)', - 'LFS_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', - 'LFS_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', + 'LFS3_IFDEF_CKPROGS(true, !CKPROGS)', + 'LFS3_IFDEF_CKFETCHES(true, !CKFETCHES)', + 'LFS3_IFDEF_CKMETAPARITY(true, !CKMETAPARITY)', + 'LFS3_IFDEF_CKDATACKSUMREADS(true, !CKDATACKSUMREADS)', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, - LFS_F_RDWR - | ((REVDBG) ? LFS_IFDEF_REVDBG(LFS_F_REVDBG, -1) : 0) - | ((REVNOISE) ? LFS_IFDEF_REVNOISE(LFS_F_REVNOISE, -1) : 0) - | ((CKPROGS) ? LFS_IFDEF_CKPROGS(LFS_F_CKPROGS, -1) : 0) - | ((CKFETCHES) ? LFS_IFDEF_CKFETCHES(LFS_F_CKFETCHES, -1) : 0) + lfs3_t lfs3; + lfs3_format(&lfs3, + LFS3_F_RDWR + | ((REVDBG) ? LFS3_IFDEF_REVDBG(LFS3_F_REVDBG, -1) : 0) + | ((REVNOISE) ? LFS3_IFDEF_REVNOISE(LFS3_F_REVNOISE, -1) : 0) + | ((CKPROGS) ? LFS3_IFDEF_CKPROGS(LFS3_F_CKPROGS, -1) : 0) + | ((CKFETCHES) ? LFS3_IFDEF_CKFETCHES(LFS3_F_CKFETCHES, -1) : 0) | ((CKMETAPARITY) - ? LFS_IFDEF_CKMETAPARITY(LFS_F_CKMETAPARITY, -1) + ? LFS3_IFDEF_CKMETAPARITY(LFS3_F_CKMETAPARITY, -1) : 0) | ((CKDATACKSUMREADS) - ? LFS_IFDEF_CKDATACKSUMREADS(LFS_F_CKDATACKSUMREADS, -1) + ? LFS3_IFDEF_CKDATACKSUMREADS(LFS3_F_CKDATACKSUMREADS, -1) : 0) - | ((CKMETA) ? LFS_F_CKMETA : 0) - | ((CKDATA) ? LFS_F_CKDATA : 0), + | ((CKMETA) ? LFS3_F_CKMETA : 0) + | ((CKDATA) ? LFS3_F_CKDATA : 0), CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -141,36 +141,36 @@ code = ''' defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // by default we need a lookahead scan - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); + lfs3_unmount(&lfs3) => 0; - // with LFS_M_LOOKAHEAD, mount performs a lookahead scan - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_LOOKAHEAD - | ((CKMETA) ? LFS_M_CKMETA : 0) - | ((CKDATA) ? LFS_M_CKDATA : 0), + // with LFS3_M_LOOKAHEAD, mount performs a lookahead scan + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_LOOKAHEAD + | ((CKMETA) ? LFS3_M_CKMETA : 0) + | ((CKDATA) ? LFS3_M_CKDATA : 0), CFG) => 0; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_COMPACT + LFS3_I_MKCONSISTENT + | LFS3_I_COMPACT // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); - lfsr_unmount(&lfs) => 0; + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_t_compact] @@ -188,72 +188,72 @@ defines.SIZE = [ # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; uint32_t prng = 42; // first lets create a compactable filesystem - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // write to our mdir until >gc_compact_thresh full - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jellyfish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jellyfish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // hack, don't use the internals like this uint8_t wbuf[SIZE]; while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // by default mount does not compact - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); + lfs3_unmount(&lfs3) => 0; - // with LFS_M_COMPACT, mount compact any uncompacted blocks - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_COMPACT - | ((LOOKAHEAD) ? LFS_M_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_M_CKMETA : 0) - | ((CKDATA) ? LFS_M_CKDATA : 0), + // with LFS3_M_COMPACT, mount compact any uncompacted blocks + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_COMPACT + | ((LOOKAHEAD) ? LFS3_M_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_M_CKMETA : 0) + | ((CKDATA) ? LFS3_M_CKDATA : 0), CFG) => 0; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + LFS3_I_MKCONSISTENT + | ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // mdir should have been compacted - lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0; assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // check we can still read the file uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_t_mkconsistent] @@ -266,33 +266,33 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; uint32_t prng = 42; // first lets create some orphans - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "cuttlefish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "cuttlefish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "octopus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create this many orphaned files // @@ -301,61 +301,64 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // by default we clean up orphans lazily - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); + lfs3_unmount(&lfs3) => 0; - // with LFS_M_MKCONSISTENT, mount cleans up orphans eagerly - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_M_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_M_COMPACT : 0) - | ((CKMETA) ? LFS_M_CKMETA : 0) - | ((CKDATA) ? LFS_M_CKDATA : 0), + // with LFS3_M_MKCONSISTENT, mount cleans up orphans eagerly + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_M_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_M_COMPACT : 0) + | ((CKMETA) ? LFS3_M_CKMETA : 0) + | ((CKDATA) ? LFS3_M_CKDATA : 0), CFG) => 0; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((!COMPACT) ? LFS_I_COMPACT : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((!COMPACT) ? LFS3_I_COMPACT : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the files - lfsr_file_open(&lfs, &file, "cuttlefish", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "cuttlefish", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "octopus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "octopus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can detect at least fully clobbered blocks @@ -374,53 +377,53 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -429,10 +432,10 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto clobbered; } } @@ -441,11 +444,11 @@ code = ''' } clobbered:; - // mount with LFS_M_CKMETA, we should detect clobbered blocks - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_CKMETA, - CFG) => LFS_ERR_CORRUPT; + // mount with LFS3_M_CKMETA, we should detect clobbered blocks + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_CKMETA, + CFG) => LFS3_ERR_CORRUPT; } done:; ''' @@ -463,54 +466,54 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_block_t i = 0; + lfs3_block_t i = 0; while (true) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting filesystem uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "squid%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } // this gets a bit tricky be cause we need to clobber both // blocks in mdir pairs - if (tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -519,10 +522,10 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - if (tinfo.btype != LFS_BTYPE_MDIR || k == i+1) { - i += (tinfo.btype == LFS_BTYPE_MDIR) ? 2 : 1; - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + if (tinfo.btype != LFS3_BTYPE_MDIR || k == i+1) { + i += (tinfo.btype == LFS3_BTYPE_MDIR) ? 2 : 1; + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto clobbered; } } @@ -531,13 +534,13 @@ code = ''' } clobbered:; - // mount with LFS_M_CKDATA, we should detect clobbered blocks + // mount with LFS3_M_CKDATA, we should detect clobbered blocks // - // note LFS_M_CKDATA implies LFS_M_CKMETA - lfsr_mount(&lfs, - LFS_M_RDWR - | LFS_M_CKDATA, - CFG) => LFS_ERR_CORRUPT; + // note LFS3_M_CKDATA implies LFS3_M_CKMETA + lfs3_mount(&lfs3, + LFS3_M_RDWR + | LFS3_M_CKDATA, + CFG) => LFS3_ERR_CORRUPT; } done:; ''' @@ -548,248 +551,248 @@ done:; # test that we fail if we find no magic [cases.test_mount_incompat_no_magic] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // delete the magic string // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MAGIC, 0))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MAGIC, 0))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_CORRUPT; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_CORRUPT; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_CORRUPT; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_CORRUPT; ''' # test that we fail if we find bad magic [cases.test_mount_incompat_bad_magic] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // tweak the magic string // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MAGIC, 0, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MAGIC, 0, "lottlefs", 8))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_CORRUPT; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_CORRUPT; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_CORRUPT; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_CORRUPT; ''' # test that we fail to mount after a major version bump [cases.test_mount_incompat_major] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // bump the major version // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_VERSION, 0, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_VERSION, 0, ((const uint8_t[2]){ - LFS_DISK_VERSION_MAJOR+1, + LFS3_DISK_VERSION_MAJOR+1, 0}), 2))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test that we fail to mount after a minor version bump [cases.test_mount_incompat_minor] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // bump the minor version // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_VERSION, 0, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_VERSION, 0, ((const uint8_t[2]){ - LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR+1}), 2))) => 0; - lfsr_unmount(&lfs) => 0; + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR+1}), 2))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test that we fail to mount incompatible rcompat flags [cases.test_mount_incompat_rcompat] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set the nonstandard rcompat flag, this will always be incompatible // with standard littlefs // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_LE32( - LFSR_TAG_RCOMPAT, 0, - LFSR_RCOMPAT_COMPAT - | LFSR_RCOMPAT_NONSTANDARD))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_LE32( + LFS3_TAG_RCOMPAT, 0, + LFS3_RCOMPAT_COMPAT + | LFS3_RCOMPAT_NONSTANDARD))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test that we fail to mount incompatible wcompat flags [cases.test_mount_incompat_wcompat] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set the nonstandard rcompat flag, this will always be incompatible // with standard littlefs // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_LE32( - LFSR_TAG_WCOMPAT, 0, - LFSR_WCOMPAT_COMPAT - | LFSR_WCOMPAT_NONSTANDARD))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_LE32( + LFS3_TAG_WCOMPAT, 0, + LFS3_WCOMPAT_COMPAT + | LFS3_WCOMPAT_NONSTANDARD))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; // but we _can_ mount readonly - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that an incompatible ocompat flag is a noop [cases.test_mount_incompat_ocompat] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set the nonstandard ocompat flag, this will always be incompatible // with standard littlefs // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_LE32( - LFSR_TAG_OCOMPAT, 0, - LFSR_OCOMPAT_COMPAT - | LFSR_OCOMPAT_NONSTANDARD))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_LE32( + LFS3_TAG_OCOMPAT, 0, + LFS3_OCOMPAT_COMPAT + | LFS3_OCOMPAT_NONSTANDARD))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, ocompat should always be ignored - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we fail to mount rdonly images [cases.test_mount_incompat_rdonly] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set the rdonly flag, this prevents writing from a littlefs image // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_LE32( - LFSR_TAG_WCOMPAT, 0, - LFSR_WCOMPAT_COMPAT - | LFSR_WCOMPAT_RDONLY))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_LE32( + LFS3_TAG_WCOMPAT, 0, + LFS3_WCOMPAT_COMPAT + | LFS3_WCOMPAT_RDONLY))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; // but we _can_ mount readonly - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we fail to mount wronly images [cases.test_mount_incompat_wronly] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set the wronly flag, this prevents reading from a littlefs image // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_LE32( - LFSR_TAG_RCOMPAT, 0, - LFSR_RCOMPAT_COMPAT - | LFSR_RCOMPAT_WRONLY))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_LE32( + LFS3_TAG_RCOMPAT, 0, + LFS3_RCOMPAT_COMPAT + | LFS3_RCOMPAT_WRONLY))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # these are just a bit harder to detect [cases.test_mount_incompat_rcompat_overflow] defines.OVERFLOW = 72 defines.FLAG = 'range(72)' -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set a really far rcompat flag // @@ -799,28 +802,28 @@ code = ''' memset(overflow, 0, sizeof(overflow)); overflow[FLAG / 8] |= 1 << (FLAG % 8); - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t rcompat_buf[LFSR_LE32_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_RCOMPAT, 0, - lfsr_data_fromle32(LFSR_RCOMPAT_COMPAT, rcompat_buf), - LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t rcompat_buf[LFS3_LE32_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_RCOMPAT, 0, + lfs3_data_fromle32(LFS3_RCOMPAT_COMPAT, rcompat_buf), + LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' [cases.test_mount_incompat_wcompat_overflow] defines.OVERFLOW = 72 defines.FLAG = 'range(72)' -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; uint8_t flags[9] = {0}; flags[FLAG / 8] |= 1 << (FLAG % 8); @@ -833,31 +836,31 @@ code = ''' memset(overflow, 0, sizeof(overflow)); overflow[FLAG / 8] |= 1 << (FLAG % 8); - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t wcompat_buf[LFSR_LE32_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_WCOMPAT, 0, - lfsr_data_fromle32(LFSR_WCOMPAT_COMPAT, wcompat_buf), - LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t wcompat_buf[LFS3_LE32_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_WCOMPAT, 0, + lfs3_data_fromle32(LFS3_WCOMPAT_COMPAT, wcompat_buf), + LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; // but we _can_ mount readonly - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_ocompat_overflow] defines.OVERFLOW = 72 defines.FLAG = 'range(72)' -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set a really far ocompat flag // @@ -867,30 +870,30 @@ code = ''' memset(overflow, 0, sizeof(overflow)); overflow[FLAG / 8] |= 1 << (FLAG % 8); - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t ocompat_buf[LFSR_LE32_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_OCOMPAT, 0, - lfsr_data_fromle32(LFSR_OCOMPAT_COMPAT, ocompat_buf), - LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t ocompat_buf[LFS3_LE32_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_OCOMPAT, 0, + lfs3_data_fromle32(LFS3_OCOMPAT_COMPAT, ocompat_buf), + LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, ocompat should always be ignored - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # but just appending zeros is _not_ an error [cases.test_mount_incompat_rcompat_padding] defines.OVERFLOW = 72 -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set a really far rcompat flag // @@ -899,29 +902,29 @@ code = ''' uint8_t overflow[OVERFLOW / 8]; memset(overflow, 0, sizeof(overflow)); - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t rcompat_buf[LFSR_LE32_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_RCOMPAT, 0, - lfsr_data_fromle32(LFSR_RCOMPAT_COMPAT, rcompat_buf), - LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t rcompat_buf[LFS3_LE32_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_RCOMPAT, 0, + lfs3_data_fromle32(LFS3_RCOMPAT_COMPAT, rcompat_buf), + LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, extra zeros should be ignored - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_wcompat_padding] defines.OVERFLOW = 72 -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; uint8_t flags[9] = {0}; flags[FLAG / 8] |= 1 << (FLAG % 8); @@ -933,29 +936,29 @@ code = ''' uint8_t overflow[OVERFLOW / 8]; memset(overflow, 0, sizeof(overflow)); - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t wcompat_buf[LFSR_LE32_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_WCOMPAT, 0, - lfsr_data_fromle32(LFSR_WCOMPAT_COMPAT, wcompat_buf), - LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t wcompat_buf[LFS3_LE32_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_WCOMPAT, 0, + lfs3_data_fromle32(LFS3_WCOMPAT_COMPAT, wcompat_buf), + LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, extra zeros should be ignored - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_ocompat_padding] defines.OVERFLOW = 72 -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set a really far ocompat flag // @@ -964,1010 +967,1010 @@ code = ''' uint8_t overflow[OVERFLOW / 8]; memset(overflow, 0, sizeof(overflow)); - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t ocompat_buf[LFSR_LE32_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_OCOMPAT, 0, - lfsr_data_fromle32(LFSR_OCOMPAT_COMPAT, ocompat_buf), - LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t ocompat_buf[LFS3_LE32_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_OCOMPAT, 0, + lfs3_data_fromle32(LFS3_OCOMPAT_COMPAT, ocompat_buf), + LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, extra zeros should be ignored - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we fail to mount incompatible block sizes [cases.test_mount_incompat_block_size] defines.INC_BLOCK_SIZE = ['BLOCK_SIZE/2', 'BLOCK_SIZE*2'] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set an incompatible block size // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_GEOMETRY( - LFSR_TAG_GEOMETRY, 0, - (&(lfsr_geometry_t){ + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_GEOMETRY( + LFS3_TAG_GEOMETRY, 0, + (&(lfs3_geometry_t){ INC_BLOCK_SIZE, BLOCK_COUNT})))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test that we fail to mount after incompatible block counts [cases.test_mount_incompat_block_count] defines.INC_BLOCK_COUNT = ['BLOCK_COUNT*2'] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set an incompatible block count // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_GEOMETRY( - LFSR_TAG_GEOMETRY, 0, - (&(lfsr_geometry_t){ + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_GEOMETRY( + LFS3_TAG_GEOMETRY, 0, + (&(lfs3_geometry_t){ BLOCK_SIZE, INC_BLOCK_COUNT})))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test that we fail to mount after incompatible name limit [cases.test_mount_incompat_name_limit] -defines.INC_NAME_LIMIT = ['LFS_NAME_MAX*2'] -in = 'lfs.c' +defines.INC_NAME_LIMIT = ['LFS3_NAME_MAX*2'] +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set an incompatible block size // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_LEB128( - LFSR_TAG_NAMELIMIT, 0, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_LEB128( + LFS3_TAG_NAMELIMIT, 0, INC_NAME_LIMIT))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test that we fail to mount after incompatible file limit [cases.test_mount_incompat_file_limit] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // set an incompatible file limit // // note we're messing around with internals to do this! this // is not a user API - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t file_limit_buf[LFSR_LEB128_DSIZE]; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_FILELIMIT, 0, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + uint8_t file_limit_buf[LFS3_LEB128_DSIZE]; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_FILELIMIT, 0, // it's a bit difficult to test this since file limit // is usually our integer limit, but we can force a // larger value by inserting an extra byte into our // leb128 encoding - LFSR_DATA_BUF("\xff", 1), - lfsr_data_fromleb128(LFS_FILE_MAX, file_limit_buf)))) => 0; - lfsr_unmount(&lfs) => 0; + LFS3_DATA_BUF("\xff", 1), + lfs3_data_fromleb128(LFS3_FILE_MAX, file_limit_buf)))) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test what happens if we find an unknown config [cases.test_mount_incompat_unknown_config] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create an unknown config - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_CONFIG + 0x42, 0, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_CONFIG + 0x42, 0, "oh no!", strlen("oh no!")))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_NOTSUP; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_NOTSUP; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_NOTSUP; ''' # test what happens if we find an unknown file type [cases.test_mount_incompat_unknown_type] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi c!", strlen("hi c!")) => strlen("hi c!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // open/mkdir should error - lfsr_file_open(&lfs, &file, "b", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTSUP; - lfsr_mkdir(&lfs, "b") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "b") => LFS3_ERR_EXIST; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_rm] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi c!", strlen("hi c!")) => strlen("hi c!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // removing unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_remove(&lfs, "b") => 0; + lfs3_remove(&lfs3, "b") => 0; // check that things look reasonable - lfsr_stat(&lfs, "b", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "b", &info) => LFS3_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_mv_src] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi c!", strlen("hi c!")) => strlen("hi c!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // renaming unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_rename(&lfs, "b", "c") => 0; + lfs3_rename(&lfs3, "b", "c") => 0; // check that things look reasonable after renaming/removing - lfsr_stat(&lfs, "c", &info) => 0; + lfs3_stat(&lfs3, "c", &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_mv_dst] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi c!", strlen("hi c!")) => strlen("hi c!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // renaming unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_rename(&lfs, "c", "b") => 0; + lfs3_rename(&lfs3, "c", "b") => 0; // check that things look reasonable after renaming/removing - lfsr_stat(&lfs, "b", &info) => 0; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_mv_src_dst] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh hi!", strlen("oh hi!")) => strlen("oh hi!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "c"; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // renaming unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_rename(&lfs, "b", "c") => 0; + lfs3_rename(&lfs3, "b", "c") => 0; // check that things look reasonable after renaming/removing - lfsr_stat(&lfs, "c", &info) => 0; + lfs3_stat(&lfs3, "c", &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_mv_noop] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi c!", strlen("hi c!")) => strlen("hi c!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // renaming unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_rename(&lfs, "b", "b") => 0; + lfs3_rename(&lfs3, "b", "b") => 0; // check that things look reasonable after renaming/removing - lfsr_stat(&lfs, "b", &info) => 0; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi c!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_mv_notdir] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_mkdir(&lfs, "c") => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_mkdir(&lfs3, "c") => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // renaming unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_rename(&lfs, "c", "b") => LFS_ERR_NOTDIR; + lfs3_rename(&lfs3, "c", "b") => LFS3_ERR_NOTDIR; // check that things look reasonable after renaming/removing - lfsr_stat(&lfs, "b", &info) => 0; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mount_incompat_unknown_type_mv_isdir] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // create some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "a", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "a", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hi a!", strlen("hi a!")) => strlen("hi a!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "b", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "b", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "oh no!", strlen("oh no!")) => strlen("oh no!"); - lfsr_file_close(&lfs, &file) => 0; - lfsr_mkdir(&lfs, "c") => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_mkdir(&lfs3, "c") => 0; + lfs3_unmount(&lfs3) => 0; // change a file's type to something unknown - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; const char *path = "b"; - lfsr_mdir_t mdir; - lfsr_did_t did; - lfsr_mtree_pathlookup(&lfs, &path, + lfs3_mdir_t mdir; + lfs3_did_t did; + lfs3_mtree_pathlookup(&lfs3, &path, &mdir, NULL, &did) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_MASK8 | (LFSR_TAG_NAME + 0x13), 0, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + lfs3_unmount(&lfs3) => 0; // mount - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // our file should appear as an unknown type - struct lfs_info info; - lfsr_stat(&lfs, "b", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // renaming unknown files should still work, if this would leak // resources the new type should set a wcompat flag - lfsr_rename(&lfs, "b", "c") => LFS_ERR_ISDIR; + lfs3_rename(&lfs3, "b", "c") => LFS3_ERR_ISDIR; // check that things look reasonable after renaming/removing - lfsr_stat(&lfs, "b", &info) => 0; + lfs3_stat(&lfs3, "b", &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "a") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("hi a!")); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "b") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "c") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1982,30 +1985,30 @@ code = ''' # [cases.test_mount_incompat_out_of_phase] defines.PHASE = [1, 2, 3, 4] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a superblock - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; // with some files - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "r2d2", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "r2d2", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; char wbuf[256]; strcpy(wbuf, "beep boop"); - lfsr_file_write(&lfs, &file, wbuf, strlen(wbuf)) => strlen(wbuf); - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c3po", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, strlen(wbuf)) => strlen(wbuf); + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c3po", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; strcpy(wbuf, "we seem to be made to suffer"); - lfsr_file_write(&lfs, &file, wbuf, strlen(wbuf)) => strlen(wbuf); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, strlen(wbuf)) => strlen(wbuf); + lfs3_file_close(&lfs3, &file) => 0; // shift the filesystem out-of-phase uint8_t shift_buf[BLOCK_SIZE]; - for (lfs_size_t i = 0; i < 4; i++) { + for (lfs3_size_t i = 0; i < 4; i++) { CFG->read(CFG, 4-1-i, 0, shift_buf, BLOCK_SIZE) => 0; CFG->erase(CFG, 4-1-i + PHASE) => 0; CFG->prog(CFG, 4-1-i + PHASE, 0, shift_buf, BLOCK_SIZE) => 0; @@ -2018,6 +2021,6 @@ code = ''' } // mount should now fail - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => LFS_ERR_CORRUPT; - lfsr_mount(&lfs, LFS_M_RDONLY, CFG) => LFS_ERR_CORRUPT; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => LFS3_ERR_CORRUPT; + lfs3_mount(&lfs3, LFS3_M_RDONLY, CFG) => LFS3_ERR_CORRUPT; ''' diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 5747e33d..ddc94e39 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -10,16 +10,16 @@ defines.LOOKAHEAD_SIZE = '(BLOCK_COUNT+8-1) / 8' defines.REVDBG = [false, true] defines.REVNOISE = [false, true] defines.F_FLAGS = ''' - ((REVDBG) ? LFS_IFDEF_REVDBG(LFS_F_REVDBG, -1) : 0) - | ((REVNOISE) ? LFS_IFDEF_REVNOISE(LFS_F_REVNOISE, -1) : 0) + ((REVDBG) ? LFS3_IFDEF_REVDBG(LFS3_F_REVDBG, -1) : 0) + | ((REVNOISE) ? LFS3_IFDEF_REVNOISE(LFS3_F_REVNOISE, -1) : 0) ''' defines.M_FLAGS = ''' - ((REVDBG) ? LFS_IFDEF_REVDBG(LFS_M_REVDBG, -1) : 0) - | ((REVNOISE) ? LFS_IFDEF_REVNOISE(LFS_M_REVNOISE, -1) : 0) + ((REVDBG) ? LFS3_IFDEF_REVDBG(LFS3_M_REVDBG, -1) : 0) + | ((REVNOISE) ? LFS3_IFDEF_REVNOISE(LFS3_M_REVNOISE, -1) : 0) ''' if = [ - 'LFS_IFDEF_REVDBG(true, !REVDBG)', - 'LFS_IFDEF_REVNOISE(true, !REVNOISE)', + 'LFS3_IFDEF_REVDBG(true, !REVDBG)', + 'LFS3_IFDEF_REVNOISE(true, !REVNOISE)', '!REVDBG || !REVNOISE', ] @@ -28,139 +28,144 @@ if = [ # test a single mroot [cases.test_mtree_mroot] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test a single mroot with attributes [cases.test_mtree_mroot_rattrs] defines.N = [1, 3] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(i), 0, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(i), 0, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } - for (lfs_size_t i = 0; i < N; i++) { - lfsr_data_t data; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_data_t data; uint8_t buffer[1]; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, + LFS3_TAG_ATTR(i), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // check things stay sane after remount - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_data_t data; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_data_t data; uint8_t buffer[1]; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, + LFS3_TAG_ATTR(i), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test a single mroot with forced compaction [cases.test_mtree_mroot_compact] defines.N = [1, 3] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // force mroot to compact - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(i), 0, + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(i), 0, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } - for (lfs_size_t i = 0; i < N; i++) { - lfsr_data_t data; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_data_t data; uint8_t buffer[1]; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, + LFS3_TAG_ATTR(i), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // check things stay sane after remount - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_data_t data; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_data_t data; uint8_t buffer[1]; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(i), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, + LFS3_TAG_ATTR(i), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test a single mroot with many commits [cases.test_mtree_mroot_many_commits] defines.N = [5, 5000] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); - for (lfs_size_t i = 0; i < N; i++) { - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, &(uint8_t){'a'+(i % 26)}, 1))) => 0; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[4]; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, + LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[4]; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'a'+((N-1) % 26)}, 1) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // check things stay sane after remount - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, &(uint8_t){'a'+((N-1) % 26)}, 1) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -170,294 +175,294 @@ code = ''' [cases.test_mtree_uninline] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, buffer, SIZE))) => 0; // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_uninline_split] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_split] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now add another large entry to an mdir, forcing a split memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "e", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "e", 1))) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -465,80 +470,80 @@ code = ''' [cases.test_mtree_split_many] defines.N = [5, 10, 20, 40, 80, 160, 320] defines.FORCE_COMPACTION = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // create entries - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } // try looking up each entry - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_data_t data; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; 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, + if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) { + lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1, &mdir) => 0; } - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; 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, + if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) { + lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1, &mdir) => 0; } - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # create random entries @@ -547,22 +552,22 @@ defines.N = [5, 10, 20, 40, 80, 160] defines.FORCE_COMPACTION = [false, true] defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); bool sim[N]; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = false; } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // update sim sim[x] = true; @@ -571,77 +576,77 @@ code = ''' char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", x); - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); + assert(!err || err == LFS3_ERR_NOENT); if (!err) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + lfs3_data_t data; // double check uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } // try looking up each entry - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_data_t data; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -651,486 +656,486 @@ code = ''' [cases.test_mtree_drop] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_drop_compact] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_drop_uninline_split] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 2); // assert split/drop worked out - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_drop_split_l] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now add another large entry to an mdir, forcing a split memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'd'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert split/drop worked out - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'd'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_drop_split_r] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now add another large entry to an mdir, forcing a split memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert split/drop worked out - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_drop_fuzz] @@ -1138,22 +1143,22 @@ defines.N = [5, 10, 20, 40, 80, 160] defines.FORCE_COMPACTION = [false, true] defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); bool sim[N]; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = false; } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", x); @@ -1166,26 +1171,26 @@ code = ''' sim[x] = true; // update mtree - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); + assert(!err || err == LFS3_ERR_NOENT); if (!err) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + lfs3_data_t data; // double check uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); // delete @@ -1194,71 +1199,71 @@ code = ''' sim[x] = false; // update mtree - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; } } // try looking up each entry - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_data_t data; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1270,113 +1275,113 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, buffer, SIZE))) => 0; // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // force mdir to compact twice, this should relocate - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_t old_mdir = mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(4), 0, "d", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(5), 0, "e", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(5), 0, "e", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_relocate_l] @@ -1384,129 +1389,129 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // force mdir to compact twice, this should relocate memset(buffer+1, 'a', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_t old_mdir = mdir; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "e", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_relocate_r] @@ -1514,129 +1519,129 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // force mdir to compact twice, this should relocate memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_t old_mdir = mdir; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "e", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_extend] @@ -1644,73 +1649,73 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // prepare mroot with an entry uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "b", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "c", 1))) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert that our entry is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_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; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_extend_twice] @@ -1721,123 +1726,123 @@ defines.BLOCK_RECYCLES = 0 # force our block to compact by setting prog_size=block_size, we don't have # an easy way to force the intermediary mroots to compact otherwise defines.PROG_SIZE = 'BLOCK_SIZE' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // prepare mroot with an entry uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "b", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "c", 1))) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // force mroot to compact four times, this should relocate the mroot // twice, forcing a second mroot extension - old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "d", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(4), 0, "e", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(5), 0, "f", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(6), 0, "g", 1))) => 0; + old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "d", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "e", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(5), 0, "f", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(6), 0, "g", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'f'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'g'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_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; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'f'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'g'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_relocate_mroot] @@ -1845,100 +1850,100 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // prepare mroot with an entry uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "b", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "c", 1))) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // force mroot to compact twice again, this should relocate the mroot - old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "d", 1))) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(4), 0, "e", 1))) => 0; + old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "d", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "e", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert that our entry is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_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; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_relocate_extend] @@ -1946,134 +1951,134 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // setup mroot to compact and relocate on next commit - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_t old_mroot = lfs.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_t old_mroot = lfs3.mroot; // force mdir to compact twice, this should relocate memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_t old_mdir = mdir; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "e", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_split_extend] @@ -2081,149 +2086,149 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now add another large entry to an mdir, forcing a split memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // setup mroot to compact and relocate on next commit - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_t old_mroot = lfs.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_t old_mroot = lfs3.mroot; // force mdir to compact twice, this should relocate - lfsr_mdir_t old_mdir = mdir; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "e", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "e", 1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "f", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "f", 1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'f'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'd'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'e'); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'f'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_drop_extend] @@ -2231,102 +2236,102 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // setup mroot to compact and relocate on next commit - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_t old_mroot = lfs.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_t old_mroot = lfs3.mroot; // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; // force mdir to compact twice, this should relocate mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 0); // assert mroot relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was dropped - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_uninline_extend] @@ -2334,84 +2339,84 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // force mroot to compact once, so the second compact below will // trigger a relocation - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfsr_data_t data; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_data_t data; // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, buffer, SIZE))) => 0; // force mroot to compact, this should both uninline and relocate - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0; // assert mroot relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_uninline_split_extend] @@ -2419,98 +2424,98 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // force mroot to compact once, so the second compact below will // trigger a relocation - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfsr_data_t data; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact, this should both split and relocate - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mroot relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 1) => 1; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 1) => 1; assert(buffer[0] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # this fuzz covers a lot of configurations @@ -2520,22 +2525,22 @@ defines.FORCE_COMPACTION = [false, true] defines.BLOCK_RECYCLES = [4, 1, 0] defines.SEED = 'range(500)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); bool sim[N]; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = false; } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", x); @@ -2548,26 +2553,26 @@ code = ''' sim[x] = true; // update mtree - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); + assert(!err || err == LFS3_ERR_NOENT); if (!err) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + lfs3_data_t data; // double check uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); // update @@ -2575,28 +2580,28 @@ code = ''' // sim update is a noop // update mtree - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } // we can't really change metadata names, but commits still // trigger writes to the mdir - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, 0, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, 0, 0, name+1, 3))) => 0; + lfs3_data_t data; // double check uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); // delete @@ -2605,457 +2610,457 @@ code = ''' sim[x] = false; // update mtree - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; } } // try looking up each entry - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_data_t data; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' ## Opened mdir tracking ## [cases.test_mtree_opened] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "c", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "c", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "c", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "c", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // insert a new entry, this should update our neighbors - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, "b", 1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "b", 1))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; assert(mdir.rbyd.weight == 4); - lfsr_data_t data; + lfs3_data_t data; // assert our entry was created uint8_t buffer[2]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 2) => 2; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 2) => 2; assert(buffer[1] == 'b'); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "c", 1, + lfs3_mtree_namelookup(&lfs3, 0, "c", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_remove_l] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "b", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "b", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // try removing left neighbor - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "b", 1, + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_remove_r] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "b", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "b", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // try removing right neighbor - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, "b", 1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed - lfsr_mtree_namelookup(&lfs, 0, "b", 1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_uninline_split] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "d", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "d", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "d", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'b', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "d", 1, + lfs3_mtree_namelookup(&lfs3, 0, "d", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_split] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "e", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "e", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "e", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "e", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'b', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "e", 1, + lfs3_mtree_namelookup(&lfs3, 0, "e", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_extend] # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "b", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "b", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert that our neighbors were updated correctly - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "b", 1, + lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_relocate_l] @@ -3063,96 +3068,96 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "d", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "d", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "d", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'b', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // force mdir to compact twice, this should relocate memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_t old_mdir = mdir; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, 0, + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, 0, 0, (const char*)buffer+1, SIZE-1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, 0, + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, 0, 0, (const char*)buffer+1, SIZE-1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "d", 1, + lfs3_mtree_namelookup(&lfs3, 0, "d", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_relocate_r] @@ -3160,307 +3165,307 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "d", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "d", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "d", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'b', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // force mdir to compact twice, this should relocate memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_t old_mdir = mdir; + lfs3_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, 0, + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, 0, 0, (const char*)buffer+1, SIZE-1))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, 0, + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, 0, 0, (const char*)buffer+1, SIZE-1))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); + assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "d", 1, + lfs3_mtree_namelookup(&lfs3, 0, "d", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_middle_split] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "f", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "f", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "f", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "f", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'b', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'e', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now add _another_ large entry to the middle mdir, forcing another split memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (4 << lfs.mbits)); + assert(lfs3.mtree.weight == (4 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "f", 1, + lfs3_mtree_namelookup(&lfs3, 0, "f", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_opened_middle_drop] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // setup our neighbors - lfsr_omdir_t left = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_omdir_t left = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &left.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(left.mdir.rbyd.weight == 2); - lfsr_omdir_open(&lfs, &left); + lfs3_omdir_open(&lfs3, &left); - lfsr_omdir_t right = {.flags=0}; - lfsr_mtree_namelookup(&lfs, 0, "e", 1, - &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "e", 1))) => 0; + lfs3_omdir_t right = {.flags=0}; + lfs3_mtree_namelookup(&lfs3, 0, "e", 1, + &right.mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "e", 1))) => 0; assert(right.mdir.rbyd.weight == 3); - lfsr_omdir_open(&lfs, &right); + lfs3_omdir_open(&lfs3, &right); // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'b', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'd', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now remove the middle entry, forcing a drop - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped correctly - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our neighbors were updated correctly - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; assert(left.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&left.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&left.mdir, &mdir) == 0); assert(left.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(left.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_mtree_namelookup(&lfs, 0, "e", 1, + lfs3_mtree_namelookup(&lfs3, 0, "e", 1, &mdir, NULL, NULL) => 0; assert(right.mdir.mid == mdir.mid); - assert(lfsr_mdir_cmp(&right.mdir, &mdir) == 0); + assert(lfs3_mdir_cmp(&right.mdir, &mdir) == 0); assert(right.mdir.rbyd.trunk == mdir.rbyd.trunk); assert(right.mdir.rbyd.cksum == mdir.rbyd.cksum); - lfsr_omdir_close(&lfs, &left); - lfsr_omdir_close(&lfs, &right); - lfsr_unmount(&lfs) => 0; + lfs3_omdir_close(&lfs3, &left); + lfs3_omdir_close(&lfs3, &right); + lfs3_unmount(&lfs3) => 0; ''' @@ -3469,45 +3474,45 @@ code = ''' # test specific corner cases [cases.test_mtree_traversal] defines.CKMETA = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // insert at least one entry - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(mdir.rbyd.weight == 2); // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -3517,8 +3522,8 @@ code = ''' seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8); seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -3536,96 +3541,96 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; } } free(seen); - lfsr_data_t data; + lfs3_data_t data; // and the tree should still work // assert that our entry is still in the mtree uint8_t buffer[256]; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 2; assert(memcmp(buffer, "\0a", 2) == 0); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert that our entry is still in the mtree - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 2; assert(memcmp(buffer, "\0a", 2) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_traversal_uninline] defines.CKMETA = [false, true] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, buffer, SIZE))) => 0; // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -3635,8 +3640,8 @@ code = ''' seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8); seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -3654,7 +3659,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -3665,111 +3670,111 @@ code = ''' // and the tree should still work // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined - assert(lfs.mtree.weight == (1 << lfs.mbits)); + assert(lfs3.mtree.weight == (1 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our rattrs are still in the mroot/mtree - lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &lfs3.mroot, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'b'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_traversal_uninline_split] defines.CKMETA = [false, true] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -3779,8 +3784,8 @@ code = ''' seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8); seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -3798,7 +3803,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -3809,134 +3814,134 @@ code = ''' // and the tree should still work // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_traversal_split] defines.CKMETA = [false, true] # this should be set so only one entry can fit in a metadata block defines.SIZE = 'BLOCK_SIZE / 4' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // create 2 large entries that needs to be uninlined and split uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfs.mtree.weight == (2 << lfs.mbits)); + assert(lfs3.mtree.weight == (2 << lfs3.mbits)); // assert mroot now has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -3946,8 +3951,8 @@ code = ''' seen[mdir->rbyd.blocks[1] / 8] |= 1 << (mdir->rbyd.blocks[1] % 8); seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -3965,7 +3970,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -3976,112 +3981,112 @@ code = ''' // and the tree should still work // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'c'); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert mdir was split correctly - assert(lfs.mtree.weight == (3 << lfs.mbits)); + assert(lfs3.mtree.weight == (3 << lfs3.mbits)); // assert mroot still has no entries - assert(lfs.mroot.rbyd.weight == 0); + assert(lfs3.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_mtree_lookup(&lfs, (1 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (1 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'b'); - lfsr_mtree_lookup(&lfs, (2 << lfs.mbits)+0, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (2 << lfs3.mbits)+0, &mdir) => 0; assert(mdir.rbyd.weight == 1); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'c'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_traversal_extend] defines.CKMETA = [false, true] # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // insert at least one entry - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, "a", 1))) => 0; + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -4093,8 +4098,8 @@ code = ''' seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -4113,37 +4118,37 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; } } free(seen); - lfsr_data_t data; + lfs3_data_t data; // and the tree should still work // assert that our entry is still in the mtree uint8_t buffer[256]; - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 2; assert(memcmp(buffer, "\0a", 2) == 0); // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // assert that our entry is still in the mtree - lfsr_mtree_namelookup(&lfs, 0, "a", 1, + lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 2; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 2; assert(memcmp(buffer, "\0a", 2) == 0); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # larger traversal tests @@ -4151,33 +4156,33 @@ code = ''' defines.N = [5, 10, 20, 40, 80, 160, 320] defines.CKMETA = [false, true] defines.FORCE_COMPACTION = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); // create entries - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } @@ -4185,26 +4190,26 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -4216,8 +4221,8 @@ code = ''' seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -4236,7 +4241,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -4247,49 +4252,49 @@ code = ''' // and the tree should still work // try looking up each entry - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_data_t data; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; 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, + if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) { + lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1, &mdir) => 0; } - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; 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, + if (lfs3_mrid(&lfs3, mdir.mid) >= (lfs3_srid_t)mdir.rbyd.weight) { + lfs3_mtree_lookup(&lfs3, lfs3_mbid(&lfs3, mdir.mid) + 1, &mdir) => 0; } - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_mtree_traversal_fuzz] @@ -4298,22 +4303,22 @@ defines.CKMETA = [false, true] defines.FORCE_COMPACTION = [false, true] defines.SEED = 'range(100)' fuzz = 'SEED' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); bool sim[N]; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { sim[i] = false; } uint32_t prng = SEED; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // choose a pseudo-random name - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // update sim sim[x] = true; @@ -4322,26 +4327,26 @@ code = ''' char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", x); - lfsr_mdir_t mdir; - int err = lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mdir_t mdir; + int err = lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL); - assert(!err || err == LFS_ERR_NOENT); + assert(!err || err == LFS3_ERR_NOENT); if (!err) { continue; } // force a compaction? if (FORCE_COMPACTION) { - lfs.mroot.rbyd.eoff = -1; + lfs3.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME(LFSR_TAG_REG, +1, 0, name+1, 3))) => 0; - lfsr_data_t data; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + lfs3_data_t data; // double check uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } @@ -4350,26 +4355,26 @@ code = ''' uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY - | LFS_T_MTREEONLY - | ((CKMETA) ? LFS_T_CKMETA : 0)); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY + | LFS3_T_MTREEONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0)); + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], @@ -4381,8 +4386,8 @@ code = ''' seen[mdir->rbyd.blocks[0] / 8] |= 1 << (mdir->rbyd.blocks[0] % 8); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -4401,7 +4406,7 @@ code = ''' // if traversal worked, we should be able to clobber all other blocks uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -4412,53 +4417,53 @@ code = ''' // and the tree should still work // try looking up each entry - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_data_t data; + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_data_t data; uint8_t buffer[256]; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } // check things stay sane after remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; // try looking up each entry - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_BOOKMARK, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 1; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_BOOKMARK, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 1; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; name[0] = '\0'; sprintf(name+1, "%03x", i); if (sim[i]) { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, &mdir, NULL, NULL) => 0; - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, sizeof(buffer)) => 4; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, sizeof(buffer)) => 4; assert(memcmp(buffer, name, 4) == 0); } else { - lfsr_mtree_namelookup(&lfs, 0, name+1, 3, - &mdir, NULL, NULL) => LFS_ERR_NOENT; + lfs3_mtree_namelookup(&lfs3, 0, name+1, 3, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4466,44 +4471,44 @@ code = ''' # test that our cycle detector at least works in common cases [cases.test_mtree_traversal_mroot_cycle] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_MPTR( - LFSR_TAG_MROOT, 0, - LFSR_MPTR_MROOTANCHOR()))) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( + LFS3_RATTR_MPTR( + LFS3_TAG_MROOT, 0, + LFS3_MPTR_MROOTANCHOR()))) => 0; // technically, cycle detection only needs to work when we're validating - lfsr_traversal_t t; - lfsr_traversal_init(&t, - LFS_T_RDONLY | LFS_T_MTREEONLY | LFS_T_CKMETA); - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_init(&t, + LFS3_T_RDONLY | LFS3_T_MTREEONLY | LFS3_T_CKMETA); + for (lfs3_block_t i = 0;; i++) { // assert that we detect the cycle in a reasonable number of iterations assert(i < 2*BLOCK_COUNT); - lfsr_tag_t tag; - lfsr_bptr_t bptr; - int err = lfsr_mtree_traverse(&lfs, &t, + lfs3_tag_t tag; + lfs3_bptr_t bptr; + int err = lfs3_mtree_traverse(&lfs3, &t, &tag, &bptr); - assert(!err || err == LFS_ERR_CORRUPT); - if (err == LFS_ERR_CORRUPT) { + assert(!err || err == LFS3_ERR_CORRUPT); + if (err == LFS3_ERR_CORRUPT) { break; } - if (tag == LFSR_TAG_MDIR) { - lfsr_mdir_t *mdir = (lfsr_mdir_t*)bptr.data.u.buffer; + if (tag == LFS3_TAG_MDIR) { + lfs3_mdir_t *mdir = (lfs3_mdir_t*)bptr.data.u.buffer; printf("traversal: 0x%x mdir 0x{%x,%x}\n", tag, mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]); - } else if (tag == LFSR_TAG_BRANCH) { - lfsr_rbyd_t *rbyd = (lfsr_rbyd_t*)bptr.data.u.buffer; + } else if (tag == LFS3_TAG_BRANCH) { + lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)bptr.data.u.buffer; printf("traversal: 0x%x btree 0x%x.%x\n", tag, rbyd->blocks[0], rbyd->trunk); @@ -4515,7 +4520,7 @@ code = ''' } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -4524,41 +4529,41 @@ code = ''' # test some that some tricky truncated tags are rejected correctly [cases.test_mtree_truncated_tag] defines.OVERFLOW = [-3, -2, -1, 0, 1, 2, 3, 4, 5] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a malformed mroot uint8_t buffer[BLOCK_SIZE]; // fill with zeros to make parity checks easier memset(buffer, 0, BLOCK_SIZE); memcpy(&buffer[0], "evil", 4); - uint32_t cksum = lfs_crc32c(0, &buffer[0], 4); + uint32_t cksum = lfs3_crc32c(0, &buffer[0], 4); // make sure we're not caught by magic checks - buffer[4+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_MAGIC >> 8); - buffer[4+1] = (uint8_t)(LFSR_TAG_MAGIC >> 0); + buffer[4+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_MAGIC >> 8); + buffer[4+1] = (uint8_t)(LFS3_TAG_MAGIC >> 0); buffer[4+2] = 0; buffer[4+3] = 8; memcpy(&buffer[4+4], "littlefs", 8); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[4], 4+8); // append a tag that overflows our block - lfs_size_t size = BLOCK_SIZE - (16+7) + OVERFLOW; - buffer[16+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_ATTR >> 8); - buffer[16+1] = (uint8_t)(LFSR_TAG_ATTR >> 0); + lfs3_size_t size = BLOCK_SIZE - (16+7) + OVERFLOW; + buffer[16+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_ATTR >> 8); + buffer[16+1] = (uint8_t)(LFS3_TAG_ATTR >> 0); buffer[16+2] = 0; buffer[16+3] = 0x80 | (0x7f & (size >> 0)); buffer[16+4] = 0x80 | (0x7f & (size >> 7)); buffer[16+5] = 0x80 | (0x7f & (size >> 14)); buffer[16+6] = 0x00 | (0x7f & (size >> 21)); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[16], 7+size); // make next tag look valid to make errors look more likely if (OVERFLOW < 0) { - buffer[BLOCK_SIZE + OVERFLOW] = ((uint8_t)lfs_parity(cksum) << 7); + buffer[BLOCK_SIZE + OVERFLOW] = ((uint8_t)lfs3_parity(cksum) << 7); } // write to both mroot blocks @@ -4568,51 +4573,51 @@ code = ''' } // try to mount, this should fail - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => LFS_ERR_CORRUPT; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => LFS3_ERR_CORRUPT; ''' [cases.test_mtree_truncated_cksum] defines.OVERFLOW = [1, 2, 3, 4] defines.TRUNCATED_SIZE = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a malformed mroot uint8_t buffer[BLOCK_SIZE]; // fill with zeros to make parity checks easier memset(buffer, 0, BLOCK_SIZE); memcpy(&buffer[0], "evil", 4); - uint32_t cksum = lfs_crc32c(0, &buffer[0], 4); + uint32_t cksum = lfs3_crc32c(0, &buffer[0], 4); // make sure we're not caught by magic checks - buffer[4+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_MAGIC >> 8); - buffer[4+1] = (uint8_t)(LFSR_TAG_MAGIC >> 0); + buffer[4+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_MAGIC >> 8); + buffer[4+1] = (uint8_t)(LFS3_TAG_MAGIC >> 0); buffer[4+2] = 0; buffer[4+3] = 8; memcpy(&buffer[4+4], "littlefs", 8); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[4], 4+8); // append a tag for padding - lfs_size_t size = BLOCK_SIZE - (16+7) - (7+4) + OVERFLOW; - buffer[16+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_ATTR >> 8); - buffer[16+1] = (uint8_t)(LFSR_TAG_ATTR >> 0); + lfs3_size_t size = BLOCK_SIZE - (16+7) - (7+4) + OVERFLOW; + buffer[16+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_ATTR >> 8); + buffer[16+1] = (uint8_t)(LFS3_TAG_ATTR >> 0); buffer[16+2] = 0; buffer[16+3] = 0x80 | (0x7f & (size >> 0)); buffer[16+4] = 0x80 | (0x7f & (size >> 7)); buffer[16+5] = 0x80 | (0x7f & (size >> 14)); buffer[16+6] = 0x00 | (0x7f & (size >> 21)); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[16], 7+size); // append a truncated cksum tag - lfs_off_t off = BLOCK_SIZE - (7+4) + OVERFLOW; + lfs3_off_t off = BLOCK_SIZE - (7+4) + OVERFLOW; size = (TRUNCATED_SIZE) ? 4-OVERFLOW : 4; - buffer[off+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_CKSUM >> 8); - buffer[off+1] = (uint8_t)(LFSR_TAG_CKSUM >> 0); + buffer[off+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_CKSUM >> 8); + buffer[off+1] = (uint8_t)(LFS3_TAG_CKSUM >> 0); buffer[off+2] = 0; buffer[off+3] = 0x80 | (0x7f & (size >> 0)); buffer[off+4] = 0x80 | (0x7f & (size >> 7)); @@ -4626,62 +4631,62 @@ code = ''' } // try to mount, this should fail - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => LFS_ERR_CORRUPT; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => LFS3_ERR_CORRUPT; ''' [cases.test_mtree_truncated_ecksum] defines.OVERFLOW = [-3, -2, -1, 0, 1, 2, 3, 4, 5] defines.TRUNCATED_SIZE = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a malformed mroot uint8_t buffer[BLOCK_SIZE]; // fill with zeros to make parity checks easier memset(buffer, 0, BLOCK_SIZE); memcpy(&buffer[0], "evil", 4); - uint32_t cksum = lfs_crc32c(0, &buffer[0], 4); + uint32_t cksum = lfs3_crc32c(0, &buffer[0], 4); // make sure we're not caught by magic checks - buffer[4+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_MAGIC >> 8); - buffer[4+1] = (uint8_t)(LFSR_TAG_MAGIC >> 0); + buffer[4+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_MAGIC >> 8); + buffer[4+1] = (uint8_t)(LFS3_TAG_MAGIC >> 0); buffer[4+2] = 0; buffer[4+3] = 8; memcpy(&buffer[4+4], "littlefs", 8); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[4], 4+8); // append a tag for padding - lfs_size_t size = BLOCK_SIZE - (16+7) - (7+5) + OVERFLOW; - buffer[16+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_ATTR >> 8); - buffer[16+1] = (uint8_t)(LFSR_TAG_ATTR >> 0); + lfs3_size_t size = BLOCK_SIZE - (16+7) - (7+5) + OVERFLOW; + buffer[16+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_ATTR >> 8); + buffer[16+1] = (uint8_t)(LFS3_TAG_ATTR >> 0); buffer[16+2] = 0; buffer[16+3] = 0x80 | (0x7f & (size >> 0)); buffer[16+4] = 0x80 | (0x7f & (size >> 7)); buffer[16+5] = 0x80 | (0x7f & (size >> 14)); buffer[16+6] = 0x00 | (0x7f & (size >> 21)); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[16], 7+size); // append a truncated ecksum tag - lfs_off_t off = BLOCK_SIZE - (7+5) + OVERFLOW; - size = (TRUNCATED_SIZE) ? 5-lfs_smax(OVERFLOW, 0) : 5; - buffer[off+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_ECKSUM >> 8); - buffer[off+1] = (uint8_t)(LFSR_TAG_ECKSUM >> 0); + lfs3_off_t off = BLOCK_SIZE - (7+5) + OVERFLOW; + size = (TRUNCATED_SIZE) ? 5-lfs3_smax(OVERFLOW, 0) : 5; + buffer[off+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_ECKSUM >> 8); + buffer[off+1] = (uint8_t)(LFS3_TAG_ECKSUM >> 0); buffer[off+2] = 0; buffer[off+3] = 0x80 | (0x7f & (size >> 0)); buffer[off+4] = 0x80 | (0x7f & (size >> 7)); buffer[off+5] = 0x80 | (0x7f & (size >> 14)); buffer[off+6] = 0x00 | (0x7f & (size >> 21)); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[16], 7+size); // make next tag look valid to make errors look more likely if (OVERFLOW < 0) { - buffer[BLOCK_SIZE + OVERFLOW] = ((uint8_t)lfs_parity(cksum) << 7); + buffer[BLOCK_SIZE + OVERFLOW] = ((uint8_t)lfs3_parity(cksum) << 7); } // write to both mroot blocks @@ -4691,62 +4696,62 @@ code = ''' } // try to mount, this should fail - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => LFS_ERR_CORRUPT; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => LFS3_ERR_CORRUPT; ''' [cases.test_mtree_truncated_gcksumdelta] defines.OVERFLOW = [-3, -2, -1, 0, 1, 2, 3, 4] defines.TRUNCATED_SIZE = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' // create a malformed mroot uint8_t buffer[BLOCK_SIZE]; // fill with zeros to make parity checks easier memset(buffer, 0, BLOCK_SIZE); memcpy(&buffer[0], "evil", 4); - uint32_t cksum = lfs_crc32c(0, &buffer[0], 4); + uint32_t cksum = lfs3_crc32c(0, &buffer[0], 4); // make sure we're not caught by magic checks - buffer[4+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_MAGIC >> 8); - buffer[4+1] = (uint8_t)(LFSR_TAG_MAGIC >> 0); + buffer[4+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_MAGIC >> 8); + buffer[4+1] = (uint8_t)(LFS3_TAG_MAGIC >> 0); buffer[4+2] = 0; buffer[4+3] = 8; memcpy(&buffer[4+4], "littlefs", 8); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[4], 4+8); // append a tag for padding - lfs_size_t size = BLOCK_SIZE - (16+7) - (7+4) + OVERFLOW; - buffer[16+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_ATTR >> 8); - buffer[16+1] = (uint8_t)(LFSR_TAG_ATTR >> 0); + lfs3_size_t size = BLOCK_SIZE - (16+7) - (7+4) + OVERFLOW; + buffer[16+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_ATTR >> 8); + buffer[16+1] = (uint8_t)(LFS3_TAG_ATTR >> 0); buffer[16+2] = 0; buffer[16+3] = 0x80 | (0x7f & (size >> 0)); buffer[16+4] = 0x80 | (0x7f & (size >> 7)); buffer[16+5] = 0x80 | (0x7f & (size >> 14)); buffer[16+6] = 0x00 | (0x7f & (size >> 21)); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[16], 7+size); // append a truncated gcksumdelta tag - lfs_off_t off = BLOCK_SIZE - (7+4) + OVERFLOW; - size = (TRUNCATED_SIZE) ? 4-lfs_smax(OVERFLOW, 0) : 4; - buffer[off+0] = ((uint8_t)lfs_parity(cksum) << 7) - | (uint8_t)(LFSR_TAG_GCKSUMDELTA >> 8); - buffer[off+1] = (uint8_t)(LFSR_TAG_GCKSUMDELTA >> 0); + lfs3_off_t off = BLOCK_SIZE - (7+4) + OVERFLOW; + size = (TRUNCATED_SIZE) ? 4-lfs3_smax(OVERFLOW, 0) : 4; + buffer[off+0] = ((uint8_t)lfs3_parity(cksum) << 7) + | (uint8_t)(LFS3_TAG_GCKSUMDELTA >> 8); + buffer[off+1] = (uint8_t)(LFS3_TAG_GCKSUMDELTA >> 0); buffer[off+2] = 0; buffer[off+3] = 0x80 | (0x7f & (size >> 0)); buffer[off+4] = 0x80 | (0x7f & (size >> 7)); buffer[off+5] = 0x80 | (0x7f & (size >> 14)); buffer[off+6] = 0x00 | (0x7f & (size >> 21)); - cksum = lfs_crc32c(cksum ^ ((uint32_t)lfs_parity(cksum) << 7), + cksum = lfs3_crc32c(cksum ^ ((uint32_t)lfs3_parity(cksum) << 7), &buffer[16], 7+size); // make next tag look valid to make errors look more likely if (OVERFLOW < 0) { - buffer[BLOCK_SIZE + OVERFLOW] = ((uint8_t)lfs_parity(cksum) << 7); + buffer[BLOCK_SIZE + OVERFLOW] = ((uint8_t)lfs3_parity(cksum) << 7); } // write to both mroot blocks @@ -4756,8 +4761,8 @@ code = ''' } // try to mount, this should fail - lfs_t lfs; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => LFS_ERR_CORRUPT; + lfs3_t lfs3; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => LFS3_ERR_CORRUPT; ''' @@ -4766,18 +4771,18 @@ code = ''' # make sure our magic string ("littlefs") shows up in the same place (off=8) [cases.test_mtree_magic] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; // check our magic string // // note if we lose power we may not have the magic string in both blocks! // but we don't lose power in this test so we can assert the magic string // is present in both - uint8_t magic[LFS_MAX(16, READ_SIZE)]; - CFG->read(CFG, 0, 0, magic, LFS_MAX(16, READ_SIZE)) => 0; + uint8_t magic[LFS3_MAX(16, READ_SIZE)]; + CFG->read(CFG, 0, 0, magic, LFS3_MAX(16, READ_SIZE)) => 0; assert(memcmp(&magic[8], "littlefs", 8) == 0); - CFG->read(CFG, 1, 0, magic, LFS_MAX(16, READ_SIZE)) => 0; + CFG->read(CFG, 1, 0, magic, LFS3_MAX(16, READ_SIZE)) => 0; assert(memcmp(&magic[8], "littlefs", 8) == 0); ''' @@ -4786,54 +4791,54 @@ code = ''' defines.SIZE = 'BLOCK_SIZE / 4' # make it so blocks relocate every two compacts defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // prepare mroot with an entry uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert that our entry is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // check our magic string // // note if we lose power we may not have the magic string in both blocks! // but we don't lose power in this test so we can assert the magic string // is present in both - uint8_t magic[LFS_MAX(16, READ_SIZE)]; - CFG->read(CFG, 0, 0, magic, LFS_MAX(16, READ_SIZE)) => 0; + uint8_t magic[LFS3_MAX(16, READ_SIZE)]; + CFG->read(CFG, 0, 0, magic, LFS3_MAX(16, READ_SIZE)) => 0; assert(memcmp(&magic[8], "littlefs", 8) == 0); - CFG->read(CFG, 1, 0, magic, LFS_MAX(16, READ_SIZE)) => 0; + CFG->read(CFG, 1, 0, magic, LFS3_MAX(16, READ_SIZE)) => 0; assert(memcmp(&magic[8], "littlefs", 8) == 0); ''' @@ -4845,67 +4850,67 @@ defines.BLOCK_RECYCLES = 0 # force our block to compact by setting prog_size=block_size, we don't have # any way to indirectly force the intermediary mroots to compact otherwise defines.PROG_SIZE = 'BLOCK_SIZE' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR | F_FLAGS, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR | M_FLAGS, CFG) => 0; - lfs_alloc_ckpoint(&lfs); - lfsr_data_t data; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR | F_FLAGS, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR | M_FLAGS, CFG) => 0; + lfs3_alloc_ckpoint(&lfs3); + lfs3_data_t data; // prepare mroot with an entry uint8_t buffer[SIZE]; buffer[0] = '\0'; memset(buffer+1, 'a', SIZE-1); - lfsr_mdir_t mdir; - lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, - &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_REG, +1, + lfs3_mdir_t mdir; + lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, + &mdir, NULL, NULL) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_NAME( + LFS3_TAG_REG, +1, 0, (const char*)buffer+1, SIZE-1))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot - lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + lfs3_mdir_t old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // force mroot to compact four times, this should relocate the mroot // twice, forcing a second mroot extension - old_mroot = lfs.mroot; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; + old_mroot = lfs3.mroot; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3.mroot.rbyd.eoff = -1; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; // assert we relocated - assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); + assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); // assert that our rattr is still in the mroot - lfsr_mtree_lookup(&lfs, (0 << lfs.mbits)+1, &mdir) => 0; + lfs3_mtree_lookup(&lfs3, (0 << lfs3.mbits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); - lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; + lfs3_mdir_lookup(&lfs3, &mdir, LFS3_TAG_REG, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, SIZE) => SIZE; assert(buffer[1] == 'a'); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // check our magic string // // note if we lose power we may not have the magic string in both blocks! // but we don't lose power in this test so we can assert the magic string // is present in both - uint8_t magic[LFS_MAX(16, READ_SIZE)]; - CFG->read(CFG, 0, 0, magic, LFS_MAX(16, READ_SIZE)) => 0; + uint8_t magic[LFS3_MAX(16, READ_SIZE)]; + CFG->read(CFG, 0, 0, magic, LFS3_MAX(16, READ_SIZE)) => 0; assert(memcmp(&magic[8], "littlefs", 8) == 0); - CFG->read(CFG, 1, 0, magic, LFS_MAX(16, READ_SIZE)) => 0; + CFG->read(CFG, 1, 0, magic, LFS3_MAX(16, READ_SIZE)) => 0; assert(memcmp(&magic[8], "littlefs", 8) == 0); ''' diff --git a/tests/test_paths.toml b/tests/test_paths.toml index bb321778..55b83a5f 100644 --- a/tests/test_paths.toml +++ b/tests/test_paths.toml @@ -5,247 +5,247 @@ after = 'test_dirs' [cases.test_paths_simple] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "coffee/drip", "espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew", "espresso/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/turkish", "espresso/macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/tubruk", "espresso/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/vietnamese", "espresso/cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai", "espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => 0; + lfs3_stat(&lfs3, "espresso/espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "coffee/drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "espresso/espresso") => 0; - lfsr_remove(&lfs, "espresso/americano") => 0; - lfsr_remove(&lfs, "espresso/macchiato") => 0; - lfsr_remove(&lfs, "espresso/latte") => 0; - lfsr_remove(&lfs, "espresso/cappuccino") => 0; - lfsr_remove(&lfs, "espresso/mocha") => 0; + lfs3_remove(&lfs3, "espresso/espresso") => 0; + lfs3_remove(&lfs3, "espresso/americano") => 0; + lfs3_remove(&lfs3, "espresso/macchiato") => 0; + lfs3_remove(&lfs3, "espresso/latte") => 0; + lfs3_remove(&lfs3, "espresso/cappuccino") => 0; + lfs3_remove(&lfs3, "espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # absolute path test @@ -254,494 +254,494 @@ code = ''' [cases.test_paths_absolute] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/drip") => 0; - lfsr_mkdir(&lfs, "/coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "/coffee/turkish") => 0; - lfsr_mkdir(&lfs, "/coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "/coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "/coffee/thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/drip") => 0; + lfs3_mkdir(&lfs3, "/coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "/coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "/coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "/coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "/coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/coffee/drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "coffee/drip", "/espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew", "/espresso/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/turkish", "espresso/macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/tubruk", "espresso/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/vietnamese", "/espresso/cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/thai", "/espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "/espresso/espresso", &info) => 0; + lfs3_stat(&lfs3, "/espresso/espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "espresso/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/espresso") => 0; - lfsr_remove(&lfs, "/espresso/americano") => 0; - lfsr_remove(&lfs, "/espresso/macchiato") => 0; - lfsr_remove(&lfs, "/espresso/latte") => 0; - lfsr_remove(&lfs, "/espresso/cappuccino") => 0; - lfsr_remove(&lfs, "/espresso/mocha") => 0; + lfs3_remove(&lfs3, "/espresso/espresso") => 0; + lfs3_remove(&lfs3, "/espresso/americano") => 0; + lfs3_remove(&lfs3, "/espresso/macchiato") => 0; + lfs3_remove(&lfs3, "/espresso/latte") => 0; + lfs3_remove(&lfs3, "/espresso/cappuccino") => 0; + lfs3_remove(&lfs3, "/espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "/espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # redundant slashes [cases.test_paths_redundant_slashes] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/drip") => 0; - lfsr_mkdir(&lfs, "//coffee//coldbrew") => 0; - lfsr_mkdir(&lfs, "///coffee///turkish") => 0; - lfsr_mkdir(&lfs, "////coffee////tubruk") => 0; - lfsr_mkdir(&lfs, "/////coffee/////vietnamese") => 0; - lfsr_mkdir(&lfs, "//////coffee//////thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/drip") => 0; + lfs3_mkdir(&lfs3, "//coffee//coldbrew") => 0; + lfs3_mkdir(&lfs3, "///coffee///turkish") => 0; + lfs3_mkdir(&lfs3, "////coffee////tubruk") => 0; + lfs3_mkdir(&lfs3, "/////coffee/////vietnamese") => 0; + lfs3_mkdir(&lfs3, "//////coffee//////thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "//////coffee//////drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "//////coffee//////drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/////coffee/////coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/////coffee/////coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "////coffee////turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "////coffee////turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "///coffee///tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "///coffee///tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "//coffee//vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "//coffee//vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "//coffee//coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "///coffee///turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "////coffee////tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/////coffee/////vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "//////coffee//////thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "//coffee//coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "///coffee///turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "////coffee////tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/////coffee/////vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "//////coffee//////thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "//coffee//coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "///coffee///turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "////coffee////tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/////coffee/////vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "//////coffee//////thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "//coffee//coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "///coffee///turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "////coffee////tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/////coffee/////vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "//////coffee//////thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "//coffee//coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "///coffee///turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "////coffee////tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/////coffee/////vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "//////coffee//////thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "//coffee//coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "///coffee///turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "////coffee////tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/////coffee/////vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "//////coffee//////thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "//////coffee//////drip", "/espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/////coffee/////coldbrew", "//espresso//americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "////coffee////turkish", "///espresso///macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "///coffee///tubruk", "////espresso////latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "//coffee//vietnamese", "/////espresso/////cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/thai", "//////espresso//////mocha") => 0; // stat paths - lfsr_stat(&lfs, "//////espresso//////espresso", &info) => 0; + lfs3_stat(&lfs3, "//////espresso//////espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/////espresso/////americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/////espresso/////americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "////espresso////macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "////espresso////macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "///espresso///latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "///espresso///latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "//espresso//cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "//espresso//cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "//////coffee//////drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/////coffee/////coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "////coffee////turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "///coffee///tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "//coffee//vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "//////coffee//////drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/////coffee/////coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "////coffee////turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "///coffee///tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "//coffee//vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/espresso") => 0; - lfsr_remove(&lfs, "//espresso//americano") => 0; - lfsr_remove(&lfs, "///espresso///macchiato") => 0; - lfsr_remove(&lfs, "////espresso////latte") => 0; - lfsr_remove(&lfs, "/////espresso/////cappuccino") => 0; - lfsr_remove(&lfs, "//////espresso//////mocha") => 0; + lfs3_remove(&lfs3, "/espresso/espresso") => 0; + lfs3_remove(&lfs3, "//espresso//americano") => 0; + lfs3_remove(&lfs3, "///espresso///macchiato") => 0; + lfs3_remove(&lfs3, "////espresso////latte") => 0; + lfs3_remove(&lfs3, "/////espresso/////cappuccino") => 0; + lfs3_remove(&lfs3, "//////espresso//////mocha") => 0; // stat paths - lfsr_stat(&lfs, "//////espresso//////espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/////espresso/////americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "////espresso////macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "///espresso///latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "//espresso//cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "//////espresso//////espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/////espresso/////americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "////espresso////macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "///espresso///latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "//espresso//cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test trailing slashes @@ -750,603 +750,603 @@ code = ''' [cases.test_paths_trailing_slashes] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip/") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew//") => 0; - lfsr_mkdir(&lfs, "coffee/turkish///") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk////") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese/////") => 0; - lfsr_mkdir(&lfs, "coffee/thai//////") => 0; + lfs3_mkdir(&lfs3, "coffee/drip/") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew//") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish///") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk////") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese/////") => 0; + lfs3_mkdir(&lfs3, "coffee/thai//////") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; // still create so we have something to test - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; + struct lfs3_info info; if (DIR) { - lfsr_stat(&lfs, "coffee/drip//////", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip//////", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/coldbrew/////", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/coldbrew/////", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/turkish////", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/turkish////", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/tubruk///", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/tubruk///", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/vietnamese//", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/vietnamese//", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/thai/", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/thai/", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); } else { - lfsr_stat(&lfs, "coffee/drip//////", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/coldbrew/////", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/turkish////", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/tubruk///", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/vietnamese//", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/thai/", &info) => LFS_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/drip//////", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/coldbrew/////", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/turkish////", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/tubruk///", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/vietnamese//", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/thai/", &info) => LFS3_ERR_NOTDIR; } // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew//") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/turkish///") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk////") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/////") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/thai//////") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew//") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish///") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk////") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/////") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/thai//////") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew//") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/turkish///") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk////") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/////") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/thai//////") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew//") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish///") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk////") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/////") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/thai//////") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; if (DIR) { - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip//////", "espresso/espresso/") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew/////", "espresso/americano//") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/turkish////", "espresso/macchiato///") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/tubruk///", "espresso/latte////") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/vietnamese//", "espresso/cappuccino/////") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai/", "espresso/mocha//////") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso//////", &info) => 0; + lfs3_stat(&lfs3, "espresso/espresso//////", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/americano/////", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/americano/////", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/macchiato////", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/macchiato////", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/latte///", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/latte///", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/cappuccino//", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/cappuccino//", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/mocha/", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/mocha/", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); - lfsr_stat(&lfs, "coffee/drip//////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/coldbrew/////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/turkish////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tubruk///", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/vietnamese//", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai/", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/drip//////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/coldbrew/////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/turkish////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tubruk///", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/vietnamese//", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai/", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "espresso/espresso/") => 0; - lfsr_remove(&lfs, "espresso/americano//") => 0; - lfsr_remove(&lfs, "espresso/macchiato///") => 0; - lfsr_remove(&lfs, "espresso/latte////") => 0; - lfsr_remove(&lfs, "espresso/cappuccino/////") => 0; - lfsr_remove(&lfs, "espresso/mocha//////") => 0; + lfs3_remove(&lfs3, "espresso/espresso/") => 0; + lfs3_remove(&lfs3, "espresso/americano//") => 0; + lfs3_remove(&lfs3, "espresso/macchiato///") => 0; + lfs3_remove(&lfs3, "espresso/latte////") => 0; + lfs3_remove(&lfs3, "espresso/cappuccino/////") => 0; + lfs3_remove(&lfs3, "espresso/mocha//////") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso//////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano/////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte///", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino//", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha/", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso//////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano/////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte///", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino//", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha/", &info) => LFS3_ERR_NOENT; } else { // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip//////", - "espresso/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/////", - "espresso/americano") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish////", - "espresso/macchiato") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk///", - "espresso/latte") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese//", - "espresso/cappuccino") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/", - "espresso/mocha") => LFS_ERR_NOTDIR; + "espresso/mocha") => LFS3_ERR_NOTDIR; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso/") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano//") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano//") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato///") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato///") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino/////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha//////") => LFS_ERR_NOTDIR; + "espresso/mocha//////") => LFS3_ERR_NOTDIR; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip//////", - "espresso/espresso/") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso/") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/////", - "espresso/americano//") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano//") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish////", - "espresso/macchiato///") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato///") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk///", - "espresso/latte////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese//", - "espresso/cappuccino/////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino/////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/", - "espresso/mocha//////") => LFS_ERR_NOTDIR; + "espresso/mocha//////") => LFS3_ERR_NOTDIR; // remove paths - lfsr_remove(&lfs, "coffee/drip/") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/coldbrew//") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/turkish///") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/tubruk////") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/vietnamese/////") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/thai//////") => LFS_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/drip/") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/coldbrew//") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/turkish///") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/tubruk////") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/vietnamese/////") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/thai//////") => LFS3_ERR_NOTDIR; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # dot path tests [cases.test_paths_dots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/drip") => 0; - lfsr_mkdir(&lfs, "/./coffee/./coldbrew") => 0; - lfsr_mkdir(&lfs, "/././coffee/././turkish") => 0; - lfsr_mkdir(&lfs, "/./././coffee/./././tubruk") => 0; - lfsr_mkdir(&lfs, "/././././coffee/././././vietnamese") => 0; - lfsr_mkdir(&lfs, "/./././././coffee/./././././thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/drip") => 0; + lfs3_mkdir(&lfs3, "/./coffee/./coldbrew") => 0; + lfs3_mkdir(&lfs3, "/././coffee/././turkish") => 0; + lfs3_mkdir(&lfs3, "/./././coffee/./././tubruk") => 0; + lfs3_mkdir(&lfs3, "/././././coffee/././././vietnamese") => 0; + lfs3_mkdir(&lfs3, "/./././././coffee/./././././thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/./././././coffee/./././././drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/./././././coffee/./././././drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/././././coffee/././././coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/././././coffee/././././coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/./././coffee/./././turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/./././coffee/./././turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/././coffee/././tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/././coffee/././tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/./coffee/./vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/./coffee/./vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/./coffee/./coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/././coffee/././turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/./././coffee/./././tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/././././coffee/././././vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/./././././coffee/./././././thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/./coffee/./coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/././coffee/././turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/./././coffee/./././tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/././././coffee/././././vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/./././././coffee/./././././thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/./coffee/./coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/././coffee/././turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/./././coffee/./././tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/././././coffee/././././vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/./././././coffee/./././././thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/./coffee/./coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/././coffee/././turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/./././coffee/./././tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/././././coffee/././././vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/./././././coffee/./././././thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/./coffee/./coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/././coffee/././turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/./././coffee/./././tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/././././coffee/././././vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/./././././coffee/./././././thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/./coffee/./coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/././coffee/././turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/./././coffee/./././tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/././././coffee/././././vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/./././././coffee/./././././thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "/./././././coffee/./././././drip", "/espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/././././coffee/././././coldbrew", "/./espresso/./americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/./././coffee/./././turkish", "/././espresso/././macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/././coffee/././tubruk", "/./././espresso/./././latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/./coffee/./vietnamese", "/././././espresso/././././cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/thai", "/./././././espresso/./././././mocha") => 0; // stat paths - lfsr_stat(&lfs, "/./././././espresso/./././././espresso", &info) => 0; + lfs3_stat(&lfs3, "/./././././espresso/./././././espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/././././espresso/././././americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/././././espresso/././././americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/./././espresso/./././macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/./././espresso/./././macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/././espresso/././latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/././espresso/././latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/./espresso/./cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/./espresso/./cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "/./././././coffee/./././././drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/././././coffee/././././coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/./././coffee/./././turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/././coffee/././tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/./coffee/./vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/./././././coffee/./././././drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/././././coffee/././././coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/./././coffee/./././turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/././coffee/././tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/./coffee/./vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/espresso") => 0; - lfsr_remove(&lfs, "/./espresso/./americano") => 0; - lfsr_remove(&lfs, "/././espresso/././macchiato") => 0; - lfsr_remove(&lfs, "/./././espresso/./././latte") => 0; - lfsr_remove(&lfs, "/././././espresso/././././cappuccino") => 0; - lfsr_remove(&lfs, "/./././././espresso/./././././mocha") => 0; + lfs3_remove(&lfs3, "/espresso/espresso") => 0; + lfs3_remove(&lfs3, "/./espresso/./americano") => 0; + lfs3_remove(&lfs3, "/././espresso/././macchiato") => 0; + lfs3_remove(&lfs3, "/./././espresso/./././latte") => 0; + lfs3_remove(&lfs3, "/././././espresso/././././cappuccino") => 0; + lfs3_remove(&lfs3, "/./././././espresso/./././././mocha") => 0; // stat paths - lfsr_stat(&lfs, "/./././././espresso/./././././espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/././././espresso/././././americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/./././espresso/./././macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/././espresso/././latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/./espresso/./cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/./././././espresso/./././././espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/././././espresso/././././americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/./././espresso/./././macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/././espresso/././latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/./espresso/./cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test trailing dots, these get a bit weird @@ -1361,656 +1361,656 @@ code = ''' [cases.test_paths_trailing_dots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip/.") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "coffee/coldbrew/./.") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "coffee/turkish/././.") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "coffee/tubruk/./././.") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "coffee/vietnamese/././././.") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "coffee/thai/./././././.") => LFS_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee/drip/.") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee/coldbrew/./.") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee/turkish/././.") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee/tubruk/./././.") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee/vietnamese/././././.") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee/thai/./././././.") => LFS3_ERR_NOENT; // still create so we have something to test - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; // still create so we have something to test - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; + struct lfs3_info info; if (DIR) { - lfsr_stat(&lfs, "coffee/drip/./././././.", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip/./././././.", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/coldbrew/././././.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/coldbrew/././././.", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/turkish/./././.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/turkish/./././.", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/tubruk/././.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/tubruk/././.", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/vietnamese/./.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/vietnamese/./.", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/thai/.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/thai/.", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); } else { - lfsr_stat(&lfs, "coffee/drip/./././././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/coldbrew/././././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/turkish/./././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/tubruk/././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/vietnamese/./.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/thai/.", &info) => LFS_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/drip/./././././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/coldbrew/././././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/turkish/./././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/tubruk/././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/vietnamese/./.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/thai/.", &info) => LFS3_ERR_NOTDIR; } // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew/./.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/turkish/././.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk/./././.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/././././.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/thai/./././././.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew/./.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish/././.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk/./././.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/././././.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/thai/./././././.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew/./.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/turkish/././.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk/./././.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/././././.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/thai/./././././.") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew/./.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish/././.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk/./././.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/././././.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/thai/./././././.") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; if (DIR) { // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha/./././././.") => LFS_ERR_NOENT; + "espresso/mocha/./././././.") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", - "espresso/espresso/.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", - "espresso/americano/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/turkish/./././.", - "espresso/macchiato/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tubruk/././.", - "espresso/latte/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/vietnamese/./.", - "espresso/cappuccino/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai/.", - "espresso/mocha/./././././.") => LFS_ERR_NOENT; + "espresso/mocha/./././././.") => LFS3_ERR_NOENT; // this one works - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", "espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", "espresso/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/turkish/./././.", "espresso/macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/tubruk/././.", "espresso/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/vietnamese/./.", "espresso/cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai/.", "espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso/./././././.", &info) => 0; + lfs3_stat(&lfs3, "espresso/espresso/./././././.", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/americano/././././.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/americano/././././.", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/macchiato/./././.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/macchiato/./././.", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/latte/././.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/latte/././.", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/cappuccino/./.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/cappuccino/./.", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "espresso/mocha/.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "espresso/mocha/.", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); - lfsr_stat(&lfs, "coffee/drip/./././././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/coldbrew/././././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/turkish/./././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tubruk/././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/vietnamese/./.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai/.", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/drip/./././././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/coldbrew/././././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/turkish/./././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tubruk/././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/vietnamese/./.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai/.", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "espresso/espresso/.") => 0; - lfsr_remove(&lfs, "espresso/americano/./.") => 0; - lfsr_remove(&lfs, "espresso/macchiato/././.") => 0; - lfsr_remove(&lfs, "espresso/latte/./././.") => 0; - lfsr_remove(&lfs, "espresso/cappuccino/././././.") => 0; - lfsr_remove(&lfs, "espresso/mocha/./././././.") => 0; + lfs3_remove(&lfs3, "espresso/espresso/.") => 0; + lfs3_remove(&lfs3, "espresso/americano/./.") => 0; + lfs3_remove(&lfs3, "espresso/macchiato/././.") => 0; + lfs3_remove(&lfs3, "espresso/latte/./././.") => 0; + lfs3_remove(&lfs3, "espresso/cappuccino/././././.") => 0; + lfs3_remove(&lfs3, "espresso/mocha/./././././.") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso/./././././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano/././././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato/./././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte/././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino/./.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha/.", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso/./././././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano/././././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato/./././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte/././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino/./.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha/.", &info) => LFS3_ERR_NOENT; } else { // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", - "espresso/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", - "espresso/americano") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish/./././.", - "espresso/macchiato") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk/././.", - "espresso/latte") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese/./.", - "espresso/cappuccino") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/.", - "espresso/mocha") => LFS_ERR_NOTDIR; + "espresso/mocha") => LFS3_ERR_NOTDIR; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha/./././././.") => LFS_ERR_NOENT; + "espresso/mocha/./././././.") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", - "espresso/espresso/.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", - "espresso/americano/./.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish/./././.", - "espresso/macchiato/././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk/././.", - "espresso/latte/./././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese/./.", - "espresso/cappuccino/././././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/.", - "espresso/mocha/./././././.") => LFS_ERR_NOTDIR; + "espresso/mocha/./././././.") => LFS3_ERR_NOTDIR; // remove paths - lfsr_remove(&lfs, "coffee/drip/.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/coldbrew/./.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/turkish/././.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/tubruk/./././.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/vietnamese/././././.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/thai/./././././.") => LFS_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/drip/.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/coldbrew/./.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/turkish/././.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/tubruk/./././.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/vietnamese/././././.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/thai/./././././.") => LFS3_ERR_NOTDIR; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_REG); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == LFS3_TYPE_REG); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # dot dot path tests [cases.test_paths_dotdots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "no") => 0; - lfsr_mkdir(&lfs, "no/no") => 0; - lfsr_mkdir(&lfs, "coffee") => 0; - lfsr_mkdir(&lfs, "coffee/no") => 0; + lfs3_mkdir(&lfs3, "no") => 0; + lfs3_mkdir(&lfs3, "no/no") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee/no") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/drip") => 0; - lfsr_mkdir(&lfs, "/no/../coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "/coffee/no/../turkish") => 0; - lfsr_mkdir(&lfs, "/no/no/../../coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "/no/no/../../coffee/no/../vietnamese") => 0; - lfsr_mkdir(&lfs, "/no/no/../../no/no/../../coffee/thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/drip") => 0; + lfs3_mkdir(&lfs3, "/no/../coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "/coffee/no/../turkish") => 0; + lfs3_mkdir(&lfs3, "/no/no/../../coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "/no/no/../../coffee/no/../vietnamese") => 0; + lfs3_mkdir(&lfs3, "/no/no/../../no/no/../../coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/no/no/../../no/no/../../coffee/drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/no/no/../../no/no/../../coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/../../coffee/no/../coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/../../coffee/no/../coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/../../coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/../../coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/no/../tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/no/../tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/../coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/../coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/no/../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/../../coffee/no/../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/../../no/no/../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/no/../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/../../coffee/no/../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/../../no/no/../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/../coffee/coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/no/../turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/no/../../coffee/tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/no/../../coffee/no/../vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/no/../../no/no/../../coffee/thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/../coffee/coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/no/../turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/no/../../coffee/tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/no/../../coffee/no/../vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/no/../../no/no/../../coffee/thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/../coffee/coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/no/../turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/no/../../coffee/tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/no/../../coffee/no/../vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/no/../../no/no/../../coffee/thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/../coffee/coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/no/../turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/no/../../coffee/tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/no/../../coffee/no/../vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/no/../../no/no/../../coffee/thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "/no/no/../../no/no/../../coffee/drip", "/espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/no/../../coffee/no/../coldbrew", "/no/../espresso/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/no/../../coffee/turkish", "/espresso/no/../macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/no/../tubruk", "/no/no/../../espresso/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/../coffee/vietnamese", "/no/no/../../espresso/no/../cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/thai", "/no/no/../../no/no/../../espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "/no/no/../../no/no/../../espresso/espresso", &info) => 0; + lfs3_stat(&lfs3, "/no/no/../../no/no/../../espresso/espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/../../espresso/no/../americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/../../espresso/no/../americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/../../espresso/macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/../../espresso/macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/no/../latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/no/../latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/../espresso/cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/../espresso/cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/../../no/no/../../coffee/drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/../../coffee/no/../coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/../../coffee/turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/no/../tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/../coffee/vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/../../no/no/../../coffee/drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/../../coffee/no/../coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/../../coffee/turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/no/../tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/../coffee/vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/espresso") => 0; - lfsr_remove(&lfs, "/no/../espresso/americano") => 0; - lfsr_remove(&lfs, "/espresso/no/../macchiato") => 0; - lfsr_remove(&lfs, "/no/no/../../espresso/latte") => 0; - lfsr_remove(&lfs, "/no/no/../../espresso/no/../cappuccino") => 0; - lfsr_remove(&lfs, "/no/no/../../no/no/../../espresso/mocha") => 0; + lfs3_remove(&lfs3, "/espresso/espresso") => 0; + lfs3_remove(&lfs3, "/no/../espresso/americano") => 0; + lfs3_remove(&lfs3, "/espresso/no/../macchiato") => 0; + lfs3_remove(&lfs3, "/no/no/../../espresso/latte") => 0; + lfs3_remove(&lfs3, "/no/no/../../espresso/no/../cappuccino") => 0; + lfs3_remove(&lfs3, "/no/no/../../no/no/../../espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "/no/no/../../no/no/../../espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/../../espresso/no/../americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/../../espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/no/../latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/../espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/../../no/no/../../espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/../../espresso/no/../americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/../../espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/no/../latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/../espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test trailing dot dots, these get really weird @@ -2030,3759 +2030,3759 @@ code = ''' [cases.test_paths_trailing_dotdots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip/..") => LFS_ERR_EXIST; - lfsr_mkdir(&lfs, "coffee/coldbrew/../..") => LFS_ERR_EXIST; - lfsr_mkdir(&lfs, "coffee/turkish/../../..") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "coffee/tubruk/../../../..") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "coffee/vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "coffee/thai/../../../../../..") => LFS_ERR_INVAL; + lfs3_mkdir(&lfs3, "coffee/drip/..") => LFS3_ERR_EXIST; + lfs3_mkdir(&lfs3, "coffee/coldbrew/../..") => LFS3_ERR_EXIST; + lfs3_mkdir(&lfs3, "coffee/turkish/../../..") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "coffee/tubruk/../../../..") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "coffee/vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "coffee/thai/../../../../../..") => LFS3_ERR_INVAL; // still create so we have something to test - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/turkish/../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/tubruk/../../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/../../../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/thai/../../../../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/turkish/../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/../../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/thai/../../../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; // still create so we have something to test - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/drip/../../../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/coldbrew/../../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/turkish/../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/tubruk/../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/vietnamese/../..", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/drip/../../../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/coldbrew/../../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/turkish/../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/tubruk/../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/vietnamese/../..", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/thai/..", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/thai/..", &info) => 0; assert(strcmp(info.name, "coffee") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/..", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/../..", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/tubruk/../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/../../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/thai/../../../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/..", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/../..", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/../../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/thai/../../../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/drip/..", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/../..", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/../../..", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/tubruk/../../../..", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/../../../../..", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/thai/../../../../../..", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/drip/..", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/../..", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/../../..", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/../../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/thai/../../../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/drip/..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/turkish/../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/tubruk/../../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/../../../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/thai/../../../../../..", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/drip/..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/turkish/../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/../../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/thai/../../../../../..", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/..") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew/../..") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/turkish/../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk/../../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/thai/../../../../../..") => LFS_ERR_INVAL; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/..") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew/../..") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish/../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk/../../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/thai/../../../../../..") => LFS3_ERR_INVAL; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/../../../../../..", - "espresso/espresso") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/coldbrew/../../../../..", - "espresso/americano") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish/../../../..", - "espresso/macchiato") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk/../../..", - "espresso/latte") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese/../..", - "espresso/cappuccino") => LFS_ERR_INVAL; + "espresso/cappuccino") => LFS3_ERR_INVAL; // this one works - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai/..", "espresso/mocha") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "espresso/mocha", "coffee") => 0; // bad destination if (DIR) { // this one works - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", "espresso/espresso/..") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "espresso", "coffee/drip") => 0; } else { - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/..") => LFS_ERR_ISDIR; + "espresso/espresso/..") => LFS3_ERR_ISDIR; } - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/cappuccino/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha/../../../../../..") => LFS_ERR_INVAL; + "espresso/mocha/../../../../../..") => LFS3_ERR_INVAL; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/../../../../../..", - "espresso/espresso/..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso/..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/coldbrew/../../../../..", - "espresso/americano/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish/../../../..", - "espresso/macchiato/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk/../../..", - "espresso/latte/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese/../..", - "espresso/cappuccino/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/cappuccino/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai/..", - "espresso/mocha/../../../../../..") => LFS_ERR_INVAL; + "espresso/mocha/../../../../../..") => LFS3_ERR_INVAL; // remove paths - lfsr_remove(&lfs, "coffee/drip/..") => LFS_ERR_NOTEMPTY; - lfsr_remove(&lfs, "coffee/coldbrew/../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/turkish/../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/tubruk/../../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/thai/../../../../../..") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/drip/..") => LFS3_ERR_NOTEMPTY; + lfs3_remove(&lfs3, "coffee/coldbrew/../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/turkish/../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/tubruk/../../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/thai/../../../../../..") => LFS3_ERR_INVAL; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # dot dot dot path tests [cases.test_paths_dot_dotdots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "no") => 0; - lfsr_mkdir(&lfs, "no/no") => 0; - lfsr_mkdir(&lfs, "coffee") => 0; - lfsr_mkdir(&lfs, "coffee/no") => 0; + lfs3_mkdir(&lfs3, "no") => 0; + lfs3_mkdir(&lfs3, "no/no") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee/no") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/drip") => 0; - lfsr_mkdir(&lfs, "/no/./../coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "/coffee/no/./../turkish") => 0; - lfsr_mkdir(&lfs, "/no/no/./.././../coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "/no/no/./.././../coffee/no/./../vietnamese") => 0; - lfsr_mkdir(&lfs, "/no/no/./.././../no/no/./.././../coffee/thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/drip") => 0; + lfs3_mkdir(&lfs3, "/no/./../coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "/coffee/no/./../turkish") => 0; + lfs3_mkdir(&lfs3, "/no/no/./.././../coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "/no/no/./.././../coffee/no/./../vietnamese") => 0; + lfs3_mkdir(&lfs3, "/no/no/./.././../no/no/./.././../coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/no/no/./.././../no/no/./.././../coffee/drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/no/no/./.././../no/no/./.././../coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/./.././../coffee/no/./../coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/./.././../coffee/no/./../coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/./.././../coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/./.././../coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/no/./../tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/no/./../tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/./../coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/./../coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/./../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/no/./../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/./.././../coffee/no/./../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/no/no/./.././../no/no/./.././../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/./../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/no/./../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../coffee/no/./../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/no/no/./.././../no/no/./.././../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/./../coffee/coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/no/./../turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/no/./.././../coffee/tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/no/./.././../coffee/no/./../vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/no/no/./.././../no/no/./.././../coffee/thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/./../coffee/coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/no/./../turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/no/./.././../coffee/tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/no/./.././../coffee/no/./../vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/no/no/./.././../no/no/./.././../coffee/thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/./../coffee/coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/no/./../turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/no/./.././../coffee/tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/no/./.././../coffee/no/./../vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/no/no/./.././../no/no/./.././../coffee/thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/./../coffee/coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/no/./../turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/no/./.././../coffee/tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/no/./.././../coffee/no/./../vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/no/no/./.././../no/no/./.././../coffee/thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "/no/no/./.././../no/no/./.././../coffee/drip", "/espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/no/./.././../coffee/no/./../coldbrew", "/no/./../espresso/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/no/./.././../coffee/turkish", "/espresso/no/./../macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/no/./../tubruk", "/no/no/./.././../espresso/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/./../coffee/vietnamese", "/no/no/./.././../espresso/no/./../cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/thai", "/no/no/./.././../no/no/./.././../espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "/no/no/./.././../no/no/./.././../espresso/espresso", &info) => 0; + lfs3_stat(&lfs3, "/no/no/./.././../no/no/./.././../espresso/espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/./.././../espresso/no/./../americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/./.././../espresso/no/./../americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/./.././../espresso/macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/no/./.././../espresso/macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/no/./../latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/no/./../latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/no/./../espresso/cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/no/./../espresso/cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "/no/no/./.././../no/no/./.././../coffee/drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/./.././../coffee/no/./../coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/./.././../coffee/turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/no/./../tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/./../coffee/vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/./.././../no/no/./.././../coffee/drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/./.././../coffee/no/./../coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/./.././../coffee/turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/no/./../tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/./../coffee/vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/espresso") => 0; - lfsr_remove(&lfs, "/no/./../espresso/americano") => 0; - lfsr_remove(&lfs, "/espresso/no/./../macchiato") => 0; - lfsr_remove(&lfs, "/no/no/./.././../espresso/latte") => 0; - lfsr_remove(&lfs, "/no/no/./.././../espresso/no/./../cappuccino") => 0; - lfsr_remove(&lfs, "/no/no/./.././../no/no/./.././../espresso/mocha") => 0; + lfs3_remove(&lfs3, "/espresso/espresso") => 0; + lfs3_remove(&lfs3, "/no/./../espresso/americano") => 0; + lfs3_remove(&lfs3, "/espresso/no/./../macchiato") => 0; + lfs3_remove(&lfs3, "/no/no/./.././../espresso/latte") => 0; + lfs3_remove(&lfs3, "/no/no/./.././../espresso/no/./../cappuccino") => 0; + lfs3_remove(&lfs3, "/no/no/./.././../no/no/./.././../espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "/no/no/./.././../no/no/./.././../espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/./.././../espresso/no/./../americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/no/./.././../espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/no/./../latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/no/./../espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/./.././../no/no/./.././../espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/./.././../espresso/no/./../americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/no/./.././../espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/no/./../latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/no/./../espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # dot dot dot path tests [cases.test_paths_dotdotdots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; - lfsr_mkdir(&lfs, "coffee/...") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee/...") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/.../drip") => 0; - lfsr_mkdir(&lfs, "/coffee/.../coldbrew") => 0; - lfsr_mkdir(&lfs, "/coffee/.../turkish") => 0; - lfsr_mkdir(&lfs, "/coffee/.../tubruk") => 0; - lfsr_mkdir(&lfs, "/coffee/.../vietnamese") => 0; - lfsr_mkdir(&lfs, "/coffee/.../thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/.../drip") => 0; + lfs3_mkdir(&lfs3, "/coffee/.../coldbrew") => 0; + lfs3_mkdir(&lfs3, "/coffee/.../turkish") => 0; + lfs3_mkdir(&lfs3, "/coffee/.../tubruk") => 0; + lfs3_mkdir(&lfs3, "/coffee/.../vietnamese") => 0; + lfs3_mkdir(&lfs3, "/coffee/.../thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/coffee/.../drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/coffee/.../drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/.../coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/.../coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/.../turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/.../turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/.../tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/.../tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/.../vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/.../vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/.../thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/.../thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.../drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.../thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.../thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/.../drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/.../coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/.../turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/.../tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/.../vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/.../thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/.../drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/.../coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/.../turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/.../tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/.../vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/.../thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/.../thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_mkdir(&lfs, "espresso/...") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso/...") => 0; + lfs3_rename(&lfs3, "/coffee/.../drip", "/espresso/.../espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/.../coldbrew", "/espresso/.../americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/.../turkish", "/espresso/.../macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/.../tubruk", "/espresso/.../latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/.../vietnamese", "/espresso/.../cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/.../thai", "/espresso/.../mocha") => 0; // stat paths - lfsr_stat(&lfs, "/espresso/.../espresso", &info) => 0; + lfs3_stat(&lfs3, "/espresso/.../espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/.../americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/.../americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/.../macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/.../macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/.../latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/.../latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/.../cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/.../cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/.../mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/.../mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "coffee/.../drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/.../coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/.../turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/.../tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/.../vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/.../thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.../drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.../coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.../turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.../tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.../vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.../thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/.../espresso") => 0; - lfsr_remove(&lfs, "/espresso/.../americano") => 0; - lfsr_remove(&lfs, "/espresso/.../macchiato") => 0; - lfsr_remove(&lfs, "/espresso/.../latte") => 0; - lfsr_remove(&lfs, "/espresso/.../cappuccino") => 0; - lfsr_remove(&lfs, "/espresso/.../mocha") => 0; + lfs3_remove(&lfs3, "/espresso/.../espresso") => 0; + lfs3_remove(&lfs3, "/espresso/.../americano") => 0; + lfs3_remove(&lfs3, "/espresso/.../macchiato") => 0; + lfs3_remove(&lfs3, "/espresso/.../latte") => 0; + lfs3_remove(&lfs3, "/espresso/.../cappuccino") => 0; + lfs3_remove(&lfs3, "/espresso/.../mocha") => 0; // stat paths - lfsr_stat(&lfs, "/espresso/.../espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/.../americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/.../macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/.../latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/.../cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/.../mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.../espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.../americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.../macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.../latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.../cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.../mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # leading dot path test [cases.test_paths_leading_dots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/coffee/.drip") => 0; - lfsr_mkdir(&lfs, "/coffee/..coldbrew") => 0; - lfsr_mkdir(&lfs, "/coffee/...turkish") => 0; - lfsr_mkdir(&lfs, "/coffee/....tubruk") => 0; - lfsr_mkdir(&lfs, "/coffee/.....vietnamese") => 0; - lfsr_mkdir(&lfs, "/coffee/......thai") => 0; + lfs3_mkdir(&lfs3, "/coffee/.drip") => 0; + lfs3_mkdir(&lfs3, "/coffee/..coldbrew") => 0; + lfs3_mkdir(&lfs3, "/coffee/...turkish") => 0; + lfs3_mkdir(&lfs3, "/coffee/....tubruk") => 0; + lfs3_mkdir(&lfs3, "/coffee/.....vietnamese") => 0; + lfs3_mkdir(&lfs3, "/coffee/......thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/coffee/.drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "/coffee/.drip", &info) => 0; assert(strcmp(info.name, ".drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/..coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/..coldbrew", &info) => 0; assert(strcmp(info.name, "..coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/...turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/...turkish", &info) => 0; assert(strcmp(info.name, "...turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/....tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/....tubruk", &info) => 0; assert(strcmp(info.name, "....tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/.....vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/.....vietnamese", &info) => 0; assert(strcmp(info.name, ".....vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/coffee/......thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/coffee/......thai", &info) => 0; assert(strcmp(info.name, "......thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "/coffee/.drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/..coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/...turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/....tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/.....vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/coffee/......thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/..coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/...turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/....tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/.....vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/coffee/......thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/.drip") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/..coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/...turkish") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/....tubruk") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/.....vietnamese") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/coffee/......thai") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/.drip") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/..coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/...turkish") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/....tubruk") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/.....vietnamese") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/coffee/......thai") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/coffee/.drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/..coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/...turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/....tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/.....vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "/coffee/......thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/coffee/.drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/..coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/...turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/....tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/.....vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "/coffee/......thai") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "/coffee/.drip", "/espresso/.espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/..coldbrew", "/espresso/..americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/...turkish", "/espresso/...macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/....tubruk", "/espresso/....latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/.....vietnamese", "/espresso/.....cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/coffee/......thai", "/espresso/......mocha") => 0; // stat paths - lfsr_stat(&lfs, "/espresso/.espresso", &info) => 0; + lfs3_stat(&lfs3, "/espresso/.espresso", &info) => 0; assert(strcmp(info.name, ".espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/..americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/..americano", &info) => 0; assert(strcmp(info.name, "..americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/...macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/...macchiato", &info) => 0; assert(strcmp(info.name, "...macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/....latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/....latte", &info) => 0; assert(strcmp(info.name, "....latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/.....cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/.....cappuccino", &info) => 0; assert(strcmp(info.name, ".....cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "/espresso/......mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "/espresso/......mocha", &info) => 0; assert(strcmp(info.name, "......mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "coffee/.drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/..coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/...turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/....tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/.....vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/......thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/..coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/...turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/....tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/.....vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/......thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "/espresso/.espresso") => 0; - lfsr_remove(&lfs, "/espresso/..americano") => 0; - lfsr_remove(&lfs, "/espresso/...macchiato") => 0; - lfsr_remove(&lfs, "/espresso/....latte") => 0; - lfsr_remove(&lfs, "/espresso/.....cappuccino") => 0; - lfsr_remove(&lfs, "/espresso/......mocha") => 0; + lfs3_remove(&lfs3, "/espresso/.espresso") => 0; + lfs3_remove(&lfs3, "/espresso/..americano") => 0; + lfs3_remove(&lfs3, "/espresso/...macchiato") => 0; + lfs3_remove(&lfs3, "/espresso/....latte") => 0; + lfs3_remove(&lfs3, "/espresso/.....cappuccino") => 0; + lfs3_remove(&lfs3, "/espresso/......mocha") => 0; // stat paths - lfsr_stat(&lfs, "/espresso/.espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/..americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/...macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/....latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/.....cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "/espresso/......mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/..americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/...macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/....latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/.....cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "/espresso/......mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # root dot dot path test [cases.test_paths_root_dotdots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "no") => 0; - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "no") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "/../coffee/drip") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "/../../coffee/coldbrew") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "/../../../coffee/turkish") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "/no/../../coffee/tubruk") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "/no/../../../coffee/vietnamese") => LFS_ERR_INVAL; - lfsr_mkdir(&lfs, "/no/../../../../coffee/thai") => LFS_ERR_INVAL; + lfs3_mkdir(&lfs3, "/../coffee/drip") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "/../../coffee/coldbrew") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "/../../../coffee/turkish") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "/no/../../coffee/tubruk") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "/no/../../../coffee/vietnamese") => LFS3_ERR_INVAL; + lfs3_mkdir(&lfs3, "/no/../../../../coffee/thai") => LFS3_ERR_INVAL; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/../coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../../coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/../coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../../coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; } // ok, actually create paths if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "/no/../../../../coffee/drip", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "/no/../../../coffee/coldbrew", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "/no/../../coffee/turkish", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "/../../../coffee/tubruk", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "/../../coffee/vietnamese", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "/../coffee/thai", &info) => LFS_ERR_INVAL; + struct lfs3_info info; + lfs3_stat(&lfs3, "/no/../../../../coffee/drip", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "/no/../../../coffee/coldbrew", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "/no/../../coffee/turkish", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "/../../../coffee/tubruk", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "/../../coffee/vietnamese", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "/../coffee/thai", &info) => LFS3_ERR_INVAL; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/../coffee/drip", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../../coffee/turkish", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../coffee/tubruk", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../coffee/vietnamese", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../../coffee/thai", - LFS_O_RDONLY) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/../coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../../coffee/turkish", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../coffee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../coffee/vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../../coffee/thai", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../../coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../../coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/../../../coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "/no/../../../../coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/../../../coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "/no/../../../../coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/../coffee/drip") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "/../../coffee/coldbrew") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "/../../../coffee/turkish") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "/no/../../coffee/tubruk") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "/no/../../../coffee/vietnamese") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "/no/../../../../coffee/thai") => LFS_ERR_INVAL; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/../coffee/drip") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "/../../coffee/coldbrew") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "/../../../coffee/turkish") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "/no/../../coffee/tubruk") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "/no/../../../coffee/vietnamese") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "/no/../../../../coffee/thai") => LFS3_ERR_INVAL; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/../../../../coffee/drip", - "espresso/espresso") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/no/../../../coffee/coldbrew", - "espresso/americano") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/no/../../coffee/turkish", - "espresso/macchiato") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../../../coffee/tubruk", - "espresso/latte") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../../coffee/vietnamese", - "espresso/cappuccino") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../coffee/thai", - "espresso/mocha") => LFS_ERR_INVAL; + "espresso/mocha") => LFS3_ERR_INVAL; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "/../espresso/espresso") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../espresso/espresso") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/coldbrew", - "/../../espresso/americano") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../../espresso/americano") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish", - "/../../../espresso/macchiato") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../../../espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk", - "/no/../../espresso/latte") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../espresso/latte") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese", - "/no/../../../espresso/cappuccino") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../../espresso/cappuccino") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai", - "/no/../../../../espresso/mocha") => LFS_ERR_INVAL; + "/no/../../../../espresso/mocha") => LFS3_ERR_INVAL; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/../../../../coffee/drip", - "/../espresso/espresso") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../espresso/espresso") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/no/../../../coffee/coldbrew", - "/../../espresso/americano") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../../espresso/americano") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/no/../../coffee/turkish", - "/../../../espresso/macchiato") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../../../espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../../../coffee/tubruk", - "/no/../../espresso/latte") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../espresso/latte") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../../coffee/vietnamese", - "/no/../../../espresso/cappuccino") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../../espresso/cappuccino") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../coffee/thai", - "/no/../../../../espresso/mocha") => LFS_ERR_INVAL; + "/no/../../../../espresso/mocha") => LFS3_ERR_INVAL; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "/no/../../../../coffee/drip", - "/no/../../../../coffee/drip") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../../../coffee/drip") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/no/../../../coffee/coldbrew", - "/no/../../../coffee/coldbrew") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../../coffee/coldbrew") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/no/../../coffee/turkish", - "/no/../../coffee/turkish") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/no/../../coffee/turkish") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../../../coffee/tubruk", - "/../../../coffee/tubruk") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../../../coffee/tubruk") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../../coffee/vietnamese", - "/../../coffee/vietnamese") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "/../../coffee/vietnamese") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/../coffee/thai", - "/../coffee/thai") => LFS_ERR_INVAL; + "/../coffee/thai") => LFS3_ERR_INVAL; // remove paths - lfsr_remove(&lfs, "/../espresso/espresso") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "/../../espresso/americano") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "/../../../espresso/macchiato") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "/no/../../espresso/latte") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "/no/../../../espresso/cappuccino") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "/no/../../../../espresso/mocha") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "/../espresso/espresso") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "/../../espresso/americano") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "/../../../espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "/no/../../espresso/latte") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "/no/../../../espresso/cappuccino") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "/no/../../../../espresso/mocha") => LFS3_ERR_INVAL; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # trailing noent tests [cases.test_paths_noent] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/_rip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/c_ldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tu_kish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tub_uk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/_vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai_", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/_rip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/c_ldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tu_kish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tub_uk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/_vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai_", &info) => LFS3_ERR_NOENT; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/_rip", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tu_kish", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tub_uk", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/thai_", - LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/_rip", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/thai_", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/_rip") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/c_ldbrew") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/tu_kish") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/tub_uk") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/_vietnamese") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/thai_") => LFS_ERR_NOENT; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/_rip") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/c_ldbrew") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/tu_kish") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/tub_uk") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/_vietnamese") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/thai_") => LFS3_ERR_NOENT; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "coffee/_rip", - "espresso/espresso") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew", - "espresso/americano") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish", - "espresso/macchiato") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk", - "espresso/latte") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese", - "espresso/cappuccino") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_", - "espresso/mocha") => LFS_ERR_NOENT; + "espresso/mocha") => LFS3_ERR_NOENT; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip", - "coffee/_rip") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/_rip") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew", - "coffee/c_ldbrew") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/c_ldbrew") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish", - "coffee/tu_kish") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/tu_kish") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk", - "coffee/tub_uk") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/tub_uk") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese", - "coffee/_vietnamese") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/_vietnamese") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_", - "coffee/thai_") => LFS_ERR_NOENT; + "coffee/thai_") => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "coffee/_rip") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/c_ldbrew") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/tu_kish") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/tub_uk") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/_vietnamese") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/thai_") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/_rip") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/c_ldbrew") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/tu_kish") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/tub_uk") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/_vietnamese") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/thai_") => LFS3_ERR_NOENT; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # parent noent tests [cases.test_paths_noent_parent] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "_offee/drip") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "c_ffee/coldbrew") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "co_fee/turkish") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "cof_ee/tubruk") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "_coffee/vietnamese") => LFS_ERR_NOENT; - lfsr_mkdir(&lfs, "coffee_/thai") => LFS_ERR_NOENT; + lfs3_mkdir(&lfs3, "_offee/drip") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "c_ffee/coldbrew") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "co_fee/turkish") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "cof_ee/tubruk") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "_coffee/vietnamese") => LFS3_ERR_NOENT; + lfs3_mkdir(&lfs3, "coffee_/thai") => LFS3_ERR_NOENT; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "_offee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "c_ffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "co_fee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "cof_ee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "_coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee_/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "_offee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "c_ffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "co_fee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "cof_ee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "_coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee_/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; } // ok, actually create paths if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "_offee/drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "c_ffee/coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "co_fee/turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "cof_ee/tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "_coffee/vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee_/thai", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "_offee/drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "c_ffee/coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "co_fee/turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "cof_ee/tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "_coffee/vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee_/thai", &info) => LFS3_ERR_NOENT; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "_offee/drip", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "c_ffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "co_fee/turkish", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "cof_ee/tubruk", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "_coffee/vietnamese", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee_/thai", - LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "_offee/drip", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "c_ffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "co_fee/turkish", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "cof_ee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "_coffee/vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee_/thai", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "_offee/drip", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "c_ffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "co_fee/turkish", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "cof_ee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "_coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee_/thai", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "_offee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "c_ffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "co_fee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "cof_ee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "_coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee_/thai", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "_offee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "c_ffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "co_fee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "cof_ee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "_coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee_/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "_offee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "c_ffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "co_fee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "cof_ee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "_coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee_/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "_offee/drip") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "c_ffee/coldbrew") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "co_fee/turkish") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "cof_ee/tubruk") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "_coffee/vietnamese") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee_/thai") => LFS_ERR_NOENT; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "_offee/drip") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "c_ffee/coldbrew") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "co_fee/turkish") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "cof_ee/tubruk") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "_coffee/vietnamese") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee_/thai") => LFS3_ERR_NOENT; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "_offee/drip", - "espresso/espresso") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "c_ffee/coldbrew", - "espresso/americano") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "co_fee/turkish", - "espresso/macchiato") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "cof_ee/tubruk", - "espresso/latte") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "_coffee/vietnamese", - "espresso/cappuccino") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee_/thai", - "espresso/mocha") => LFS_ERR_NOENT; + "espresso/mocha") => LFS3_ERR_NOENT; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "_spresso/espresso") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "_spresso/espresso") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/coldbrew", - "e_presso/americano") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "e_presso/americano") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/turkish", - "es_resso/macchiato") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "es_resso/macchiato") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tubruk", - "esp_esso/latte") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "esp_esso/latte") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/vietnamese", - "_espresso/cappuccino") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "_espresso/cappuccino") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai", - "espresso_/mocha") => LFS_ERR_NOENT; + "espresso_/mocha") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "_offee/drip", - "_spresso/espresso") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "_spresso/espresso") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "c_ffee/coldbrew", - "e_presso/americano") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "e_presso/americano") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "co_fee/turkish", - "es_resso/macchiato") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "es_resso/macchiato") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "cof_ee/tubruk", - "esp_esso/latte") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "esp_esso/latte") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "_coffee/vietnamese", - "_espresso/cappuccino") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "_espresso/cappuccino") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee_/thai", - "espresso_/mocha") => LFS_ERR_NOENT; + "espresso_/mocha") => LFS3_ERR_NOENT; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "_offee/drip", - "_offee/drip") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "_offee/drip") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "c_ffee/coldbrew", - "c_ffee/coldbrew") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "c_ffee/coldbrew") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "co_fee/turkish", - "co_fee/turkish") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "co_fee/turkish") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "cof_ee/tubruk", - "cof_ee/tubruk") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "cof_ee/tubruk") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "_coffee/vietnamese", - "_coffee/vietnamese") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "_coffee/vietnamese") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee_/thai", - "coffee_/thai") => LFS_ERR_NOENT; + "coffee_/thai") => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "_offee/drip") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "c_ffee/coldbrew") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "co_fee/turkish") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "cof_ee/tubruk") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "_coffee/vietnamese") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee_/thai") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "_offee/drip") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "c_ffee/coldbrew") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "co_fee/turkish") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "cof_ee/tubruk") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "_coffee/vietnamese") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee_/thai") => LFS3_ERR_NOENT; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # parent notdir tests [cases.test_paths_notdir_parent] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (DIR) { - lfsr_mkdir(&lfs, "drip/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "coldbrew/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "turkish/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "tubruk/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "vietnamese/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "thai/coffee") => LFS_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "drip/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "coldbrew/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "turkish/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "tubruk/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "vietnamese/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "thai/coffee") => LFS3_ERR_NOTDIR; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "drip/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coldbrew/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "turkish/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "tubruk/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "vietnamese/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "thai/coffee", &info) => LFS_ERR_NOTDIR; + struct lfs3_info info; + lfs3_stat(&lfs3, "drip/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coldbrew/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "turkish/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "tubruk/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "vietnamese/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "thai/coffee", &info) => LFS3_ERR_NOTDIR; // file open paths, only works on files! - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "drip/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coldbrew/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "turkish/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "tubruk/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "vietnamese/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "thai/coffee") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "drip/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coldbrew/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "turkish/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "tubruk/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "vietnamese/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "thai/coffee") => LFS3_ERR_NOTDIR; // make some normal paths so we have something to rename - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "drip/coffee", - "espresso/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coldbrew/coffee", - "espresso/americano") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "turkish/coffee", - "espresso/macchiato") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "tubruk/coffee", - "espresso/latte") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "vietnamese/coffee", - "espresso/cappuccino") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "thai/coffee", - "espresso/mocha") => LFS_ERR_NOTDIR; + "espresso/mocha") => LFS3_ERR_NOTDIR; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "drip/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "drip/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew", - "coldbrew/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coldbrew/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish", - "turkish/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "turkish/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk", - "tubruk/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "tubruk/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese", - "vietnamese/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "vietnamese/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai", - "thai/espresso") => LFS_ERR_NOTDIR; + "thai/espresso") => LFS3_ERR_NOTDIR; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "drip/coffee", - "drip/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "drip/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coldbrew/coffee", - "coldbrew/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coldbrew/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "turkish/coffee", - "turkish/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "turkish/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "tubruk/coffee", - "tubruk/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "tubruk/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "vietnamese/coffee", - "vietnamese/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "vietnamese/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "thai/coffee", - "thai/espresso") => LFS_ERR_NOTDIR; + "thai/espresso") => LFS3_ERR_NOTDIR; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "drip/coffee", - "drip/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "drip/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coldbrew/coffee", - "coldbrew/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coldbrew/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "turkish/coffee", - "turkish/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "turkish/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "tubruk/coffee", - "tubruk/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "tubruk/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "vietnamese/coffee", - "vietnamese/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "vietnamese/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "thai/coffee", - "thai/coffee") => LFS_ERR_NOTDIR; + "thai/coffee") => LFS3_ERR_NOTDIR; // remove paths - lfsr_stat(&lfs, "drip/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coldbrew/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "turkish/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "tubruk/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "vietnamese/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "thai/espresso", &info) => LFS_ERR_NOTDIR; + lfs3_stat(&lfs3, "drip/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coldbrew/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "turkish/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "tubruk/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "vietnamese/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "thai/espresso", &info) => LFS3_ERR_NOTDIR; // stat paths - lfsr_stat(&lfs, "drip/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coldbrew/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "turkish/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "tubruk/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "vietnamese/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "thai/espresso", &info) => LFS_ERR_NOTDIR; + lfs3_stat(&lfs3, "drip/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coldbrew/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "turkish/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "tubruk/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "vietnamese/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "thai/espresso", &info) => LFS3_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # noent tests with trailing slashes [cases.test_paths_noent_trailing_slashes] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/_rip//////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/c_ldbrew/////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tu_kish////", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tub_uk///", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/_vietnamese//", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai_/", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/_rip//////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/c_ldbrew/////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tu_kish////", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tub_uk///", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/_vietnamese//", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai_/", &info) => LFS3_ERR_NOENT; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/_rip/", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew//", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tu_kish///", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tub_uk////", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/////", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/thai_//////", - LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/_rip/", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew//", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish///", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk////", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/////", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/thai_//////", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_rip/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew//", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tu_kish///", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tub_uk////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai_//////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/_rip/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish///", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai_//////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/_rip/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew//", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tu_kish///", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tub_uk////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai_//////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/_rip/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish///", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai_//////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/_rip/") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/c_ldbrew//") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/tu_kish///") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/tub_uk////") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/_vietnamese/////") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/thai_//////") => LFS_ERR_NOENT; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/_rip/") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/c_ldbrew//") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/tu_kish///") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/tub_uk////") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/_vietnamese/////") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/thai_//////") => LFS3_ERR_NOENT; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip//////", - "espresso/espresso") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew/////", - "espresso/americano") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish////", - "espresso/macchiato") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk///", - "espresso/latte") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese//", - "espresso/cappuccino") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_/", - "espresso/mocha") => LFS_ERR_NOENT; + "espresso/mocha") => LFS3_ERR_NOENT; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip", - "espresso/espresso/") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew", - "espresso/americano//") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano//") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish", - "espresso/macchiato///") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato///") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk", - "espresso/latte////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese", - "espresso/cappuccino/////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_", - "espresso/mocha//////") => LFS_ERR_NOENT; + "espresso/mocha//////") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip//////", - "espresso/espresso/") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew/////", - "espresso/americano//") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano//") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish////", - "espresso/macchiato///") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato///") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk///", - "espresso/latte////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese//", - "espresso/cappuccino/////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_/", - "espresso/mocha//////") => LFS_ERR_NOENT; + "espresso/mocha//////") => LFS3_ERR_NOENT; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip//////", - "coffee/_rip//////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/_rip//////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew/////", - "coffee/c_ldbrew/////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/c_ldbrew/////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish////", - "coffee/tu_kish////") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/tu_kish////") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk///", - "coffee/tub_uk///") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/tub_uk///") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese//", - "coffee/_vietnamese//") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/_vietnamese//") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_/", - "coffee/thai_/") => LFS_ERR_NOENT; + "coffee/thai_/") => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "coffee/_rip/") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/c_ldbrew//") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/tu_kish///") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/tub_uk////") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/_vietnamese/////") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/thai_//////") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/_rip/") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/c_ldbrew//") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/tu_kish///") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/tub_uk////") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/_vietnamese/////") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/thai_//////") => LFS3_ERR_NOENT; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # noent tests with trailing dots [cases.test_paths_noent_trailing_dots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/_rip/./././././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/c_ldbrew/././././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tu_kish/./././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tub_uk/././.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/_vietnamese/./.", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai_/.", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/_rip/./././././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/c_ldbrew/././././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tu_kish/./././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tub_uk/././.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/_vietnamese/./.", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai_/.", &info) => LFS3_ERR_NOENT; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/_rip/.", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew/./.", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tu_kish/././.", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tub_uk/./././.", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/././././.", - LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/thai_/./././././.", - LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/_rip/.", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew/./.", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish/././.", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk/./././.", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/././././.", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/thai_/./././././.", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_rip/.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tu_kish/././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tub_uk/./././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/thai_/./././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_rip/.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/thai_/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_rip/.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tu_kish/././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/tub_uk/./././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file, "coffee/thai_/./././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_rip/.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "coffee/thai_/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOENT; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/_rip/.") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/c_ldbrew/./.") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/tu_kish/././.") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/tub_uk/./././.") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/_vietnamese/././././.") => LFS_ERR_NOENT; - lfsr_dir_open(&lfs, &dir, "coffee/thai_/./././././.") => LFS_ERR_NOENT; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/_rip/.") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/c_ldbrew/./.") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/tu_kish/././.") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/tub_uk/./././.") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/_vietnamese/././././.") => LFS3_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, "coffee/thai_/./././././.") => LFS3_ERR_NOENT; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip/./././././.", - "espresso/espresso") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew/././././.", - "espresso/americano") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish/./././.", - "espresso/macchiato") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk/././.", - "espresso/latte") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese/./.", - "espresso/cappuccino") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_/.", - "espresso/mocha") => LFS_ERR_NOENT; + "espresso/mocha") => LFS3_ERR_NOENT; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip", - "espresso/espresso/.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew", - "espresso/americano/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish", - "espresso/macchiato/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk", - "espresso/latte/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese", - "espresso/cappuccino/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_", - "espresso/mocha/./././././.") => LFS_ERR_NOENT; + "espresso/mocha/./././././.") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip/./././././.", - "espresso/espresso/.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew/././././.", - "espresso/americano/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish/./././.", - "espresso/macchiato/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk/././.", - "espresso/latte/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese/./.", - "espresso/cappuccino/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_/.", - "espresso/mocha/./././././.") => LFS_ERR_NOENT; + "espresso/mocha/./././././.") => LFS3_ERR_NOENT; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip/./././././.", - "coffee/_rip/./././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/_rip/./././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew/././././.", - "coffee/c_ldbrew/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/c_ldbrew/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish/./././.", - "coffee/tu_kish/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/tu_kish/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk/././.", - "coffee/tub_uk/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/tub_uk/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese/./.", - "coffee/_vietnamese/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "coffee/_vietnamese/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_/.", - "coffee/thai_/.") => LFS_ERR_NOENT; + "coffee/thai_/.") => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "coffee/_rip/.") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/c_ldbrew/./.") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/tu_kish/././.") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/tub_uk/./././.") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/_vietnamese/././././.") => LFS_ERR_NOENT; - lfsr_remove(&lfs, "coffee/thai_/./././././.") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/_rip/.") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/c_ldbrew/./.") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/tu_kish/././.") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/tub_uk/./././.") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/_vietnamese/././././.") => LFS3_ERR_NOENT; + lfs3_remove(&lfs3, "coffee/thai_/./././././.") => LFS3_ERR_NOENT; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # noent tests with trailing dotdots [cases.test_paths_noent_trailing_dotdots] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/_rip/../../../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/c_ldbrew/../../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/tu_kish/../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/tub_uk/../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/_vietnamese/../..", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/_rip/../../../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/c_ldbrew/../../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/tu_kish/../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/tub_uk/../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/_vietnamese/../..", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/thai_/..", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/thai_/..", &info) => 0; assert(strcmp(info.name, "coffee") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/_rip/..", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/c_ldbrew/../..", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/tu_kish/../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/tub_uk/../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/_vietnamese/../../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/thai_/../../../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/_rip/..", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/c_ldbrew/../..", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/tu_kish/../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/tub_uk/../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/_vietnamese/../../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/thai_/../../../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/_rip/..") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/c_ldbrew/../..") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/tu_kish/../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/tub_uk/../../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/_vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/thai_/../../../../../..") => LFS_ERR_INVAL; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/_rip/..") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/c_ldbrew/../..") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/tu_kish/../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/tub_uk/../../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/_vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/thai_/../../../../../..") => LFS3_ERR_INVAL; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip/../../../../../..", - "espresso/espresso") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/c_ldbrew/../../../../..", - "espresso/americano") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tu_kish/../../../..", - "espresso/macchiato") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tub_uk/../../..", - "espresso/latte") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/_vietnamese/../..", - "espresso/cappuccino") => LFS_ERR_INVAL; + "espresso/cappuccino") => LFS3_ERR_INVAL; // this one works - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai_/..", "espresso/mocha") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "espresso/mocha", "coffee") => 0; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip", - "espresso/espresso/..") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/..") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/c_ldbrew", - "espresso/americano/../..") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/../..") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tu_kish", - "espresso/macchiato/../../..") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/../../..") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tub_uk", - "espresso/latte/../../../..") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/../../../..") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/_vietnamese", - "espresso/cappuccino/../../../../..") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/../../../../..") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai_", - "espresso/mocha/../../../../../..") => LFS_ERR_NOENT; + "espresso/mocha/../../../../../..") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip/../../../../../..", - "espresso/espresso/..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso/..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/c_ldbrew/../../../../..", - "espresso/americano/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tu_kish/../../../..", - "espresso/macchiato/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tub_uk/../../..", - "espresso/latte/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/_vietnamese/../..", - "espresso/cappuccino/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/cappuccino/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai_/..", - "espresso/mocha/../../../../../..") => LFS_ERR_INVAL; + "espresso/mocha/../../../../../..") => LFS3_ERR_INVAL; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/_rip/../../../../../..", - "coffee/_rip/../../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/_rip/../../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/c_ldbrew/../../../../..", - "coffee/c_ldbrew/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/c_ldbrew/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tu_kish/../../../..", - "coffee/tu_kish/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/tu_kish/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tub_uk/../../..", - "coffee/tub_uk/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/tub_uk/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/_vietnamese/../..", - "coffee/_vietnamese/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/_vietnamese/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai_/..", "coffee/thai_/..") => 0; // remove paths - lfsr_remove(&lfs, "coffee/_rip/..") => LFS_ERR_NOTEMPTY; - lfsr_remove(&lfs, "coffee/c_ldbrew/../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/tu_kish/../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/tub_uk/../../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/_vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/thai_/../../../../../..") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/_rip/..") => LFS3_ERR_NOTEMPTY; + lfs3_remove(&lfs3, "coffee/c_ldbrew/../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/tu_kish/../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/tub_uk/../../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/_vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/thai_/../../../../../..") => LFS3_ERR_INVAL; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # trailing notsup tests [cases.test_paths_notsup] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; // create paths with unknown file types const char *path; - lfsr_mdir_t mdir; - lfsr_did_t did; + lfs3_mdir_t mdir; + lfs3_did_t did; path = "coffee/drip"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/coldbrew"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/turkish"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/tubruk"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/vietnamese"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/thai"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_RDONLY) => LFS_ERR_NOTSUP; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_RDONLY) => LFS3_ERR_NOTSUP; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/turkish") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/thai") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/thai") => LFS3_ERR_NOTDIR; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "espresso") => 0; + lfs3_rename(&lfs3, "coffee/drip", "espresso/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew", "espresso/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/turkish", "espresso/macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/tubruk", "espresso/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/vietnamese", "espresso/cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai", "espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => 0; + lfs3_stat(&lfs3, "espresso/espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "espresso/americano", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "espresso/americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "espresso/macchiato", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "espresso/macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "espresso/latte", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "espresso/latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "espresso/cappuccino", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "espresso/mocha", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "espresso/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/drip", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/turkish", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/tubruk", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/vietnamese", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/thai", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/drip", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/turkish", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/tubruk", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/thai", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "espresso/espresso") => 0; - lfsr_remove(&lfs, "espresso/americano") => 0; - lfsr_remove(&lfs, "espresso/macchiato") => 0; - lfsr_remove(&lfs, "espresso/latte") => 0; - lfsr_remove(&lfs, "espresso/cappuccino") => 0; - lfsr_remove(&lfs, "espresso/mocha") => 0; + lfs3_remove(&lfs3, "espresso/espresso") => 0; + lfs3_remove(&lfs3, "espresso/americano") => 0; + lfs3_remove(&lfs3, "espresso/macchiato") => 0; + lfs3_remove(&lfs3, "espresso/latte") => 0; + lfs3_remove(&lfs3, "espresso/cappuccino") => 0; + lfs3_remove(&lfs3, "espresso/mocha") => 0; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # parent notsup tests [cases.test_paths_notsup_parent] defines.DIR = [false, true] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths with unknown file types const char *path; - lfsr_mdir_t mdir; - lfsr_did_t did; + lfs3_mdir_t mdir; + lfs3_did_t did; path = "drip"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coldbrew"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "turkish"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "tubruk"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "vietnamese"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "thai"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; if (DIR) { - lfsr_mkdir(&lfs, "drip/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "coldbrew/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "turkish/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "tubruk/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "vietnamese/coffee") => LFS_ERR_NOTDIR; - lfsr_mkdir(&lfs, "thai/coffee") => LFS_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "drip/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "coldbrew/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "turkish/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "tubruk/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "vietnamese/coffee") => LFS3_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "thai/coffee") => LFS3_ERR_NOTDIR; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "drip/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coldbrew/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "turkish/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "tubruk/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "vietnamese/coffee", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "thai/coffee", &info) => LFS_ERR_NOTDIR; + struct lfs3_info info; + lfs3_stat(&lfs3, "drip/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coldbrew/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "turkish/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "tubruk/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "vietnamese/coffee", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "thai/coffee", &info) => LFS3_ERR_NOTDIR; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "drip/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coldbrew/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "turkish/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "tubruk/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "vietnamese/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "thai/coffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "drip/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coldbrew/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "turkish/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "tubruk/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "vietnamese/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "thai/coffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "drip/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coldbrew/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "turkish/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "tubruk/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "vietnamese/coffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "thai/coffee") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "drip/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coldbrew/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "turkish/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "tubruk/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "vietnamese/coffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "thai/coffee") => LFS3_ERR_NOTDIR; // make some normal paths so we have something to rename - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/turkish") => 0; - lfsr_mkdir(&lfs, "coffee/tubruk") => 0; - lfsr_mkdir(&lfs, "coffee/vietnamese") => 0; - lfsr_mkdir(&lfs, "coffee/thai") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/turkish") => 0; + lfs3_mkdir(&lfs3, "coffee/tubruk") => 0; + lfs3_mkdir(&lfs3, "coffee/vietnamese") => 0; + lfs3_mkdir(&lfs3, "coffee/thai") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/turkish", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/tubruk", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/vietnamese", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/thai", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/turkish", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/tubruk", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/thai", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "drip/coffee", - "espresso/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coldbrew/coffee", - "espresso/americano") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "turkish/coffee", - "espresso/macchiato") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "tubruk/coffee", - "espresso/latte") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "vietnamese/coffee", - "espresso/cappuccino") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "thai/coffee", - "espresso/mocha") => LFS_ERR_NOTDIR; + "espresso/mocha") => LFS3_ERR_NOTDIR; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "drip/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "drip/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew", - "coldbrew/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coldbrew/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish", - "turkish/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "turkish/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk", - "tubruk/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "tubruk/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese", - "vietnamese/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "vietnamese/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai", - "thai/espresso") => LFS_ERR_NOTDIR; + "thai/espresso") => LFS3_ERR_NOTDIR; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "drip/coffee", - "drip/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "drip/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coldbrew/coffee", - "coldbrew/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coldbrew/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "turkish/coffee", - "turkish/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "turkish/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "tubruk/coffee", - "tubruk/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "tubruk/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "vietnamese/coffee", - "vietnamese/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "vietnamese/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "thai/coffee", - "thai/espresso") => LFS_ERR_NOTDIR; + "thai/espresso") => LFS3_ERR_NOTDIR; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "drip/coffee", - "drip/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "drip/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coldbrew/coffee", - "coldbrew/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coldbrew/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "turkish/coffee", - "turkish/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "turkish/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "tubruk/coffee", - "tubruk/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "tubruk/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "vietnamese/coffee", - "vietnamese/coffee") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "vietnamese/coffee") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "thai/coffee", - "thai/coffee") => LFS_ERR_NOTDIR; + "thai/coffee") => LFS3_ERR_NOTDIR; // remove paths - lfsr_stat(&lfs, "drip/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coldbrew/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "turkish/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "tubruk/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "vietnamese/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "thai/espresso", &info) => LFS_ERR_NOTDIR; + lfs3_stat(&lfs3, "drip/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coldbrew/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "turkish/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "tubruk/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "vietnamese/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "thai/espresso", &info) => LFS3_ERR_NOTDIR; // stat paths - lfsr_stat(&lfs, "drip/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coldbrew/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "turkish/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "tubruk/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "vietnamese/espresso", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "thai/espresso", &info) => LFS_ERR_NOTDIR; + lfs3_stat(&lfs3, "drip/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coldbrew/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "turkish/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "tubruk/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "vietnamese/espresso", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "thai/espresso", &info) => LFS3_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # notsup tests with trailing slashes [cases.test_paths_notsup_trailing_slashes] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; // create paths with unknown file types const char *path; - lfsr_mdir_t mdir; - lfsr_did_t did; + lfs3_mdir_t mdir; + lfs3_did_t did; path = "coffee/drip"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/coldbrew"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/turkish"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/tubruk"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/vietnamese"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/thai"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/drip//////", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/coldbrew/////", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/turkish////", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/tubruk///", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/vietnamese//", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/thai/", &info) => LFS_ERR_NOTDIR; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/drip//////", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/coldbrew/////", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/turkish////", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/tubruk///", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/vietnamese//", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/thai/", &info) => LFS3_ERR_NOTDIR; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew//", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish///", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai//////", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew//", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish///", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai//////", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew//") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/turkish///") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk////") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/////") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/thai//////") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew//") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish///") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk////") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/////") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/thai//////") => LFS3_ERR_NOTDIR; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip//////", - "espresso/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/////", - "espresso/americano") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish////", - "espresso/macchiato") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk///", - "espresso/latte") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese//", - "espresso/cappuccino") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/", - "espresso/mocha") => LFS_ERR_NOTDIR; + "espresso/mocha") => LFS3_ERR_NOTDIR; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso/") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano//") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano//") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato///") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato///") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino/////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha//////") => LFS_ERR_NOTDIR; + "espresso/mocha//////") => LFS3_ERR_NOTDIR; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip//////", - "espresso/espresso/") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso/") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/////", - "espresso/americano//") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano//") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish////", - "espresso/macchiato///") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato///") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk///", - "espresso/latte////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese//", - "espresso/cappuccino/////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino/////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/", - "espresso/mocha//////") => LFS_ERR_NOTDIR; + "espresso/mocha//////") => LFS3_ERR_NOTDIR; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip//////", - "coffee/drip//////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/drip//////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/////", - "coffee/coldbrew/////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/coldbrew/////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish////", - "coffee/turkish////") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/turkish////") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk///", - "coffee/tubruk///") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/tubruk///") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese//", - "coffee/vietnamese//") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/vietnamese//") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/", - "coffee/thai/") => LFS_ERR_NOTDIR; + "coffee/thai/") => LFS3_ERR_NOTDIR; // remove paths - lfsr_remove(&lfs, "coffee/drip/") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/coldbrew//") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/turkish///") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/tubruk////") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/vietnamese/////") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/thai//////") => LFS_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/drip/") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/coldbrew//") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/turkish///") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/tubruk////") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/vietnamese/////") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/thai//////") => LFS3_ERR_NOTDIR; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # notsup tests with trailing dots [cases.test_paths_notsup_trailing_dots] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; // create paths with unknown file types const char *path; - lfsr_mdir_t mdir; - lfsr_did_t did; + lfs3_mdir_t mdir; + lfs3_did_t did; path = "coffee/drip"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/coldbrew"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/turkish"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/tubruk"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/vietnamese"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/thai"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/drip/./././././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/coldbrew/././././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/turkish/./././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/tubruk/././.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/vietnamese/./.", &info) => LFS_ERR_NOTDIR; - lfsr_stat(&lfs, "coffee/thai/.", &info) => LFS_ERR_NOTDIR; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/drip/./././././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/coldbrew/././././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/turkish/./././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/tubruk/././.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/vietnamese/./.", &info) => LFS3_ERR_NOTDIR; + lfs3_stat(&lfs3, "coffee/thai/.", &info) => LFS3_ERR_NOTDIR; // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_RDONLY) => LFS_ERR_NOTDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_RDONLY) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/drip/.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/./.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/tubruk/./././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; - lfsr_file_open(&lfs, &file, "coffee/thai/./././././.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/drip/.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/./.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/./././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; + lfs3_file_open(&lfs3, &file, "coffee/thai/./././././.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NOTDIR; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew/./.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/turkish/././.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk/./././.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/././././.") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/thai/./././././.") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew/./.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish/././.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk/./././.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/././././.") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/thai/./././././.") => LFS3_ERR_NOTDIR; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", - "espresso/espresso") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", - "espresso/americano") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish/./././.", - "espresso/macchiato") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk/././.", - "espresso/latte") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese/./.", - "espresso/cappuccino") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/.", - "espresso/mocha") => LFS_ERR_NOTDIR; + "espresso/mocha") => LFS3_ERR_NOTDIR; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano/./.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato/././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte/./././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/././././.") => LFS_ERR_NOENT; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOENT; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha/./././././.") => LFS_ERR_NOENT; + "espresso/mocha/./././././.") => LFS3_ERR_NOENT; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", - "espresso/espresso/.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/espresso/.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", - "espresso/americano/./.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/americano/./.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish/./././.", - "espresso/macchiato/././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/macchiato/././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk/././.", - "espresso/latte/./././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/latte/./././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese/./.", - "espresso/cappuccino/././././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "espresso/cappuccino/././././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/.", - "espresso/mocha/./././././.") => LFS_ERR_NOTDIR; + "espresso/mocha/./././././.") => LFS3_ERR_NOTDIR; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/./././././.", - "coffee/drip/./././././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/drip/./././././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/coldbrew/././././.", - "coffee/coldbrew/././././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/coldbrew/././././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/turkish/./././.", - "coffee/turkish/./././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/turkish/./././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/tubruk/././.", - "coffee/tubruk/././.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/tubruk/././.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/vietnamese/./.", - "coffee/vietnamese/./.") => LFS_ERR_NOTDIR; - lfsr_rename(&lfs, + "coffee/vietnamese/./.") => LFS3_ERR_NOTDIR; + lfs3_rename(&lfs3, "coffee/thai/.", - "coffee/thai/.") => LFS_ERR_NOTDIR; + "coffee/thai/.") => LFS3_ERR_NOTDIR; // remove paths - lfsr_remove(&lfs, "coffee/drip/.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/coldbrew/./.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/turkish/././.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/tubruk/./././.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/vietnamese/././././.") => LFS_ERR_NOTDIR; - lfsr_remove(&lfs, "coffee/thai/./././././.") => LFS_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/drip/.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/coldbrew/./.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/turkish/././.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/tubruk/./././.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/vietnamese/././././.") => LFS3_ERR_NOTDIR; + lfs3_remove(&lfs3, "coffee/thai/./././././.") => LFS3_ERR_NOTDIR; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # notsup tests with trailing dotdots [cases.test_paths_notsup_trailing_dotdots] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; // create paths with unknown file types const char *path; - lfsr_mdir_t mdir; - lfsr_did_t did; + lfs3_mdir_t mdir; + lfs3_did_t did; path = "coffee/drip"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/coldbrew"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/turkish"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/tubruk"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/vietnamese"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; path = "coffee/thai"; - lfsr_mtree_pathlookup(&lfs, &path, - &mdir, NULL, &did) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_CAT( - LFSR_TAG_NAME + 0x13, +1, - lfsr_data_fromleb128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), - LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; + lfs3_mtree_pathlookup(&lfs3, &path, + &mdir, NULL, &did) => LFS3_ERR_NOENT; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( + LFS3_RATTR_CAT( + LFS3_TAG_NAME + 0x13, +1, + lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), + LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/drip/../../../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/coldbrew/../../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/turkish/../../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/tubruk/../../..", &info) => LFS_ERR_INVAL; - lfsr_stat(&lfs, "coffee/vietnamese/../..", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/drip/../../../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/coldbrew/../../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/turkish/../../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/tubruk/../../..", &info) => LFS3_ERR_INVAL; + lfs3_stat(&lfs3, "coffee/vietnamese/../..", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "coffee/thai/..", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "coffee/thai/..", &info) => 0; assert(strcmp(info.name, "coffee") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // file open paths, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip/..", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew/../..", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/turkish/../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/tubruk/../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/vietnamese/../../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; - lfsr_file_open(&lfs, &file, "coffee/thai/../../../../../..", - LFS_O_RDONLY) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip/..", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew/../..", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/turkish/../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/tubruk/../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/vietnamese/../../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "coffee/thai/../../../../../..", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; // dir open paths, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/drip/..") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew/../..") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/turkish/../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/tubruk/../../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_dir_open(&lfs, &dir, "coffee/thai/../../../../../..") => LFS_ERR_INVAL; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/drip/..") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew/../..") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/turkish/../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/tubruk/../../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_dir_open(&lfs3, &dir, "coffee/thai/../../../../../..") => LFS3_ERR_INVAL; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; // bad source - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/../../../../../..", - "espresso/espresso") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/coldbrew/../../../../..", - "espresso/americano") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish/../../../..", - "espresso/macchiato") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk/../../..", - "espresso/latte") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese/../..", - "espresso/cappuccino") => LFS_ERR_INVAL; + "espresso/cappuccino") => LFS3_ERR_INVAL; // this one works - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/thai/..", "espresso/mocha") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "espresso/mocha", "coffee") => 0; // bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip", - "espresso/espresso/..") => LFS_ERR_ISDIR; - lfsr_rename(&lfs, + "espresso/espresso/..") => LFS3_ERR_ISDIR; + lfs3_rename(&lfs3, "coffee/coldbrew", - "espresso/americano/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish", - "espresso/macchiato/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk", - "espresso/latte/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese", - "espresso/cappuccino/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/cappuccino/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai", - "espresso/mocha/../../../../../..") => LFS_ERR_INVAL; + "espresso/mocha/../../../../../..") => LFS3_ERR_INVAL; // bad source and bad destination - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/../../../../../..", - "espresso/espresso/..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/espresso/..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/coldbrew/../../../../..", - "espresso/americano/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/americano/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish/../../../..", - "espresso/macchiato/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/macchiato/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk/../../..", - "espresso/latte/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/latte/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese/../..", - "espresso/cappuccino/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "espresso/cappuccino/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai/..", - "espresso/mocha/../../../../../..") => LFS_ERR_INVAL; + "espresso/mocha/../../../../../..") => LFS3_ERR_INVAL; // here's a weird one, what happens if our rename is also a noop? - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/drip/../../../../../..", - "coffee/drip/../../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/drip/../../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/coldbrew/../../../../..", - "coffee/coldbrew/../../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/coldbrew/../../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/turkish/../../../..", - "coffee/turkish/../../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/turkish/../../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/tubruk/../../..", - "coffee/tubruk/../../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/tubruk/../../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/vietnamese/../..", - "coffee/vietnamese/../..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, + "coffee/vietnamese/../..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee/thai/..", "coffee/thai/..") => 0; // remove paths - lfsr_remove(&lfs, "coffee/drip/..") => LFS_ERR_NOTEMPTY; - lfsr_remove(&lfs, "coffee/coldbrew/../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/turkish/../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/tubruk/../../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/vietnamese/../../../../..") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee/thai/../../../../../..") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/drip/..") => LFS3_ERR_NOTEMPTY; + lfs3_remove(&lfs3, "coffee/coldbrew/../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/turkish/../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/tubruk/../../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/vietnamese/../../../../..") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee/thai/../../../../../..") => LFS3_ERR_INVAL; // stat paths - lfsr_stat(&lfs, "espresso/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "espresso/mocha", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "espresso/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "espresso/mocha", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/turkish", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/turkish", &info) => 0; assert(strcmp(info.name, "turkish") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/tubruk", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/tubruk", &info) => 0; assert(strcmp(info.name, "tubruk") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/vietnamese", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/vietnamese", &info) => 0; assert(strcmp(info.name, "vietnamese") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); - lfsr_stat(&lfs, "coffee/thai", &info) => 0; + assert(info.type == LFS3_TYPE_UNKNOWN); + lfs3_stat(&lfs3, "coffee/thai", &info) => 0; assert(strcmp(info.name, "thai") == 0); - assert(info.type == LFS_TYPE_UNKNOWN); + assert(info.type == LFS3_TYPE_UNKNOWN); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test an empty path, this should error [cases.test_paths_empty] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; - struct lfs_info info; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; + struct lfs3_info info; // create empty, this should error if (DIR) { - lfsr_mkdir(&lfs, "") => LFS_ERR_INVAL; + lfs3_mkdir(&lfs3, "") => LFS3_ERR_INVAL; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; } // stat empty - lfsr_stat(&lfs, "", &info) => LFS_ERR_INVAL; + lfs3_stat(&lfs3, "", &info) => LFS3_ERR_INVAL; // file open empty, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "", - LFS_O_RDONLY) => LFS_ERR_INVAL; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "", + LFS3_O_RDONLY) => LFS3_ERR_INVAL; - lfsr_file_open(&lfs, &file, "", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_INVAL; - lfsr_file_open(&lfs, &file, "", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_INVAL; + lfs3_file_open(&lfs3, &file, "", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_INVAL; // dir open empty, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "") => LFS_ERR_INVAL; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "") => LFS3_ERR_INVAL; // rename empty, this should error - lfsr_rename(&lfs, "", "coffee") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "", "coffee") => LFS3_ERR_INVAL; - lfsr_mkdir(&lfs, "coffee") => 0; - lfsr_rename(&lfs, "coffee", "") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; + lfs3_rename(&lfs3, "coffee", "") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee") => 0; - lfsr_rename(&lfs, "", "") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "", "") => LFS3_ERR_INVAL; // stat empty - lfsr_stat(&lfs, "", &info) => LFS_ERR_INVAL; + lfs3_stat(&lfs3, "", &info) => LFS3_ERR_INVAL; // remove empty, this should error - lfsr_remove(&lfs, "") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "") => LFS3_ERR_INVAL; // stat empty - lfsr_stat(&lfs, "", &info) => LFS_ERR_INVAL; + lfs3_stat(&lfs3, "", &info) => LFS3_ERR_INVAL; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # root operations @@ -5797,1536 +5797,1536 @@ code = ''' [cases.test_paths_root] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; - struct lfs_info info; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; + struct lfs3_info info; // create root, this should error if (DIR) { - lfsr_mkdir(&lfs, "/") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "/") => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; } // stat root - lfsr_stat(&lfs, "/", &info) => 0; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // file open root, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; // dir open root, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename root, this should error - lfsr_rename(&lfs, "/", "coffee") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "/", "coffee") => LFS3_ERR_INVAL; - lfsr_mkdir(&lfs, "coffee") => 0; - lfsr_rename(&lfs, "coffee", "/") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; + lfs3_rename(&lfs3, "coffee", "/") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee") => 0; - lfsr_rename(&lfs, "/", "/") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "/", "/") => LFS3_ERR_INVAL; // stat root - lfsr_stat(&lfs, "/", &info) => 0; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // remove root, this should error - lfsr_remove(&lfs, "/") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "/") => LFS3_ERR_INVAL; // stat root - lfsr_stat(&lfs, "/", &info) => 0; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # other root representations [cases.test_paths_root_aliases] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; - struct lfs_info info; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; + struct lfs3_info info; // create root, this should error if (DIR) { - lfsr_mkdir(&lfs, "/") => LFS_ERR_EXIST; - lfsr_mkdir(&lfs, ".") => LFS_ERR_EXIST; - lfsr_mkdir(&lfs, "./") => LFS_ERR_EXIST; - lfsr_mkdir(&lfs, "/.") => LFS_ERR_EXIST; - lfsr_mkdir(&lfs, "//") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "/") => LFS3_ERR_EXIST; + lfs3_mkdir(&lfs3, ".") => LFS3_ERR_EXIST; + lfs3_mkdir(&lfs3, "./") => LFS3_ERR_EXIST; + lfs3_mkdir(&lfs3, "/.") => LFS3_ERR_EXIST; + lfs3_mkdir(&lfs3, "//") => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, ".", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "./", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, ".", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "./", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; } // stat root - lfsr_stat(&lfs, "/", &info) => 0; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, ".", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, ".", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "./", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "./", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "/.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "/.", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "//", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "//", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // file open root, only works on files! - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "/", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, ".", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "./", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/.", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, ".", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "./", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/.", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, ".", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "./", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/.", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "//", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, ".", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "./", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "/.", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "//", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "/", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, ".", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "./", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "/.", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "//", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, ".", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "./", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "/.", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "//", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; // dir open root, only works on dirs! - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, ".") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "./") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "/.") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "//") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, ".") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "./") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "/.") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "//") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename root, this should error - lfsr_rename(&lfs, "/", "coffee") => LFS_ERR_INVAL; - lfsr_rename(&lfs, ".", "coffee") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "./", "coffee") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "/.", "coffee") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "//", "coffee") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "/", "coffee") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, ".", "coffee") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "./", "coffee") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/.", "coffee") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "//", "coffee") => LFS3_ERR_INVAL; - lfsr_mkdir(&lfs, "coffee") => 0; - lfsr_rename(&lfs, "coffee", "/") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "coffee", ".") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "coffee", "./") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "coffee", "/.") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "coffee", "//") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; + lfs3_rename(&lfs3, "coffee", "/") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee", ".") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee", "./") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee", "/.") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "coffee", "//") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "coffee") => 0; - lfsr_rename(&lfs, "/", "/") => LFS_ERR_INVAL; - lfsr_rename(&lfs, ".", ".") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "..", "..") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "./", "./") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "/.", "/.") => LFS_ERR_INVAL; - lfsr_rename(&lfs, "//", "//") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "/", "/") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, ".", ".") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "..", "..") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "./", "./") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "/.", "/.") => LFS3_ERR_INVAL; + lfs3_rename(&lfs3, "//", "//") => LFS3_ERR_INVAL; // stat root - lfsr_stat(&lfs, "/", &info) => 0; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, ".", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, ".", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "./", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "./", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "/.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "/.", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "//", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "//", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); // remove root, this should error - lfsr_remove(&lfs, "/") => LFS_ERR_INVAL; - lfsr_remove(&lfs, ".") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "./") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "/.") => LFS_ERR_INVAL; - lfsr_remove(&lfs, "//") => LFS_ERR_INVAL; + lfs3_remove(&lfs3, "/") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, ".") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "./") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "/.") => LFS3_ERR_INVAL; + lfs3_remove(&lfs3, "//") => LFS3_ERR_INVAL; // stat root - lfsr_stat(&lfs, "/", &info) => 0; + lfs3_stat(&lfs3, "/", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, ".", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, ".", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "./", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "./", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "/.", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "/.", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); - lfsr_stat(&lfs, "//", &info) => 0; + assert(info.type == LFS3_TYPE_DIR); + lfs3_stat(&lfs3, "//", &info) => 0; assert(strcmp(info.name, "/") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # superblock magic shouldn't appear as a file [cases.test_paths_magic_noent] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // stat littlefs, which shouldn't exist - struct lfs_info info; - lfsr_stat(&lfs, "littlefs", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "littlefs", &info) => LFS3_ERR_NOENT; // file open littlefs, which shouldn't exist - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_RDONLY) => LFS3_ERR_NOENT; // dir open littlefs, which shouldn't exist - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "littlefs") => LFS_ERR_NOENT; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "littlefs") => LFS3_ERR_NOENT; // rename littlefs, which shouldn't exist - lfsr_rename(&lfs, "littlefs", "coffee") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "littlefs", "coffee") => LFS3_ERR_NOENT; // remove littlefs, which shouldn't exist - lfsr_remove(&lfs, "littlefs") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "littlefs") => LFS3_ERR_NOENT; // stat littlefs, which shouldn't exist - lfsr_stat(&lfs, "coffee", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "littlefs", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "littlefs", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # superblock magic shouldn't conflict with files, that would be silly [cases.test_paths_magic_conflict] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create littlefs if (DIR) { - lfsr_mkdir(&lfs, "littlefs") => 0; + lfs3_mkdir(&lfs3, "littlefs") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat littlefs - struct lfs_info info; - lfsr_stat(&lfs, "littlefs", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "littlefs", &info) => 0; assert(strcmp(info.name, "littlefs") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open littlefs, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "littlefs", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "littlefs", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open littlefs, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "littlefs") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "littlefs") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "littlefs") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "littlefs") => LFS3_ERR_NOTDIR; } // rename littlefs - lfsr_rename(&lfs, "littlefs", "coffee") => 0; - lfsr_rename(&lfs, "coffee", "littlefs") => 0; + lfs3_rename(&lfs3, "littlefs", "coffee") => 0; + lfs3_rename(&lfs3, "coffee", "littlefs") => 0; // stat littlefs - lfsr_stat(&lfs, "littlefs", &info) => 0; + lfs3_stat(&lfs3, "littlefs", &info) => 0; assert(strcmp(info.name, "littlefs") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "coffee", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee", &info) => LFS3_ERR_NOENT; // remove littlefs - lfsr_remove(&lfs, "littlefs") => 0; + lfs3_remove(&lfs3, "littlefs") => 0; // stat littlefs - lfsr_stat(&lfs, "littlefs", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "littlefs", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test name too long [cases.test_paths_nametoolong] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; char a_name[512]; - memset(a_name, 'a', LFS_NAME_MAX+1); - a_name[LFS_NAME_MAX+1] = '\0'; + memset(a_name, 'a', LFS3_NAME_MAX+1); + a_name[LFS3_NAME_MAX+1] = '\0'; // create names that are too long, should error char path[1024]; - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { sprintf(path, "coffee/%s", a_name); - lfsr_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG; + lfs3_mkdir(&lfs3, path) => LFS3_ERR_NAMETOOLONG; } else { - lfsr_file_t file; + lfs3_file_t file; sprintf(path, "coffee/%s", a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_NAMETOOLONG; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_NAMETOOLONG; } // stat paths - struct lfs_info info; + struct lfs3_info info; sprintf(path, "coffee/%s", a_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; // file open paths, only works on files! - lfsr_file_t file; + lfs3_file_t file; sprintf(path, "coffee/%s", a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_NOENT; // dir open paths, only works on dirs! - lfsr_dir_t dir; + lfs3_dir_t dir; sprintf(path, "coffee/%s", a_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOENT; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOENT; // rename paths - lfsr_mkdir(&lfs, "espresso") => 0; + lfs3_mkdir(&lfs3, "espresso") => 0; sprintf(path, "coffee/%s", a_name); - lfsr_rename(&lfs, path, "espresso/espresso") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, path, "espresso/espresso") => LFS3_ERR_NOENT; // renaming with too long a destination is tricky! if (DIR) { - lfsr_mkdir(&lfs, "coffee/drip") => 0; + lfs3_mkdir(&lfs3, "coffee/drip") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/drip", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/drip", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } sprintf(path, "espresso/%s", a_name); - lfsr_rename(&lfs, "coffee/drip", path) => LFS_ERR_NAMETOOLONG; + lfs3_rename(&lfs3, "coffee/drip", path) => LFS3_ERR_NAMETOOLONG; // stat paths - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "espresso/%s", a_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; // remove paths sprintf(path, "espresso/%s", a_name); - lfsr_remove(&lfs, path) => LFS_ERR_NOENT; + lfs3_remove(&lfs3, path) => LFS3_ERR_NOENT; // stat paths - lfsr_stat(&lfs, "coffee/drip", &info) => 0; + lfs3_stat(&lfs3, "coffee/drip", &info) => 0; assert(strcmp(info.name, "drip") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "espresso/%s", a_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test name really long but not too long [cases.test_paths_namejustlongenough] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; char a_name[512]; - memset(a_name, 'a', LFS_NAME_MAX); - a_name[LFS_NAME_MAX] = '\0'; + memset(a_name, 'a', LFS3_NAME_MAX); + a_name[LFS3_NAME_MAX] = '\0'; char b_name[512]; - memset(b_name, 'b', LFS_NAME_MAX); - b_name[LFS_NAME_MAX] = '\0'; + memset(b_name, 'b', LFS3_NAME_MAX); + b_name[LFS3_NAME_MAX] = '\0'; char c_name[512]; - memset(c_name, 'c', LFS_NAME_MAX); - c_name[LFS_NAME_MAX] = '\0'; + memset(c_name, 'c', LFS3_NAME_MAX); + c_name[LFS3_NAME_MAX] = '\0'; char d_name[512]; - memset(d_name, 'd', LFS_NAME_MAX); - d_name[LFS_NAME_MAX] = '\0'; + memset(d_name, 'd', LFS3_NAME_MAX); + d_name[LFS3_NAME_MAX] = '\0'; char e_name[512]; - memset(e_name, 'e', LFS_NAME_MAX); - e_name[LFS_NAME_MAX] = '\0'; + memset(e_name, 'e', LFS3_NAME_MAX); + e_name[LFS3_NAME_MAX] = '\0'; char f_name[512]; - memset(f_name, 'f', LFS_NAME_MAX); - f_name[LFS_NAME_MAX] = '\0'; + memset(f_name, 'f', LFS3_NAME_MAX); + f_name[LFS3_NAME_MAX] = '\0'; char g_name[512]; - memset(g_name, 'g', LFS_NAME_MAX); - g_name[LFS_NAME_MAX] = '\0'; + memset(g_name, 'g', LFS3_NAME_MAX); + g_name[LFS3_NAME_MAX] = '\0'; char h_name[512]; - memset(h_name, 'h', LFS_NAME_MAX); - h_name[LFS_NAME_MAX] = '\0'; + memset(h_name, 'h', LFS3_NAME_MAX); + h_name[LFS3_NAME_MAX] = '\0'; char i_name[512]; - memset(i_name, 'i', LFS_NAME_MAX); - i_name[LFS_NAME_MAX] = '\0'; + memset(i_name, 'i', LFS3_NAME_MAX); + i_name[LFS3_NAME_MAX] = '\0'; char j_name[512]; - memset(j_name, 'j', LFS_NAME_MAX); - j_name[LFS_NAME_MAX] = '\0'; + memset(j_name, 'j', LFS3_NAME_MAX); + j_name[LFS3_NAME_MAX] = '\0'; char k_name[512]; - memset(k_name, 'k', LFS_NAME_MAX); - k_name[LFS_NAME_MAX] = '\0'; + memset(k_name, 'k', LFS3_NAME_MAX); + k_name[LFS3_NAME_MAX] = '\0'; char l_name[512]; - memset(l_name, 'l', LFS_NAME_MAX); - l_name[LFS_NAME_MAX] = '\0'; + memset(l_name, 'l', LFS3_NAME_MAX); + l_name[LFS3_NAME_MAX] = '\0'; // create names that aren't too long - lfsr_mkdir(&lfs, c_name) => 0; + lfs3_mkdir(&lfs3, c_name) => 0; char path[1024]; if (DIR) { sprintf(path, "%s/%s", c_name, a_name); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; sprintf(path, "%s/%s", c_name, b_name); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; sprintf(path, "%s/%s", c_name, c_name); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; sprintf(path, "%s/%s", c_name, d_name); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; sprintf(path, "%s/%s", c_name, e_name); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; sprintf(path, "%s/%s", c_name, f_name); - lfsr_mkdir(&lfs, path) => 0; + lfs3_mkdir(&lfs3, path) => 0; } else { - lfsr_file_t file; + lfs3_file_t file; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; + struct lfs3_info info; sprintf(path, "%s/%s", c_name, a_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, a_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", c_name, b_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, b_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", c_name, c_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, c_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", c_name, d_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, d_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", c_name, e_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, e_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", c_name, f_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, f_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; + lfs3_file_t file; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; + lfs3_file_t file; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; sprintf(path, "%s/%s", c_name, a_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, b_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, c_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, d_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, e_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; sprintf(path, "%s/%s", c_name, f_name); - lfsr_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, path, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; + lfs3_dir_t dir; sprintf(path, "%s/%s", c_name, a_name); - lfsr_dir_open(&lfs, &dir, path) => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, path) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; sprintf(path, "%s/%s", c_name, b_name); - lfsr_dir_open(&lfs, &dir, path) => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, path) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; sprintf(path, "%s/%s", c_name, c_name); - lfsr_dir_open(&lfs, &dir, path) => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, path) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; sprintf(path, "%s/%s", c_name, d_name); - lfsr_dir_open(&lfs, &dir, path) => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, path) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; sprintf(path, "%s/%s", c_name, e_name); - lfsr_dir_open(&lfs, &dir, path) => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, path) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; sprintf(path, "%s/%s", c_name, f_name); - lfsr_dir_open(&lfs, &dir, path) => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, path) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; + lfs3_dir_t dir; sprintf(path, "%s/%s", c_name, a_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOTDIR; sprintf(path, "%s/%s", c_name, b_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOTDIR; sprintf(path, "%s/%s", c_name, c_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOTDIR; sprintf(path, "%s/%s", c_name, d_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOTDIR; sprintf(path, "%s/%s", c_name, e_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOTDIR; sprintf(path, "%s/%s", c_name, f_name); - lfsr_dir_open(&lfs, &dir, path) => LFS_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, path) => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, e_name) => 0; + lfs3_mkdir(&lfs3, e_name) => 0; char path_[1024]; sprintf(path, "%s/%s", c_name, a_name); sprintf(path_, "%s/%s", e_name, g_name); - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; sprintf(path, "%s/%s", c_name, b_name); sprintf(path_, "%s/%s", e_name, h_name); - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; sprintf(path, "%s/%s", c_name, c_name); sprintf(path_, "%s/%s", e_name, i_name); - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; sprintf(path, "%s/%s", c_name, d_name); sprintf(path_, "%s/%s", e_name, j_name); - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; sprintf(path, "%s/%s", c_name, e_name); sprintf(path_, "%s/%s", e_name, k_name); - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; sprintf(path, "%s/%s", c_name, f_name); sprintf(path_, "%s/%s", e_name, l_name); - lfsr_rename(&lfs, path, path_) => 0; + lfs3_rename(&lfs3, path, path_) => 0; // stat paths sprintf(path, "%s/%s", e_name, g_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, g_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", e_name, h_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, h_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", e_name, i_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, i_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", e_name, j_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, j_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", e_name, k_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, k_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", e_name, l_name); - lfsr_stat(&lfs, path, &info) => 0; + lfs3_stat(&lfs3, path, &info) => 0; assert(strcmp(info.name, l_name) == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); sprintf(path, "%s/%s", c_name, a_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", c_name, b_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", c_name, c_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", c_name, d_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", c_name, e_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", c_name, f_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; // remove paths sprintf(path, "%s/%s", e_name, g_name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; sprintf(path, "%s/%s", e_name, h_name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; sprintf(path, "%s/%s", e_name, i_name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; sprintf(path, "%s/%s", e_name, j_name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; sprintf(path, "%s/%s", e_name, k_name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; sprintf(path, "%s/%s", e_name, l_name); - lfsr_remove(&lfs, path) => 0; + lfs3_remove(&lfs3, path) => 0; // stat paths sprintf(path, "%s/%s", e_name, g_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", e_name, h_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", e_name, i_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", e_name, j_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", e_name, k_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; sprintf(path, "%s/%s", e_name, l_name); - lfsr_stat(&lfs, path, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, path, &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # a quick utf8 test, utf8 is easy to support [cases.test_paths_utf8] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "coffee") => 0; + lfs3_mkdir(&lfs3, "coffee") => 0; if (DIR) { - lfsr_mkdir(&lfs, "coffee/dripcoffee") => 0; - lfsr_mkdir(&lfs, "coffee/coldbrew") => 0; - lfsr_mkdir(&lfs, "coffee/türkkahvesi") => 0; - lfsr_mkdir(&lfs, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") => 0; - lfsr_mkdir(&lfs, "coffee/càphêđá") => 0; - lfsr_mkdir(&lfs, "coffee/โอเลี้ยง") => 0; + lfs3_mkdir(&lfs3, "coffee/dripcoffee") => 0; + lfs3_mkdir(&lfs3, "coffee/coldbrew") => 0; + lfs3_mkdir(&lfs3, "coffee/türkkahvesi") => 0; + lfs3_mkdir(&lfs3, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") => 0; + lfs3_mkdir(&lfs3, "coffee/càphêđá") => 0; + lfs3_mkdir(&lfs3, "coffee/โอเลี้ยง") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "coffee/dripcoffee", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "coffee/dripcoffee", &info) => 0; assert(strcmp(info.name, "dripcoffee") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/coldbrew", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => 0; assert(strcmp(info.name, "coldbrew") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/türkkahvesi", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/türkkahvesi", &info) => 0; assert(strcmp(info.name, "türkkahvesi") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", &info) => 0; assert(strcmp(info.name, "ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/càphêđá", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/càphêđá", &info) => 0; assert(strcmp(info.name, "càphêđá") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "coffee/โอเลี้ยง", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "coffee/โอเลี้ยง", &info) => 0; assert(strcmp(info.name, "โอเลี้ยง") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "coffee/dripcoffee", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/coldbrew", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/türkkahvesi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/càphêđá", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "coffee/โอเลี้ยง", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/dripcoffee", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/coldbrew", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/türkkahvesi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/càphêđá", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "coffee/โอเลี้ยง", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/dripcoffee") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/türkkahvesi") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/càphêđá") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "coffee/โอเลี้ยง") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/dripcoffee") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/türkkahvesi") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/càphêđá") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "coffee/โอเลี้ยง") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "coffee/dripcoffee") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/coldbrew") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/türkkahvesi") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/càphêđá") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "coffee/โอเลี้ยง") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "coffee/dripcoffee") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/coldbrew") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/türkkahvesi") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/càphêđá") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "coffee/โอเลี้ยง") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "caffè") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "caffè") => 0; + lfs3_rename(&lfs3, "coffee/dripcoffee", "caffè/espresso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/coldbrew", "caffè/americano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/türkkahvesi", "caffè/macchiato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", "caffè/latte") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/càphêđá", "caffè/cappuccino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "coffee/โอเลี้ยง", "caffè/mocha") => 0; // stat paths - lfsr_stat(&lfs, "caffè/espresso", &info) => 0; + lfs3_stat(&lfs3, "caffè/espresso", &info) => 0; assert(strcmp(info.name, "espresso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "caffè/americano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "caffè/americano", &info) => 0; assert(strcmp(info.name, "americano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "caffè/macchiato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "caffè/macchiato", &info) => 0; assert(strcmp(info.name, "macchiato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "caffè/latte", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "caffè/latte", &info) => 0; assert(strcmp(info.name, "latte") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "caffè/cappuccino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "caffè/cappuccino", &info) => 0; assert(strcmp(info.name, "cappuccino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "caffè/mocha", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "caffè/mocha", &info) => 0; assert(strcmp(info.name, "mocha") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "coffee/dripcoffee", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/coldbrew", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/türkkahvesi", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/càphêđá", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "coffee/โอเลี้ยง", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/dripcoffee", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/coldbrew", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/türkkahvesi", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/ꦏꦺꦴꦥꦶꦠꦸꦧꦿꦸꦏ꧀", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/càphêđá", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "coffee/โอเลี้ยง", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "caffè/espresso") => 0; - lfsr_remove(&lfs, "caffè/americano") => 0; - lfsr_remove(&lfs, "caffè/macchiato") => 0; - lfsr_remove(&lfs, "caffè/latte") => 0; - lfsr_remove(&lfs, "caffè/cappuccino") => 0; - lfsr_remove(&lfs, "caffè/mocha") => 0; + lfs3_remove(&lfs3, "caffè/espresso") => 0; + lfs3_remove(&lfs3, "caffè/americano") => 0; + lfs3_remove(&lfs3, "caffè/macchiato") => 0; + lfs3_remove(&lfs3, "caffè/latte") => 0; + lfs3_remove(&lfs3, "caffè/cappuccino") => 0; + lfs3_remove(&lfs3, "caffè/mocha") => 0; // stat paths - lfsr_stat(&lfs, "caffè/espresso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "caffè/americano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "caffè/macchiato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "caffè/latte", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "caffè/cappuccino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "caffè/mocha", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "caffè/espresso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "caffè/americano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "caffè/macchiato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "caffè/latte", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "caffè/cappuccino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "caffè/mocha", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # more utf8 tests [cases.test_paths_utf8_ipa] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "ˈkɔ.fi") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi") => 0; if (DIR) { - lfsr_mkdir(&lfs, "ˈkɔ.fi/dɹɪpˈkɔ.fi") => 0; - lfsr_mkdir(&lfs, "ˈkɔ.fi/koʊldbɹuː") => 0; - lfsr_mkdir(&lfs, "ˈkɔ.fi/tyɾckɑhvɛˈsi") => 0; - lfsr_mkdir(&lfs, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚") => 0; - lfsr_mkdir(&lfs, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥") => 0; - lfsr_mkdir(&lfs, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi/dɹɪpˈkɔ.fi") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi/koʊldbɹuː") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi/tyɾckɑhvɛˈsi") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥") => 0; + lfs3_mkdir(&lfs3, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "ˈkɔ.fi/dɹɪpˈkɔ.fi", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "ˈkɔ.fi/dɹɪpˈkɔ.fi", &info) => 0; assert(strcmp(info.name, "dɹɪpˈkɔ.fi") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "ˈkɔ.fi/koʊldbɹuː", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "ˈkɔ.fi/koʊldbɹuː", &info) => 0; assert(strcmp(info.name, "koʊldbɹuː") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "ˈkɔ.fi/tyɾckɑhvɛˈsi", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "ˈkɔ.fi/tyɾckɑhvɛˈsi", &info) => 0; assert(strcmp(info.name, "tyɾckɑhvɛˈsi") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", &info) => 0; assert(strcmp(info.name, "ˈko.piˈt̪up̚.rʊk̚") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", &info) => 0; assert(strcmp(info.name, "kaː˨˩fe˧˧ɗaː˧˥") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", &info) => 0; assert(strcmp(info.name, "ʔoː˧.lia̯ŋ˦˥") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/koʊldbɹuː", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/dɹɪpˈkɔ.fi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/koʊldbɹuː", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/tyɾckɑhvɛˈsi", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/dɹɪpˈkɔ.fi") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/koʊldbɹuː") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/tyɾckɑhvɛˈsi") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/dɹɪpˈkɔ.fi") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/koʊldbɹuː") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/tyɾckɑhvɛˈsi") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/dɹɪpˈkɔ.fi") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/koʊldbɹuː") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/tyɾckɑhvɛˈsi") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/dɹɪpˈkɔ.fi") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/koʊldbɹuː") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/tyɾckɑhvɛˈsi") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "kafˈfɛ") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "kafˈfɛ") => 0; + lfs3_rename(&lfs3, "ˈkɔ.fi/dɹɪpˈkɔ.fi", "kafˈfɛ/eˈsprɛsso") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "ˈkɔ.fi/koʊldbɹuː", "kafˈfɛ/ameriˈkano") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "ˈkɔ.fi/tyɾckɑhvɛˈsi", "kafˈfɛ/makˈkjato") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", "kafˈfɛ/ˈlat.te") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", "kafˈfɛ/kapputˈt͡ʃino") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", "kafˈfɛ/ˈmoʊkə") => 0; // stat paths - lfsr_stat(&lfs, "kafˈfɛ/eˈsprɛsso", &info) => 0; + lfs3_stat(&lfs3, "kafˈfɛ/eˈsprɛsso", &info) => 0; assert(strcmp(info.name, "eˈsprɛsso") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "kafˈfɛ/ameriˈkano", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "kafˈfɛ/ameriˈkano", &info) => 0; assert(strcmp(info.name, "ameriˈkano") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "kafˈfɛ/makˈkjato", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "kafˈfɛ/makˈkjato", &info) => 0; assert(strcmp(info.name, "makˈkjato") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "kafˈfɛ/ˈlat.te", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "kafˈfɛ/ˈlat.te", &info) => 0; assert(strcmp(info.name, "ˈlat.te") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "kafˈfɛ/kapputˈt͡ʃino", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "kafˈfɛ/kapputˈt͡ʃino", &info) => 0; assert(strcmp(info.name, "kapputˈt͡ʃino") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "kafˈfɛ/ˈmoʊkə", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "kafˈfɛ/ˈmoʊkə", &info) => 0; assert(strcmp(info.name, "ˈmoʊkə") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "ˈkɔ.fi/dɹɪpˈkɔ.fi", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ˈkɔ.fi/koʊldbɹuː", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ˈkɔ.fi/tyɾckɑhvɛˈsi", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "ˈkɔ.fi/dɹɪpˈkɔ.fi", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ˈkɔ.fi/koʊldbɹuː", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ˈkɔ.fi/tyɾckɑhvɛˈsi", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ˈkɔ.fi/ˈko.piˈt̪up̚.rʊk̚", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ˈkɔ.fi/kaː˨˩fe˧˧ɗaː˧˥", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "ˈkɔ.fi/ʔoː˧.lia̯ŋ˦˥", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "kafˈfɛ/eˈsprɛsso") => 0; - lfsr_remove(&lfs, "kafˈfɛ/ameriˈkano") => 0; - lfsr_remove(&lfs, "kafˈfɛ/makˈkjato") => 0; - lfsr_remove(&lfs, "kafˈfɛ/ˈlat.te") => 0; - lfsr_remove(&lfs, "kafˈfɛ/kapputˈt͡ʃino") => 0; - lfsr_remove(&lfs, "kafˈfɛ/ˈmoʊkə") => 0; + lfs3_remove(&lfs3, "kafˈfɛ/eˈsprɛsso") => 0; + lfs3_remove(&lfs3, "kafˈfɛ/ameriˈkano") => 0; + lfs3_remove(&lfs3, "kafˈfɛ/makˈkjato") => 0; + lfs3_remove(&lfs3, "kafˈfɛ/ˈlat.te") => 0; + lfs3_remove(&lfs3, "kafˈfɛ/kapputˈt͡ʃino") => 0; + lfs3_remove(&lfs3, "kafˈfɛ/ˈmoʊkə") => 0; // stat paths - lfsr_stat(&lfs, "kafˈfɛ/eˈsprɛsso", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "kafˈfɛ/ameriˈkano", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "kafˈfɛ/makˈkjato", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "kafˈfɛ/ˈlat.te", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "kafˈfɛ/kapputˈt͡ʃino", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "kafˈfɛ/ˈmoʊkə", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "kafˈfɛ/eˈsprɛsso", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "kafˈfɛ/ameriˈkano", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "kafˈfɛ/makˈkjato", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "kafˈfɛ/ˈlat.te", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "kafˈfɛ/kapputˈt͡ʃino", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "kafˈfɛ/ˈmoʊkə", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test spaces have no problems [cases.test_paths_spaces] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "c o f f e e") => 0; + lfs3_mkdir(&lfs3, "c o f f e e") => 0; if (DIR) { - lfsr_mkdir(&lfs, "c o f f e e/d r i p") => 0; - lfsr_mkdir(&lfs, "c o f f e e/c o l d b r e w") => 0; - lfsr_mkdir(&lfs, "c o f f e e/t u r k i s h") => 0; - lfsr_mkdir(&lfs, "c o f f e e/t u b r u k") => 0; - lfsr_mkdir(&lfs, "c o f f e e/v i e t n a m e s e") => 0; - lfsr_mkdir(&lfs, "c o f f e e/t h a i") => 0; + lfs3_mkdir(&lfs3, "c o f f e e/d r i p") => 0; + lfs3_mkdir(&lfs3, "c o f f e e/c o l d b r e w") => 0; + lfs3_mkdir(&lfs3, "c o f f e e/t u r k i s h") => 0; + lfs3_mkdir(&lfs3, "c o f f e e/t u b r u k") => 0; + lfs3_mkdir(&lfs3, "c o f f e e/v i e t n a m e s e") => 0; + lfs3_mkdir(&lfs3, "c o f f e e/t h a i") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "c o f f e e/d r i p", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "c o f f e e/d r i p", &info) => 0; assert(strcmp(info.name, "d r i p") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "c o f f e e/c o l d b r e w", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "c o f f e e/c o l d b r e w", &info) => 0; assert(strcmp(info.name, "c o l d b r e w") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "c o f f e e/t u r k i s h", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "c o f f e e/t u r k i s h", &info) => 0; assert(strcmp(info.name, "t u r k i s h") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "c o f f e e/t u b r u k", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "c o f f e e/t u b r u k", &info) => 0; assert(strcmp(info.name, "t u b r u k") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "c o f f e e/v i e t n a m e s e", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "c o f f e e/v i e t n a m e s e", &info) => 0; assert(strcmp(info.name, "v i e t n a m e s e") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "c o f f e e/t h a i", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "c o f f e e/t h a i", &info) => 0; assert(strcmp(info.name, "t h a i") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "c o f f e e/d r i p", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/c o l d b r e w", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/t u r k i s h", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/t u b r u k", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/v i e t n a m e s e", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "c o f f e e/t h a i", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/d r i p", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/c o l d b r e w", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u r k i s h", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/t u b r u k", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/v i e t n a m e s e", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "c o f f e e/t h a i", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "c o f f e e/d r i p") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "c o f f e e/c o l d b r e w") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "c o f f e e/t u r k i s h") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "c o f f e e/t u b r u k") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "c o f f e e/v i e t n a m e s e") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "c o f f e e/t h a i") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/d r i p") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/c o l d b r e w") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/t u r k i s h") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/t u b r u k") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/v i e t n a m e s e") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/t h a i") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "c o f f e e/d r i p") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "c o f f e e/c o l d b r e w") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "c o f f e e/t u r k i s h") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "c o f f e e/t u b r u k") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "c o f f e e/v i e t n a m e s e") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "c o f f e e/t h a i") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/d r i p") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/c o l d b r e w") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/t u r k i s h") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/t u b r u k") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/v i e t n a m e s e") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "c o f f e e/t h a i") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "e s p r e s s o") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "e s p r e s s o") => 0; + lfs3_rename(&lfs3, "c o f f e e/d r i p", "e s p r e s s o/e s p r e s s o") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "c o f f e e/c o l d b r e w", "e s p r e s s o/a m e r i c a n o") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "c o f f e e/t u r k i s h", "e s p r e s s o/m a c c h i a t o") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "c o f f e e/t u b r u k", "e s p r e s s o/l a t t e") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "c o f f e e/v i e t n a m e s e", "e s p r e s s o/c a p p u c c i n o") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "c o f f e e/t h a i", "e s p r e s s o/m o c h a") => 0; // stat paths - lfsr_stat(&lfs, "e s p r e s s o/e s p r e s s o", &info) => 0; + lfs3_stat(&lfs3, "e s p r e s s o/e s p r e s s o", &info) => 0; assert(strcmp(info.name, "e s p r e s s o") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "e s p r e s s o/a m e r i c a n o", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "e s p r e s s o/a m e r i c a n o", &info) => 0; assert(strcmp(info.name, "a m e r i c a n o") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "e s p r e s s o/m a c c h i a t o", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "e s p r e s s o/m a c c h i a t o", &info) => 0; assert(strcmp(info.name, "m a c c h i a t o") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "e s p r e s s o/l a t t e", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "e s p r e s s o/l a t t e", &info) => 0; assert(strcmp(info.name, "l a t t e") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "e s p r e s s o/c a p p u c c i n o", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "e s p r e s s o/c a p p u c c i n o", &info) => 0; assert(strcmp(info.name, "c a p p u c c i n o") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "e s p r e s s o/m o c h a", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "e s p r e s s o/m o c h a", &info) => 0; assert(strcmp(info.name, "m o c h a") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "c o f f e e/d r i p", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "c o f f e e/c o l d b r e w", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "c o f f e e/t u r k i s h", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "c o f f e e/t u b r u k", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "c o f f e e/v i e t n a m e s e", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "c o f f e e/t h a i", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "c o f f e e/d r i p", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "c o f f e e/c o l d b r e w", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "c o f f e e/t u r k i s h", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "c o f f e e/t u b r u k", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "c o f f e e/v i e t n a m e s e", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "c o f f e e/t h a i", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "e s p r e s s o/e s p r e s s o") => 0; - lfsr_remove(&lfs, "e s p r e s s o/a m e r i c a n o") => 0; - lfsr_remove(&lfs, "e s p r e s s o/m a c c h i a t o") => 0; - lfsr_remove(&lfs, "e s p r e s s o/l a t t e") => 0; - lfsr_remove(&lfs, "e s p r e s s o/c a p p u c c i n o") => 0; - lfsr_remove(&lfs, "e s p r e s s o/m o c h a") => 0; + lfs3_remove(&lfs3, "e s p r e s s o/e s p r e s s o") => 0; + lfs3_remove(&lfs3, "e s p r e s s o/a m e r i c a n o") => 0; + lfs3_remove(&lfs3, "e s p r e s s o/m a c c h i a t o") => 0; + lfs3_remove(&lfs3, "e s p r e s s o/l a t t e") => 0; + lfs3_remove(&lfs3, "e s p r e s s o/c a p p u c c i n o") => 0; + lfs3_remove(&lfs3, "e s p r e s s o/m o c h a") => 0; // stat paths - lfsr_stat(&lfs, "e s p r e s s o/e s p r e s s o", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "e s p r e s s o/a m e r i c a n o", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "e s p r e s s o/m a c c h i a t o", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "e s p r e s s o/l a t t e", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "e s p r e s s o/c a p p u c c i n o", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "e s p r e s s o/m o c h a", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "e s p r e s s o/e s p r e s s o", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "e s p r e s s o/a m e r i c a n o", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "e s p r e s s o/m a c c h i a t o", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "e s p r e s s o/l a t t e", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "e s p r e s s o/c a p p u c c i n o", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "e s p r e s s o/m o c h a", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test with only spaces @@ -7335,247 +7335,247 @@ code = ''' [cases.test_paths_oopsallspaces] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, " ") => 0; + lfs3_mkdir(&lfs3, " ") => 0; if (DIR) { - lfsr_mkdir(&lfs, " / ") => 0; - lfsr_mkdir(&lfs, " / ") => 0; - lfsr_mkdir(&lfs, " / ") => 0; - lfsr_mkdir(&lfs, " / ") => 0; - lfsr_mkdir(&lfs, " / ") => 0; - lfsr_mkdir(&lfs, " / ") => 0; + lfs3_mkdir(&lfs3, " / ") => 0; + lfs3_mkdir(&lfs3, " / ") => 0; + lfs3_mkdir(&lfs3, " / ") => 0; + lfs3_mkdir(&lfs3, " / ") => 0; + lfs3_mkdir(&lfs3, " / ") => 0; + lfs3_mkdir(&lfs3, " / ") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, " / ", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, " / ", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, " / ", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, " / ") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, " / ") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, " / ") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, " / ") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, " / ") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, " / ") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, " / ") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, " / ") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, " / ") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, " / ") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, " / ") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, " / ") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, " / ") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, " / ") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, " / ") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, " / ") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, " / ") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, " / ") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, " / ") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, " / ") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, " / ") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, " / ") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, " / ") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, " / ") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, " ") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, " ") => 0; + lfs3_rename(&lfs3, " / ", " / ") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, " / ", " / ") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, " / ", " / ") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, " / ", " / ") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, " / ", " / ") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, " / ", " / ") => 0; // stat paths - lfsr_stat(&lfs, " / ", &info) => 0; + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, " / ", &info) => 0; assert(strcmp(info.name, " ") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, " / ") => 0; - lfsr_remove(&lfs, " / ") => 0; - lfsr_remove(&lfs, " / ") => 0; - lfsr_remove(&lfs, " / ") => 0; - lfsr_remove(&lfs, " / ") => 0; - lfsr_remove(&lfs, " / ") => 0; + lfs3_remove(&lfs3, " / ") => 0; + lfs3_remove(&lfs3, " / ") => 0; + lfs3_remove(&lfs3, " / ") => 0; + lfs3_remove(&lfs3, " / ") => 0; + lfs3_remove(&lfs3, " / ") => 0; + lfs3_remove(&lfs3, " / ") => 0; // stat paths - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, " / ", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, " / ", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test with only ascii control characters @@ -7584,247 +7584,247 @@ code = ''' [cases.test_paths_nonprintable] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "\x0c") => 0; + lfs3_mkdir(&lfs3, "\x0c") => 0; if (DIR) { - lfsr_mkdir(&lfs, "\x0c/\x01") => 0; - lfsr_mkdir(&lfs, "\x0c/\x02") => 0; - lfsr_mkdir(&lfs, "\x0c/\x03") => 0; - lfsr_mkdir(&lfs, "\x0c/\x04") => 0; - lfsr_mkdir(&lfs, "\x0c/\x05") => 0; - lfsr_mkdir(&lfs, "\x0c/\x06") => 0; + lfs3_mkdir(&lfs3, "\x0c/\x01") => 0; + lfs3_mkdir(&lfs3, "\x0c/\x02") => 0; + lfs3_mkdir(&lfs3, "\x0c/\x03") => 0; + lfs3_mkdir(&lfs3, "\x0c/\x04") => 0; + lfs3_mkdir(&lfs3, "\x0c/\x05") => 0; + lfs3_mkdir(&lfs3, "\x0c/\x06") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "\x0c/\x01", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "\x0c/\x01", &info) => 0; assert(strcmp(info.name, "\x01") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0c/\x02", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0c/\x02", &info) => 0; assert(strcmp(info.name, "\x02") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0c/\x03", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0c/\x03", &info) => 0; assert(strcmp(info.name, "\x03") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0c/\x04", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0c/\x04", &info) => 0; assert(strcmp(info.name, "\x04") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0c/\x05", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0c/\x05", &info) => 0; assert(strcmp(info.name, "\x05") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0c/\x06", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0c/\x06", &info) => 0; assert(strcmp(info.name, "\x06") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\x0c/\x01", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x02", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x03", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x04", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x05", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x0c/\x06", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x01", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x02", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x03", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x04", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x05", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x0c/\x06", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\x0c/\x01") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x0c/\x02") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x0c/\x03") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x0c/\x04") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x0c/\x05") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x0c/\x06") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x01") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x02") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x03") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x04") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x05") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x06") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\x0c/\x01") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x0c/\x02") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x0c/\x03") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x0c/\x04") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x0c/\x05") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x0c/\x06") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x01") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x02") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x03") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x04") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x05") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x0c/\x06") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "\x0e") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "\x0e") => 0; + lfs3_rename(&lfs3, "\x0c/\x01", "\x0e/\x1a") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x0c/\x02", "\x0e/\x1b") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x0c/\x03", "\x0e/\x1c") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x0c/\x04", "\x0e/\x1d") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x0c/\x05", "\x0e/\x1e") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x0c/\x06", "\x0e/\x1f") => 0; // stat paths - lfsr_stat(&lfs, "\x0e/\x1a", &info) => 0; + lfs3_stat(&lfs3, "\x0e/\x1a", &info) => 0; assert(strcmp(info.name, "\x1a") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0e/\x1b", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0e/\x1b", &info) => 0; assert(strcmp(info.name, "\x1b") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0e/\x1c", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0e/\x1c", &info) => 0; assert(strcmp(info.name, "\x1c") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0e/\x1d", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0e/\x1d", &info) => 0; assert(strcmp(info.name, "\x1d") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0e/\x1e", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0e/\x1e", &info) => 0; assert(strcmp(info.name, "\x1e") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x0e/\x1f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x0e/\x1f", &info) => 0; assert(strcmp(info.name, "\x1f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "\x0c/\x01", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0c/\x02", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0c/\x03", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0c/\x04", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0c/\x05", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0c/\x06", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\x0c/\x01", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0c/\x02", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0c/\x03", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0c/\x04", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0c/\x05", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0c/\x06", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "\x0e/\x1a") => 0; - lfsr_remove(&lfs, "\x0e/\x1b") => 0; - lfsr_remove(&lfs, "\x0e/\x1c") => 0; - lfsr_remove(&lfs, "\x0e/\x1d") => 0; - lfsr_remove(&lfs, "\x0e/\x1e") => 0; - lfsr_remove(&lfs, "\x0e/\x1f") => 0; + lfs3_remove(&lfs3, "\x0e/\x1a") => 0; + lfs3_remove(&lfs3, "\x0e/\x1b") => 0; + lfs3_remove(&lfs3, "\x0e/\x1c") => 0; + lfs3_remove(&lfs3, "\x0e/\x1d") => 0; + lfs3_remove(&lfs3, "\x0e/\x1e") => 0; + lfs3_remove(&lfs3, "\x0e/\x1f") => 0; // stat paths - lfsr_stat(&lfs, "\x0e/\x1a", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0e/\x1b", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0e/\x1c", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0e/\x1d", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0e/\x1e", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x0e/\x1f", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\x0e/\x1a", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0e/\x1b", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0e/\x1c", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0e/\x1d", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0e/\x1e", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x0e/\x1f", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test with only ascii DELs @@ -7833,247 +7833,247 @@ code = ''' [cases.test_paths_oopsalldels] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f") => 0; if (DIR) { - lfsr_mkdir(&lfs, "\x7f/\x7f") => 0; - lfsr_mkdir(&lfs, "\x7f/\x7f\x7f") => 0; - lfsr_mkdir(&lfs, "\x7f/\x7f\x7f\x7f") => 0; - lfsr_mkdir(&lfs, "\x7f/\x7f\x7f\x7f\x7f") => 0; - lfsr_mkdir(&lfs, "\x7f/\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_mkdir(&lfs, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f/\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f/\x7f\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f/\x7f\x7f\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f/\x7f\x7f\x7f\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_mkdir(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "\x7f/\x7f", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "\x7f/\x7f", &info) => 0; assert(strcmp(info.name, "\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f/\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f/\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\x7f/\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f\x7f") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f\x7f") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f\x7f") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f\x7f") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "\x7f\x7f") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "\x7f\x7f") => 0; + lfs3_rename(&lfs3, "\x7f/\x7f", "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x7f/\x7f\x7f", "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x7f/\x7f\x7f\x7f", "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x7f/\x7f\x7f\x7f\x7f", "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f", "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; // stat paths - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => 0; assert(strcmp(info.name, "\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "\x7f/\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f/\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f/\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f/\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_remove(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_remove(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_remove(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_remove(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; - lfsr_remove(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_remove(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_remove(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_remove(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_remove(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_remove(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; + lfs3_remove(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f") => 0; // stat paths - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\x7f\x7f/\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test with invalid utf8 sequences @@ -8084,247 +8084,247 @@ code = ''' [cases.test_paths_nonutf8] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "\xc0") => 0; + lfs3_mkdir(&lfs3, "\xc0") => 0; if (DIR) { - lfsr_mkdir(&lfs, "\xc0/\xa0") => 0; - lfsr_mkdir(&lfs, "\xc0/\xb0") => 0; - lfsr_mkdir(&lfs, "\xc0/\xc0") => 0; - lfsr_mkdir(&lfs, "\xc0/\xd0") => 0; - lfsr_mkdir(&lfs, "\xc0/\xe0") => 0; - lfsr_mkdir(&lfs, "\xc0/\xf0") => 0; + lfs3_mkdir(&lfs3, "\xc0/\xa0") => 0; + lfs3_mkdir(&lfs3, "\xc0/\xb0") => 0; + lfs3_mkdir(&lfs3, "\xc0/\xc0") => 0; + lfs3_mkdir(&lfs3, "\xc0/\xd0") => 0; + lfs3_mkdir(&lfs3, "\xc0/\xe0") => 0; + lfs3_mkdir(&lfs3, "\xc0/\xf0") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "\xc0/\xa0", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "\xc0/\xa0", &info) => 0; assert(strcmp(info.name, "\xa0") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xc0/\xb0", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xc0/\xb0", &info) => 0; assert(strcmp(info.name, "\xb0") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xc0/\xc0", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xc0/\xc0", &info) => 0; assert(strcmp(info.name, "\xc0") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xc0/\xd0", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xc0/\xd0", &info) => 0; assert(strcmp(info.name, "\xd0") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xc0/\xe0", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xc0/\xe0", &info) => 0; assert(strcmp(info.name, "\xe0") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xc0/\xf0", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xc0/\xf0", &info) => 0; assert(strcmp(info.name, "\xf0") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\xc0/\xa0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xb0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xc0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xd0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xe0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xc0/\xf0", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xa0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xb0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xc0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xd0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xe0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xc0/\xf0", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\xc0/\xa0") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xc0/\xb0") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xc0/\xc0") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xc0/\xd0") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xc0/\xe0") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xc0/\xf0") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xa0") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xb0") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xc0") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xd0") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xe0") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xf0") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\xc0/\xa0") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xc0/\xb0") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xc0/\xc0") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xc0/\xd0") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xc0/\xe0") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xc0/\xf0") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xa0") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xb0") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xc0") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xd0") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xe0") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xc0/\xf0") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "\xe0") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "\xe0") => 0; + lfs3_rename(&lfs3, "\xc0/\xa0", "\xe0/\xaf") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xc0/\xb0", "\xe0/\xbf") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xc0/\xc0", "\xe0/\xcf") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xc0/\xd0", "\xe0/\xdf") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xc0/\xe0", "\xe0/\xef") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xc0/\xf0", "\xe0/\xff") => 0; // stat paths - lfsr_stat(&lfs, "\xe0/\xaf", &info) => 0; + lfs3_stat(&lfs3, "\xe0/\xaf", &info) => 0; assert(strcmp(info.name, "\xaf") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xe0/\xbf", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xe0/\xbf", &info) => 0; assert(strcmp(info.name, "\xbf") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xe0/\xcf", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xe0/\xcf", &info) => 0; assert(strcmp(info.name, "\xcf") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xe0/\xdf", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xe0/\xdf", &info) => 0; assert(strcmp(info.name, "\xdf") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xe0/\xef", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xe0/\xef", &info) => 0; assert(strcmp(info.name, "\xef") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xe0/\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xe0/\xff", &info) => 0; assert(strcmp(info.name, "\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "\xc0/\xa0", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xc0/\xb0", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xc0/\xc0", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xc0/\xd0", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xc0/\xe0", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xc0/\xf0", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\xc0/\xa0", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xc0/\xb0", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xc0/\xc0", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xc0/\xd0", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xc0/\xe0", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xc0/\xf0", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "\xe0/\xaf") => 0; - lfsr_remove(&lfs, "\xe0/\xbf") => 0; - lfsr_remove(&lfs, "\xe0/\xcf") => 0; - lfsr_remove(&lfs, "\xe0/\xdf") => 0; - lfsr_remove(&lfs, "\xe0/\xef") => 0; - lfsr_remove(&lfs, "\xe0/\xff") => 0; + lfs3_remove(&lfs3, "\xe0/\xaf") => 0; + lfs3_remove(&lfs3, "\xe0/\xbf") => 0; + lfs3_remove(&lfs3, "\xe0/\xcf") => 0; + lfs3_remove(&lfs3, "\xe0/\xdf") => 0; + lfs3_remove(&lfs3, "\xe0/\xef") => 0; + lfs3_remove(&lfs3, "\xe0/\xff") => 0; // stat paths - lfsr_stat(&lfs, "\xe0/\xaf", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xe0/\xbf", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xe0/\xcf", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xe0/\xdf", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xe0/\xef", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xe0/\xff", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\xe0/\xaf", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xe0/\xbf", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xe0/\xcf", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xe0/\xdf", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xe0/\xef", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xe0/\xff", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test with only "\xff" characters @@ -8335,245 +8335,245 @@ code = ''' [cases.test_paths_oopsallffs] defines.DIR = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_F_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_F_RDWR, CFG) => 0; // create paths - lfsr_mkdir(&lfs, "\xff") => 0; + lfs3_mkdir(&lfs3, "\xff") => 0; if (DIR) { - lfsr_mkdir(&lfs, "\xff/\xff") => 0; - lfsr_mkdir(&lfs, "\xff/\xff\xff") => 0; - lfsr_mkdir(&lfs, "\xff/\xff\xff\xff") => 0; - lfsr_mkdir(&lfs, "\xff/\xff\xff\xff\xff") => 0; - lfsr_mkdir(&lfs, "\xff/\xff\xff\xff\xff\xff") => 0; - lfsr_mkdir(&lfs, "\xff/\xff\xff\xff\xff\xff\xff") => 0; + lfs3_mkdir(&lfs3, "\xff/\xff") => 0; + lfs3_mkdir(&lfs3, "\xff/\xff\xff") => 0; + lfs3_mkdir(&lfs3, "\xff/\xff\xff\xff") => 0; + lfs3_mkdir(&lfs3, "\xff/\xff\xff\xff\xff") => 0; + lfs3_mkdir(&lfs3, "\xff/\xff\xff\xff\xff\xff") => 0; + lfs3_mkdir(&lfs3, "\xff/\xff\xff\xff\xff\xff\xff") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // stat paths - struct lfs_info info; - lfsr_stat(&lfs, "\xff/\xff", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "\xff/\xff", &info) => 0; assert(strcmp(info.name, "\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff/\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff/\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff/\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff/\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff/\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff/\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff/\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff/\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff/\xff\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff/\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); // file open paths, only works on files! if (DIR) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => LFS3_ERR_ISDIR; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_RDONLY) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "\xff/\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; - lfsr_file_open(&lfs, &file, "\xff/\xff\xff\xff\xff\xff\xff", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; + lfs3_file_open(&lfs3, &file, "\xff/\xff\xff\xff\xff\xff\xff", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; } // dir open paths, only works on dirs! if (DIR) { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\xff/\xff") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff\xff") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff\xff\xff") => 0; - lfsr_dir_close(&lfs, &dir) => 0; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff\xff\xff\xff") => 0; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff\xff") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff\xff\xff") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff\xff\xff\xff") => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } else { - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "\xff/\xff") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff\xff") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff\xff\xff") => LFS_ERR_NOTDIR; - lfsr_dir_open(&lfs, &dir, "\xff/\xff\xff\xff\xff\xff\xff") => LFS_ERR_NOTDIR; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff\xff") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff\xff\xff") => LFS3_ERR_NOTDIR; + lfs3_dir_open(&lfs3, &dir, "\xff/\xff\xff\xff\xff\xff\xff") => LFS3_ERR_NOTDIR; } // rename paths - lfsr_mkdir(&lfs, "\xff\xff") => 0; - lfsr_rename(&lfs, + lfs3_mkdir(&lfs3, "\xff\xff") => 0; + lfs3_rename(&lfs3, "\xff/\xff", "\xff\xff/\xff\xff\xff\xff\xff\xff") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xff/\xff\xff", "\xff\xff/\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xff/\xff\xff\xff", "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xff/\xff\xff\xff\xff", "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xff/\xff\xff\xff\xff\xff", "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_rename(&lfs, + lfs3_rename(&lfs3, "\xff/\xff\xff\xff\xff\xff\xff", "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; // stat paths - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff", &info) => 0; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => 0; assert(strcmp(info.name, "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") == 0); - assert(info.type == ((DIR) ? LFS_TYPE_DIR : LFS_TYPE_REG)); + assert(info.type == ((DIR) ? LFS3_TYPE_DIR : LFS3_TYPE_REG)); - lfsr_stat(&lfs, "\xff/\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff/\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff/\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff/\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff/\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff/\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\xff/\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff/\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff/\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff/\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff/\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff/\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; // remove paths - lfsr_remove(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff") => 0; - lfsr_remove(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_remove(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_remove(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_remove(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; - lfsr_remove(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; + lfs3_remove(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff") => 0; + lfs3_remove(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff") => 0; + lfs3_remove(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff") => 0; + lfs3_remove(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; + lfs3_remove(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; + lfs3_remove(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") => 0; // stat paths - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "\xff\xff/\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", &info) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_powerloss.toml b/tests/test_powerloss.toml index dc37bc81..cbe89500 100644 --- a/tests/test_powerloss.toml +++ b/tests/test_powerloss.toml @@ -23,95 +23,95 @@ after = [ # [cases.test_powerloss_spam_dir_many] defines.POWERLOSS_BEHAVIOR = [ - 'LFS_EMUBD_POWERLOSS_ATOMIC', - 'LFS_EMUBD_POWERLOSS_SOMEBITS', - 'LFS_EMUBD_POWERLOSS_MOSTBITS', - 'LFS_EMUBD_POWERLOSS_OOO', + 'LFS3_EMUBD_POWERLOSS_ATOMIC', + 'LFS3_EMUBD_POWERLOSS_SOMEBITS', + 'LFS3_EMUBD_POWERLOSS_MOSTBITS', + 'LFS3_EMUBD_POWERLOSS_OOO', ] defines.MKCONSISTENT = [false, true] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # Create many files under powerloss @@ -121,10 +121,10 @@ code = ''' # [cases.test_powerloss_spam_file_many] defines.POWERLOSS_BEHAVIOR = [ - 'LFS_EMUBD_POWERLOSS_ATOMIC', - 'LFS_EMUBD_POWERLOSS_SOMEBITS', - 'LFS_EMUBD_POWERLOSS_MOSTBITS', - 'LFS_EMUBD_POWERLOSS_OOO', + 'LFS3_EMUBD_POWERLOSS_ATOMIC', + 'LFS3_EMUBD_POWERLOSS_SOMEBITS', + 'LFS3_EMUBD_POWERLOSS_MOSTBITS', + 'LFS3_EMUBD_POWERLOSS_OOO', ] defines.MKCONSISTENT = [false, true] # inlining has a tendency to hide sync issues, so try without @@ -143,72 +143,72 @@ if = '(SIZE*N)/BLOCK_SIZE <= 32' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); if (!err) { - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # A general purpose powerloss fuzz test @@ -221,10 +221,10 @@ code = ''' # [cases.test_powerloss_spam_f_pl_fuzz] defines.POWERLOSS_BEHAVIOR = [ - 'LFS_EMUBD_POWERLOSS_ATOMIC', - 'LFS_EMUBD_POWERLOSS_SOMEBITS', - 'LFS_EMUBD_POWERLOSS_MOSTBITS', - 'LFS_EMUBD_POWERLOSS_OOO', + 'LFS3_EMUBD_POWERLOSS_ATOMIC', + 'LFS3_EMUBD_POWERLOSS_SOMEBITS', + 'LFS3_EMUBD_POWERLOSS_MOSTBITS', + 'LFS3_EMUBD_POWERLOSS_OOO', ] defines.MKCONSISTENT = [false, true] # inlining has a tendency to hide sync issues, so try without @@ -246,68 +246,69 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDWR | LFS_O_CREAT) => 0; - lfs_ssize_t d = lfsr_file_read(&lfs, &state_file, &state, sizeof(state)); + lfs3_file_t state_file; + lfs3_file_open(&lfs3, &state_file, + "state", LFS3_O_RDWR | LFS3_O_CREAT) => 0; + lfs3_ssize_t d = lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)); assert(d == 0 || d == sizeof(state)); // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST); + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST); uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 0 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; uint32_t wprng = TEST_PRNG(&prng); // create a file here @@ -315,7 +316,7 @@ code = ''' sprintf(name, "test/amethyst%03x", x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -324,45 +325,45 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "test/%s", info.name); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % count; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t y = TEST_PRNG(&prng) % N; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this file char old_name[256]; @@ -370,75 +371,75 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // update our state file state.i = i; state.prng = prng; - lfsr_file_rewind(&lfs, &state_file) => 0; - lfsr_file_write(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_rewind(&lfs3, &state_file) => 0; + lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_sync(&lfs, &state_file) => 0; + lfs3_file_sync(&lfs3, &state_file) => 0; } // go ahead and close our state file in case we remount - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // at least try to read the files char name[256]; sprintf(name, "test/%s", info.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # A general purpose powerloss fuzz test, with directories! @@ -451,10 +452,10 @@ code = ''' # [cases.test_powerloss_spam_fd_pl_fuzz] defines.POWERLOSS_BEHAVIOR = [ - 'LFS_EMUBD_POWERLOSS_ATOMIC', - 'LFS_EMUBD_POWERLOSS_SOMEBITS', - 'LFS_EMUBD_POWERLOSS_MOSTBITS', - 'LFS_EMUBD_POWERLOSS_OOO', + 'LFS3_EMUBD_POWERLOSS_ATOMIC', + 'LFS3_EMUBD_POWERLOSS_SOMEBITS', + 'LFS3_EMUBD_POWERLOSS_MOSTBITS', + 'LFS3_EMUBD_POWERLOSS_OOO', ] defines.MKCONSISTENT = [false, true] # inlining has a tendency to hide sync issues, so try without @@ -478,111 +479,112 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDWR | LFS_O_CREAT) => 0; - lfs_ssize_t d = lfsr_file_read(&lfs, &state_file, &state, sizeof(state)); + lfs3_file_t state_file; + lfs3_file_open(&lfs3, &state_file, + "state", LFS3_O_RDWR | LFS3_O_CREAT) => 0; + lfs3_ssize_t d = lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)); assert(d == 0 || d == sizeof(state)); // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST); + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST); uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 6; // how many dirs do we have? - lfs_size_t dir_count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t dir_count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("quartz...")); assert(memcmp(info.name, "quartz", strlen("quartz")) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); dir_count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // dir op? if (op < 3 || dir_count == 0) { // creating a new dir? if (op == 0 || dir_count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // create a dir here char name[256]; sprintf(name, "test/quartz%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); // deleting a dir? } else if (op == 1) { // choose a random dir to delete - lfs_size_t j = TEST_PRNG(&prng) % dir_count; + lfs3_size_t j = TEST_PRNG(&prng) % dir_count; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // try to delete this dir, ignore non-empty dirs! char name[256]; assert(strlen(info.name) == strlen("quartz...")); sprintf(name, "test/%s", info.name); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOTEMPTY); + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOTEMPTY); // renaming a dir? } else { // choose a random dir to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % dir_count; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % dir_count; + lfs3_size_t y = TEST_PRNG(&prng) % N; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this dir, ignore conflicts! char old_name[256]; @@ -590,56 +592,56 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/quartz%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOTEMPTY); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOTEMPTY); } // file op? } else { // choose a pseudo-random dir - lfs_size_t dir_i = TEST_PRNG(&prng) % dir_count; + lfs3_size_t dir_i = TEST_PRNG(&prng) % dir_count; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= dir_i; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= dir_i; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; char dir_path[256]; sprintf(dir_path, "test/%s", info.name); // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp( info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 3 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % M; + lfs3_size_t x = TEST_PRNG(&prng) % M; uint32_t wprng = TEST_PRNG(&prng); // create a file here @@ -647,7 +649,7 @@ code = ''' sprintf(name, "%s/amethyst%03x", dir_path, x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -656,58 +658,58 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 4) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "%s/%s", dir_path, info.name); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // choose a random dir to rename to - lfs_size_t dir_j = TEST_PRNG(&prng) % dir_count; + lfs3_size_t dir_j = TEST_PRNG(&prng) % dir_count; // find the dir - struct lfs_info info_; - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info_) => 0; - lfsr_dir_read(&lfs, &dir, &info_) => 0; - for (lfs_size_t k = 0; k <= dir_j; k++) { - lfsr_dir_read(&lfs, &dir, &info_) => 0; + struct lfs3_info info_; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info_) => 0; + lfs3_dir_read(&lfs3, &dir, &info_) => 0; + for (lfs3_size_t k = 0; k <= dir_j; k++) { + lfs3_dir_read(&lfs3, &dir, &info_) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // choose a random file to rename to - lfs_size_t y = TEST_PRNG(&prng) % M; + lfs3_size_t y = TEST_PRNG(&prng) % M; // rename this file char old_name[256]; @@ -715,104 +717,104 @@ code = ''' sprintf(old_name, "%s/%s", dir_path, info.name); char new_name[256]; sprintf(new_name, "test/%s/amethyst%03x", info_.name, y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } // update our state file state.i = i; state.prng = prng; - lfsr_file_rewind(&lfs, &state_file) => 0; - lfsr_file_write(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_rewind(&lfs3, &state_file) => 0; + lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_sync(&lfs, &state_file) => 0; + lfs3_file_sync(&lfs3, &state_file) => 0; } // go ahead and close our state file in case we remount - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("quartz...")); assert(memcmp(info.name, "quartz", strlen("quartz")) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // check that our dirs look more-or-less ok char name[256]; sprintf(name, "test/%s", info.name); - lfsr_dir_t dir_; - lfsr_dir_open(&lfs, &dir_, name) => 0; - struct lfs_info info_; - lfsr_dir_read(&lfs, &dir_, &info_) => 0; + lfs3_dir_t dir_; + lfs3_dir_open(&lfs3, &dir_, name) => 0; + struct lfs3_info info_; + lfs3_dir_read(&lfs3, &dir_, &info_) => 0; assert(strcmp(info_.name, ".") == 0); - assert(info_.type == LFS_TYPE_DIR); + assert(info_.type == LFS3_TYPE_DIR); assert(info_.size == 0); - lfsr_dir_read(&lfs, &dir_, &info_) => 0; + lfs3_dir_read(&lfs3, &dir_, &info_) => 0; assert(strcmp(info_.name, "..") == 0); - assert(info_.type == LFS_TYPE_DIR); + assert(info_.type == LFS3_TYPE_DIR); assert(info_.size == 0); while (true) { - err = lfsr_dir_read(&lfs, &dir_, &info_); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + err = lfs3_dir_read(&lfs3, &dir_, &info_); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info_.name) == strlen("amethyst...")); assert(memcmp( info_.name, "amethyst", strlen("amethyst")) == 0); - assert(info_.type == LFS_TYPE_REG); + assert(info_.type == LFS3_TYPE_REG); assert(info_.size == SIZE); // at least try to read the files sprintf(name, "test/%s/%s", info.name, info_.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir_) => 0; + lfs3_dir_close(&lfs3, &dir_) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 682197bb..ec17990b 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -14,703 +14,703 @@ defines.ERASE_VALUE = [0xff, 0x00, -1] defines.BLOCK_SIZE = 32768 [cases.test_rbyd_atomic_commit] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; ''' [cases.test_rbyd_commit] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; ''' [cases.test_rbyd_commit_fetch_commit] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; // fetch - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // commit with the second attribute - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; ''' [cases.test_rbyd_atomic_lookup] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_lookup] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_atomic_get] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + NULL, &data) => LFS3_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_get] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // commit with one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + NULL, &data) => LFS3_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_bifoliate] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // create a split in the leaves // .-'| // 1 1 2 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split the other direction // >b // => .-'| // 2 2 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_bflips] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // ignore a black edge // .----'| // 1 2 1 2 2 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // flip a black edge // b // .-'| => .-'| // 1 2 1 2 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_trifoliate] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // ignore a black edge // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // flip a black edge // >r @@ -755,53 +755,53 @@ code = ''' // .-'| .--|-'| // 2 3 2 3 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_rflips] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // ignore a red edge and black edge // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // ignore a red edge, flip a black edge // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // flip a red edge and black edge // r @@ -888,37 +888,37 @@ code = ''' // | .-'| .--|-'| // 1 2 3 1 2 3 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // flip a red edge, ignore a black edge // r @@ -927,56 +927,56 @@ code = ''' // .--|-'| | .-'| // 3 1 2 3 1 2 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_quadrifoliate] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // ignore a red edge and black edge // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // ignore a red edge, flip a black edge // y @@ -1033,42 +1033,42 @@ code = ''' // | .-'| | .--|-'| .--|--|-'| // 1 3 4 1 3 4 2 1 3 4 2 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // flip a red edge and black edge // >y @@ -1079,42 +1079,42 @@ code = ''' // | .-'| .--|--|-'| // 2 3 4 2 3 4 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // flip a red edge, ignore a black edge // >y @@ -1125,61 +1125,61 @@ code = ''' // .--|-'| | .--|-'| // 4 2 3 4 2 3 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_rotations] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // all three the same // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // yellow and red alt the same // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // yellow and black alt the same // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // red and black alt the same // >y 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_ysplits] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // split a yellow triple, not taking any alt // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split a yellow triple, taking the black alt // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split a yellow triple, taking the red alt // b @@ -1495,45 +1495,45 @@ code = ''' // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 2 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split a yellow triple, taking the yellow alt // b @@ -1544,64 +1544,64 @@ code = ''' // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_quintifoliate] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // split a yellow triple, not taking any alt // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split a yellow triple, taking the black alt // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split a yellow triple, taking the red alt // >b @@ -1730,50 +1730,50 @@ code = ''' // | | .-'| | | .-'| | // 1 3 4 5 1 3 4 5 2 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // split a yellow triple, taking the yellow alt // >b @@ -1786,69 +1786,69 @@ code = ''' // | | .-'| | | .-'| | // 2 3 4 5 2 3 4 5 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_prunes] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // don't prune // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // prune by taking a red alt // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // prune by taking a yellow alt (this needs to prune during the rflip) // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_sextifoliate] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // don't prune // 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xff\xff\xff\xff", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(6), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(6), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(6)); + assert(tag_ == LFS3_TAG_ATTR(6)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // prune by taking a red alt // b @@ -2133,58 +2133,58 @@ code = ''' // | | | .-'| | | | .-'| | // 1 3 4 5 6 1 3 4 5 6 2 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xff\xff\xff\xff", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(6), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(6), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(6)); + assert(tag_ == LFS3_TAG_ATTR(6)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // prune by taking a yellow alt (this needs to prune during the rflip) // b @@ -2199,58 +2199,58 @@ code = ''' // | | | .-'| | | | .-'| | // 2 3 4 5 6 2 3 4 5 6 1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xff\xff\xff\xff", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(5)); + assert(tag_ == LFS3_TAG_ATTR(5)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(6), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(6), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(6)); + assert(tag_ == LFS3_TAG_ATTR(6)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_atomic_permutations] @@ -2258,25 +2258,25 @@ defines.N = 'range(1, 8)' # PERMUTATION=-1 => exhaust all permutations # PERMUTATION=n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -2299,46 +2299,46 @@ code = ''' printf("] ---\n"); // build the attribute list for the current permutation - struct lfsr_rattr rattrs[N]; + struct lfs3_rattr rattrs[N]; for (unsigned j = 0; j < N; j++) { - rattrs[j] = LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + rattrs[j] = LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa", 4); } // test the given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, rattrs, N) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, rattrs, N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N; + lfs3_size_t n = 1 + N; printf("--- summary --\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -2349,25 +2349,25 @@ defines.N = 'range(1, 8)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -2391,239 +2391,239 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N; + lfs3_size_t n = 1 + N; printf("--- summary --\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' [cases.test_rbyd_atomic_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // also try the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // also try the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_atomic_traverse_permutations] @@ -2631,22 +2631,22 @@ defines.N = 'range(1, 8)' # PERMUTATION=-1 => exhaust all permutations # PERMUTATION=n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2668,31 +2668,31 @@ code = ''' printf("] ---\n"); // build the attribute list for the current permutation - struct lfsr_rattr rattrs[N]; + struct lfs3_rattr rattrs[N]; for (unsigned j = 0; j < N; j++) { - rattrs[j] = LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + rattrs[j] = LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa", 4); } // test the given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, rattrs, N) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, rattrs, N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags tag_ = 0; rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } ''' @@ -2703,22 +2703,22 @@ defines.N = 'range(1, 8)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2742,27 +2742,27 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags tag_ = 0; rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } ''' @@ -2775,43 +2775,43 @@ defines.N = 'range(1, 8)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // create one consistent block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(j+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(j+1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2834,34 +2834,34 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // update each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; } // check that all tags have been updated - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -2871,62 +2871,62 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N; + lfs3_size_t n = 1 + N + N; printf("--- summary --\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' [cases.test_rbyd_large] -in = 'lfs.c' +in = 'lfs3.c' # ORDER: # 0 = in-order # 1 = reverse-order # 2 = random-order defines.ORDER = [0, 1, 2] code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // create the rbyd tree rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; // keep appending tags until we run out of space // // note, this will likely repeat tags, but that's ok // - lfs_size_t count = 0; + lfs3_size_t count = 0; uint32_t prng = 42; - for (lfs_size_t i = 0;; i++) { - lfs_size_t x + for (lfs3_size_t i = 0;; i++) { + lfs3_size_t x = (ORDER == 0) ? i - : (ORDER == 1) ? (((lfs_size_t)-1) - i) + : (ORDER == 1) ? (((lfs3_size_t)-1) - i) : TEST_PRNG(&prng); - int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(x & 0x7f), 0, + int err = lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(x & 0x7f), 0, "\xaa\xaa\xaa\xaa", 4))); - if (err == LFS_ERR_RANGE) { + if (err == LFS3_ERR_RANGE) { break; } assert(err == 0); @@ -2936,17 +2936,17 @@ code = ''' // check that we can still lookup all the tags prng = 42; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - for (lfs_size_t i = 0; i < count; i++) { - lfs_size_t x + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + for (lfs3_size_t i = 0; i < count; i++) { + lfs3_size_t x = (ORDER == 0) ? i - : (ORDER == 1) ? (((lfs_size_t)-1) - i) + : (ORDER == 1) ? (((lfs3_size_t)-1) - i) : TEST_PRNG(&prng); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(x & 0x7f), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(x & 0x7f), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(x & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR(x & 0x7f)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } ''' @@ -2954,120 +2954,120 @@ code = ''' ### Removal testing ### [cases.test_rbyd_remove] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // add and remove one attribute rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes, remove the first one rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes, remove the second one rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(2), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -3079,25 +3079,25 @@ defines.N = 'range(1, 7)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -3121,19 +3121,19 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -3141,65 +3141,65 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(j+1), 0))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { - int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, - -1, LFSR_TAG_ATTR(k+1), + int err = lfs3_rbyd_lookupnext(&lfs3, &rbyd, + -1, LFS3_TAG_ATTR(k+1), &rid_, &tag_, NULL, &data_); - assert(!err || err == LFS_ERR_NOENT); + assert(!err || err == LFS3_ERR_NOENT); if (k == j) { if (j == N-1) { - assert(err == LFS_ERR_NOENT); + assert(err == LFS3_ERR_NOENT); } else { assert(err == 0); - assert(tag_ == LFSR_TAG_ATTR(j+1+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } } else { - assert(tag_ == LFSR_TAG_ATTR(k+1)); + assert(tag_ == LFS3_TAG_ATTR(k+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } } // try appending the tag back to make sure things still work printf("--- append: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(j+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(j+1), 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - -1, LFSR_TAG_ATTR(k+1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + -1, LFS3_TAG_ATTR(k+1), &rid_, &tag_, NULL, &data_) => 0; if (k == j) { - assert(tag_ == LFSR_TAG_ATTR(k+1)); + assert(tag_ == LFS3_TAG_ATTR(k+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); } else { - assert(tag_ == LFSR_TAG_ATTR(k+1)); + assert(tag_ == LFS3_TAG_ATTR(k+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -3210,16 +3210,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + 2; + lfs3_size_t n = 1 + N + 2; printf("--- summary --\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -3232,22 +3232,22 @@ defines.N = 'range(1, 7)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -3270,19 +3270,19 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -3290,38 +3290,38 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(j+1), 0))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; tag_ = 0; rid_ = -1; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; if (k >= j) { - assert(tag_ == LFSR_TAG_ATTR(k+1+1)); + assert(tag_ == LFS3_TAG_ATTR(k+1+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else { - assert(tag_ == LFSR_TAG_ATTR(k+1)); + assert(tag_ == LFS3_TAG_ATTR(k+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } // cleanup @@ -3330,508 +3330,508 @@ code = ''' ''' [cases.test_rbyd_remove_missing] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // create a tree two attributes rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(3), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(5), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // one last fetch to make sure nothing was broken - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_remove_again] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // create a tree rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee\xee\xee", 4))) => 0; // remove several attributes - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(3), 0), + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(5), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(3), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(5), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(3), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(5), 0))) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // one last fetch to make sure nothing was broken - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(4), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(4), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(4)); + assert(tag_ == LFS3_TAG_ATTR(4)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(5), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_remove_all] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // commit with one attribute, remove it rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes, remove both rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(2), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // commit with two attributes, remove both in the other order rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(2), 0), + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -3843,43 +3843,43 @@ defines.N = 'range(1, 7)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // create one consistent block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(j+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(j+1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -3902,47 +3902,47 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]+1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(perm[j]+1), 0))) => 0; } // check that all tags are now removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); for (unsigned j = 1; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -3952,16 +3952,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N + 1; + lfs3_size_t n = 1 + N + N + 1; printf("--- summary --\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -3973,20 +3973,20 @@ defines.SEED = 'range(1000)' fuzz = 'SEED' # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; printf("perm: ["); @@ -4012,7 +4012,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; prng = SEED; for (unsigned i = 0; i < N; i++) { @@ -4023,17 +4023,17 @@ code = ''' // update our sim sim[rattr] = 'a'+(i % 26); // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(rattr), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(rattr), 0, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else { // update our sim sim[rattr] = '\0'; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(rattr), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(rattr), 0))) => 0; } } @@ -4053,10 +4053,10 @@ code = ''' printf("rbyd: ["); first = true; for (unsigned rattr = 0; rattr < N; rattr++) { - int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr), + int err = lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(rattr), NULL, &data); if (!err) { - lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); + lfs3_ssize_t size = lfs3_data_read(&lfs3, &data, buffer, 4); if (!first) { printf(", "); } @@ -4067,15 +4067,15 @@ code = ''' printf("]\n"); for (unsigned rattr = 0; rattr < N; rattr++) { - int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr), + int err = lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(rattr), NULL, &data); if (sim[rattr]) { assert(err == 0); - lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); + lfs3_ssize_t size = lfs3_data_read(&lfs3, &data, buffer, 4); assert(size == 1); assert(memcmp(&sim[rattr], buffer, 1) == 0); } else { - assert(err == LFS_ERR_NOENT); + assert(err == LFS3_ERR_NOENT); } } @@ -4087,316 +4087,316 @@ code = ''' ### Insertion testing ### [cases.test_rbyd_atomic_create] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // try to create one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); // try to create two ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // create a third to the right rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' [cases.test_rbyd_create] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // try to create one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); // try to create two ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // try to create two in the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // create a third to the right rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third to the left rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third in the middle rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' @@ -4407,19 +4407,19 @@ defines.N = 'range(1, 8)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -4428,11 +4428,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -4456,7 +4456,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -4466,238 +4466,238 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N; + lfs3_size_t n = 1 + N; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' [cases.test_rbyd_atomic_create_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 00000000, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_create_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // also try the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_create_traverse_permutations] @@ -4707,19 +4707,19 @@ defines.N = 'range(1, 8)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -4728,10 +4728,10 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -4755,7 +4755,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -4765,52 +4765,52 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); // try traversing all tags tag_ = 0; rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } ''' [cases.test_rbyd_create_large] -in = 'lfs.c' +in = 'lfs3.c' # ORDER: # 0 = in-order # 1 = reverse-order # 2 = random-order defines.ORDER = [0, 1, 2] code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -4822,7 +4822,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; // keep inserting tags until we run out of space // @@ -4831,16 +4831,16 @@ code = ''' // insertions // uint32_t prng = 42; - for (lfs_size_t i = 0;; i++) { + for (lfs3_size_t i = 0;; i++) { uint16_t x = (ORDER == 0) ? (uint16_t)i - : (ORDER == 1) ? (uint16_t)(((lfs_size_t)-1) - i) + : (ORDER == 1) ? (uint16_t)(((lfs3_size_t)-1) - i) : (uint16_t)TEST_PRNG(&prng); x = x % (rbyd.weight+1); - int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_RATTRS( - LFSR_RATTR_BUF(LFSR_TAG_DATA, +1, names[x % 6], 4))); - if (err == LFS_ERR_RANGE) { + int err = lfs3_rbyd_commit(&lfs3, &rbyd, x, LFS3_RATTRS( + LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, names[x % 6], 4))); + if (err == LFS3_ERR_RANGE) { break; } assert(err == 0); @@ -4849,16 +4849,16 @@ code = ''' // check that we can at least lookup all the tags // // note with random order we can't check that stored values reliably - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, x, LFS3_TAG_DATA, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == x); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } ''' @@ -4866,556 +4866,556 @@ code = ''' ### Mixed create and rattr testing ### [cases.test_rbyd_atomic_mixed] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // try to create one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); // try to create two ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); // create a third to the right rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); ''' [cases.test_rbyd_mixed] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // try to create one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); // try to create two ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); // try to create two in the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); // create a third to the right rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); // create a third to the left rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); // create a third in the middle rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); ''' @@ -5427,19 +5427,19 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -5448,11 +5448,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -5476,7 +5476,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5486,370 +5486,370 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N*M; + lfs3_size_t n = 1 + N + N*M; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' [cases.test_rbyd_atomic_mixed_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_mixed_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // also try the other direction rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 1); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_mixed_traverse_permutations] @@ -5860,19 +5860,19 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -5881,10 +5881,10 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -5908,7 +5908,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5918,50 +5918,50 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); // try traversing all tags tag_ = 0; rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == j); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } ''' @@ -5975,12 +5975,12 @@ defines.M = 'range(1, 3)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, @@ -5995,37 +5995,37 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // create one consistent block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[j % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[j % 6], 2))) => 0; } } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N*M); @@ -6048,39 +6048,39 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // update each tag in permutation order for (unsigned j = 0; j < N*M; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]%M+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, perm[j]/M, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]%M+1), 0, names[(perm[j]/M) % 6], 3))) => 0; } // check that all tags have been updated - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 3; + lfs3_data_read(&lfs3, &data, buffer, 4) => 3; assert(memcmp(buffer, names[j % 6], 3) == 0); } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -6090,16 +6090,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N*M + N*M; + lfs3_size_t n = 1 + N + N*M + N*M; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -6113,12 +6113,12 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, @@ -6133,15 +6133,15 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -6165,7 +6165,7 @@ code = ''' // create given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6175,24 +6175,24 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N*M; j++) { @@ -6200,51 +6200,51 @@ code = ''' printf("--- remove: rid%jd, %jd ---\n", j/M, (j%M)+1); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR((j%M)+1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j/M, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR((j%M)+1), 0))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, - k, LFSR_TAG_ATTR(u+1), + int err = lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k, LFS3_TAG_ATTR(u+1), &rid_, &tag_, NULL, &data_); - assert(!err || err == LFS_ERR_NOENT); + assert(!err || err == LFS3_ERR_NOENT); if (k == j/M && u == j%M) { if (u == M-1 && k == N-1) { - assert(err == LFS_ERR_NOENT); + assert(err == LFS3_ERR_NOENT); } else if (u == M-1) { assert(err == 0); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k+1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else { assert(err == 0); - assert(tag_ == LFSR_TAG_ATTR(u+1+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1+1)); assert(rid_ == k); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } else { - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == k); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } } @@ -6252,47 +6252,47 @@ code = ''' // try append the tag back to make sure things still work printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1); - lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((j%M)+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j/M, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((j%M)+1), 0, names[(j/M)%6], 3))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k, LFS3_TAG_ATTR(u+1), &rid_, &tag_, NULL, &data_) => 0; if (k == j/M && u == j%M) { - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == k); - assert(lfsr_data_size(data_) == 3); + assert(lfs3_data_size(data_) == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 3; + lfs3_data_read(&lfs3, &data, buffer, 4) => 3; assert(memcmp(buffer, names[k % 6], 3) == 0); } else { - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == k); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -6303,16 +6303,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N+N*M + 2; + lfs3_size_t n = 1 + N+N*M + 2; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -6326,12 +6326,12 @@ defines.M = 'range(1, 3)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, @@ -6346,37 +6346,37 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // create one consistent block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[j % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[j % 6], 2))) => 0; } } // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N*M); @@ -6399,36 +6399,36 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // remove each tag in permutation order for (unsigned j = 0; j < N*M; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]%M+1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, perm[j]/M, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(perm[j]%M+1), 0))) => 0; } // check that all tags have been removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_ATTR(u+1), + NULL, &data) => LFS3_ERR_NOENT; } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -6438,21 +6438,21 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N*M + N*M; + lfs3_size_t n = 1 + N + N*M + N*M; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' [cases.test_rbyd_mixed_large] -in = 'lfs.c' +in = 'lfs3.c' # ORDER: # 0 = in-order # 1 = reverse-order @@ -6460,17 +6460,17 @@ in = 'lfs.c' defines.ORDER = [0, 1, 2] defines.M = 'range(1, 4)' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -6482,7 +6482,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; // keep inserting tags until we run out of space // @@ -6491,27 +6491,27 @@ code = ''' // insertions // uint32_t prng = 42; - for (lfs_size_t i = 0;; i++) { + for (lfs3_size_t i = 0;; i++) { uint16_t x = (ORDER == 0) ? (uint16_t)i - : (ORDER == 1) ? (uint16_t)(((lfs_size_t)-1) - i) + : (ORDER == 1) ? (uint16_t)(((lfs3_size_t)-1) - i) : (uint16_t)TEST_PRNG(&prng); x = x % (rbyd.weight+1); // build a single attribute list with all ratibutes, if this fails // it should fail atomically - struct lfsr_rattr rattrs[1+M]; - rattrs[0] = LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + struct lfs3_rattr rattrs[1+M]; + rattrs[0] = LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[x % 6], 4); for (unsigned u = 0; u < M; u++) { - rattrs[1+u] = LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + rattrs[1+u] = LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[x % 6], 2); } - int err = lfsr_rbyd_commit(&lfs, &rbyd, x, rattrs, 1+M); - if (err == LFS_ERR_RANGE) { + int err = lfs3_rbyd_commit(&lfs3, &rbyd, x, rattrs, 1+M); + if (err == LFS3_ERR_RANGE) { break; } assert(err == 0); @@ -6520,23 +6520,23 @@ code = ''' // check that we can at least lookup all the tags // // note with random order we can't check that stored values reliably - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, x, LFS3_TAG_DATA, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == x); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, x, LFS3_TAG_ATTR(u+1), &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == x); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } ''' @@ -6551,19 +6551,19 @@ defines.N = 'range(1, 8)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -6572,11 +6572,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -6600,7 +6600,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6611,80 +6611,80 @@ code = ''' } // note the data size differences here - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, names[perm[j] % 6], 1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; } // try looking up each tag - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } // try traversing tags - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfsr_data_t data_; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_data_t data_; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 1); + assert(lfs3_data_size(data_) == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N; + lfs3_size_t n = 1 + N; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -6696,19 +6696,19 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -6717,11 +6717,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[4]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -6745,7 +6745,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6756,105 +6756,105 @@ code = ''' } // note the data size differences here - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(perm[j]+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(perm[j]+1), 0, names[perm[j] % 6], 1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } // try looking up each tag - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(j+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } // try traversing tags - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfsr_data_t data_; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_data_t data_; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(j+1)); + assert(tag_ == LFS3_TAG_ATTR(j+1)); assert(rid_ == -1); - assert(lfsr_data_size(data_) == 1); + assert(lfs3_data_size(data_) == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == j); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N*M; + lfs3_size_t n = 1 + N + N*M; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -6862,492 +6862,492 @@ code = ''' ### Deletion testing ### [cases.test_rbyd_delete] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // try to delete one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // try to delete the other rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // try to delete the largest of three rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // try to delete the smallest of three rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // try to delete the middle rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // try to delete one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to delete the other rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to delete the largest of three rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to delete the smallest of three rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to delete the middle rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' # some additional delete range special cases [cases.test_rbyd_delete_range_b] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -7361,292 +7361,292 @@ code = ''' // remove // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_r] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -7659,262 +7659,262 @@ code = ''' // remove // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_y] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -7927,362 +7927,362 @@ code = ''' // remove // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_rydy] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -8298,338 +8298,338 @@ code = ''' // violated if you preserve coloring during range removes // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(9), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(9), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(9), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(9), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(9), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(9), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_rydy_backwards] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -8645,338 +8645,338 @@ code = ''' // violated if you preserve coloring during range removes // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(9), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(9), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xaa\xaa", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_rydye] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -8992,315 +8992,315 @@ code = ''' // violated if you preserve coloring during range removes // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_rydye_backwards] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -9316,315 +9316,315 @@ code = ''' // violated if you preserve coloring during range removes // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), +1, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xcc\xcc\xcc\xcc", 4), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_dryy] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -9642,440 +9642,440 @@ code = ''' // but no violations have been found to be possible yet // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), +1, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(11), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(11), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(12), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(12), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xcc\xcc\xcc\xcc", 4), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(13), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(13), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(14), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(14), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(9), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(9), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(10), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(10), 0, "\xaa\xaa", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(10), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(10), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_range_dryy_backwards] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; // delete inner branches @@ -10093,421 +10093,421 @@ code = ''' // but no violations have been found to be possible yet // rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xcc\xcc", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(6), +1, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(6), +1, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(7), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(7), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(8), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(8), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(9), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(9), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(10), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(10), 0, "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(10), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(10), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(10), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(10), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(10), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(10), 0, "\xee\xee", 2))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(11), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(11), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(12), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(12), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(13), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(13), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(14), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(14), 0, "\xee\xee", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(14), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(14), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(14), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(14), 0, "\xee\xee", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "\xee\xee", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, 0, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(5), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(5), 0, "\xee\xee", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2), // propagate yellow - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(4), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(4), 0, "\xee\xee", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(3), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(3), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(4), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(4), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(5), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(5), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(6), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(6), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(7), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(7), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(8), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(8), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(9), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(9), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(10), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(10), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(11), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(11), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(12), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(12), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(13), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(13), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_ATTR(14), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(14), NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 3, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 3, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -10519,19 +10519,19 @@ defines.N = 'range(1, 7)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -10540,11 +10540,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[6]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -10568,7 +10568,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -10579,18 +10579,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each delete - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -10598,59 +10598,59 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == N-1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { assert(memcmp(buffer, names[k % 6], 4) == 0); } } - lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, N-1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[j % 6], 6))) => 0; assert(rbyd.weight == N); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -10661,16 +10661,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + 2; + lfs3_size_t n = 1 + N + 2; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -10684,19 +10684,19 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -10705,11 +10705,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[6]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // test all permutations of a given size @@ -10733,7 +10733,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -10744,25 +10744,25 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } assert(rbyd.weight == N); // copy block so we can reset after each delete - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -10770,23 +10770,23 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == N-1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -10794,9 +10794,9 @@ code = ''' } for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 2) == 0); } else { @@ -10804,58 +10804,58 @@ code = ''' } } } - lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, N-1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, N-1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, N-1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[j % 6], 6))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[j % 6], 3))) => 0; } assert(rbyd.weight == N); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 3; + lfs3_data_read(&lfs3, &data, buffer, 6) => 3; assert(memcmp(buffer, names[k % 6], 3) == 0); } } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, k, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 2; + lfs3_data_read(&lfs3, &data, buffer, 6) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } } } // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -10866,16 +10866,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N+N*M + 1 + 1+M; + lfs3_size_t n = 1 + N+N*M + 1 + 1+M; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -10888,19 +10888,19 @@ defines.N = 'range(1, 7)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -10909,10 +10909,10 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -10936,7 +10936,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -10947,18 +10947,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each delete - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -10966,32 +10966,32 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); tag_ = 0; rid_ = -1; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -10999,8 +10999,8 @@ code = ''' } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } // cleanup @@ -11018,19 +11018,19 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -11039,10 +11039,10 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -11066,7 +11066,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -11077,25 +11077,25 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } assert(rbyd.weight == N); // copy block so we can reset after each delete - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -11103,32 +11103,32 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); tag_ = 0; rid_ = -1; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -11136,14 +11136,15 @@ code = ''' } for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(u+1)); + assert(tag_ == LFS3_TAG_ATTR(u+1)); assert(rid_ == k); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 2; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 2; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 2) == 0); } else { @@ -11152,8 +11153,8 @@ code = ''' } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS3_ERR_NOENT; } // cleanup @@ -11164,315 +11165,315 @@ code = ''' # Note, "delete_all" is a weird state for rbyd trees to be in, since they # don't really have a trunk at this point [cases.test_rbyd_delete_all] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; // create and delete one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete two ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1), - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1), + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete two ids in the other order rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete three ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1), - LFSR_RATTR(LFSR_TAG_RM, -1), - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1), + LFS3_RATTR(LFS3_TAG_RM, -1), + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete three ids in the other order rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_delete_all_range] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; // create and delete one rid rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete two ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1), - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1), + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete two ids in the other order rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete three ids rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1), - LFSR_RATTR(LFSR_TAG_RM, -1), - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1), + LFS3_RATTR(LFS3_TAG_RM, -1), + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // create and delete three ids in the other order rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -11484,19 +11485,19 @@ defines.N = 'range(1, 7)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -11505,30 +11506,30 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[6]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // create one consistent block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[j % 6], 4))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each delete - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -11551,11 +11552,11 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // delete each rid in permutation order @@ -11568,36 +11569,36 @@ code = ''' } } - lfs_size_t rbyd_weight_before = rbyd.weight; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_size_t rbyd_weight_before = rbyd.weight; + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } // check that all tags are now removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_DATA, 0, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, LFS3_TAG_DATA, 0, + NULL, &data) => LFS3_ERR_NOENT; // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -11607,16 +11608,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + 2*N + 1; + lfs3_size_t n = 1 + 2*N + 1; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -11630,19 +11631,19 @@ defines.M = 'range(1, 4)' defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -11651,37 +11652,37 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_data_t data; + lfs3_data_t data; uint8_t buffer[6]; // keep track of the worst case log size - lfs_size_t worst_size = 0; + lfs3_size_t worst_size = 0; size_t worst_perm_i = 0; // create one consistent block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[j % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, names[j % 6], 2))) => 0; } } assert(rbyd.weight == N); // copy block so we can reset after each delete - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -11704,11 +11705,11 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // delete each rid in permutation order @@ -11721,50 +11722,50 @@ code = ''' } } - lfs_size_t rbyd_weight_before = rbyd.weight; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_size_t rbyd_weight_before = rbyd.weight; + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } // check that all tags are now removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u+1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u+1), 0, "\xaa\xaa\xaa", 3))) => 0; } assert(rbyd.weight == 1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(u+1), + lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(u+1), NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 3; + lfs3_data_read(&lfs3, &data, buffer, 6) => 3; assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0); } - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, - NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_DATA, + NULL, &data) => LFS3_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, 1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; // keep track of the worst size - if (lfsr_rbyd_eoff(&rbyd) > worst_size) { - worst_size = lfsr_rbyd_eoff(&rbyd); + if (lfs3_rbyd_eoff(&rbyd) > worst_size) { + worst_size = lfs3_rbyd_eoff(&rbyd); worst_perm_i = perm_i; } } @@ -11774,16 +11775,16 @@ code = ''' // test that tree is self-balancing, we should be strictly bounded // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N+N*M + N + 1+M; + lfs3_size_t n = 1 + N+N*M + N + 1+M; printf("--- summary ---\n"); printf("worst permutation: %zd\n", worst_perm_i); printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); + worst_size, n, 12*n*(2*lfs3_nlog2(n)+1)+4); printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); + worst_size / n, n, 12*(2*lfs3_nlog2(n)+1)+4); // note this only holds true with byte-level progs if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); + assert(worst_size / n <= 12*(2*lfs3_nlog2(n)+1)+4); } ''' @@ -11795,30 +11796,30 @@ defines.SEED = 'range(1000)' fuzz = 'SEED' # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; printf("perm: ["); uint32_t prng = SEED; - lfs_size_t count = 0; + lfs3_size_t count = 0; for (unsigned i = 0; i < N; i++) { // choose an rid - lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); + lfs3_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose create or delete - if (rid == (lfs_ssize_t)count || (TEST_PRNG(&prng) & 1)) { + if (rid == (lfs3_ssize_t)count || (TEST_PRNG(&prng) & 1)) { printf("c%d=%c", rid, 'a'+(i % 26)); count += 1; } else { @@ -11838,63 +11839,63 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; prng = SEED; count = 0; for (unsigned i = 0; i < N; i++) { // choose an rid - lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); + lfs3_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose create or delete - if (rid == (lfs_ssize_t)count || (TEST_PRNG(&prng) & 1)) { + if (rid == (lfs3_ssize_t)count || (TEST_PRNG(&prng) & 1)) { // update our sim memmove(sim+rid+1, sim+rid, count-rid); sim[rid] = 'a'+(i % 26); count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else { // update our sim memmove(sim+rid, sim+rid+1, count-rid-1); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; } } // compare rbyd vs simulation printf("expd: ["); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { printf("%c", sim[rid]); - if (rid < (lfs_ssize_t)count-1) { + if (rid < (lfs3_ssize_t)count-1) { printf(", "); } } printf("]\n"); printf("rbyd: ["); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) { - int err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)rbyd.weight; rid++) { + int err = lfs3_rbyd_lookup(&lfs3, &rbyd, rid, LFS3_TAG_DATA, NULL, &data); if (!err) { - lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); + lfs3_ssize_t size = lfs3_data_read(&lfs3, &data, buffer, 4); printf("%.*s", size, buffer); } else { printf("?"); } - if (rid < (lfs_ssize_t)count-1) { + if (rid < (lfs3_ssize_t)count-1) { printf(", "); } } printf("]\n"); assert(count == rbyd.weight); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { - lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { + lfs3_rbyd_lookup(&lfs3, &rbyd, rid, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(&sim[rid], buffer, 1) == 0); } @@ -11905,362 +11906,362 @@ code = ''' # Test rbyd weights [cases.test_rbyd_sparse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; // make id0 with weight w1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // make id2 with weight w2 - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +2, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +2, "\xbb\xbb\xbb\xbb", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // make id5 with weight w3 - lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +3, + lfs3_rbyd_commit(&lfs3, &rbyd, 3, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +3, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // make id9 with weight w4 - lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +4, + lfs3_rbyd_commit(&lfs3, &rbyd, 6, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +4, "\xdd\xdd\xdd\xdd", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); // make id14 with weight w5 - lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +5, + lfs3_rbyd_commit(&lfs3, &rbyd, 10, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +5, "\xee\xee\xee\xee", 4))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); ''' [cases.test_rbyd_sparse_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( // make id0 with weight w1 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), // make id2 with weight w2 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +2, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +2, "\xbb\xbb\xbb\xbb", 4), // make id5 with weight w3 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +3, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +3, "\xcc\xcc\xcc\xcc", 4), // make id9 with weight w4 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +4, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +4, "\xdd\xdd\xdd\xdd", 4), // make id14 with weight w5 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +5, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +5, "\xee\xee\xee\xee", 4))) => 0; // traverse, finding tags and weights - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_sparse_permutations] @@ -12271,19 +12272,19 @@ defines.W = 5 defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -12292,11 +12293,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -12320,7 +12321,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12330,25 +12331,25 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, j*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, j*W+W-1, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } } @@ -12362,19 +12363,19 @@ defines.W = 5 defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -12383,11 +12384,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -12411,7 +12412,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12421,1026 +12422,1026 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); // try traversing all tags tag_ = 0; rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; } ''' # Weights mixed with attributes [cases.test_rbyd_sparse_mixed] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; // make id0 with weight w1 rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "unrelated", 9), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); // make id2 with weight w2 - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +1), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +1), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); // make id5 with weight w3 - lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 3, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +2), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xcc\xcc", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); // make id9 with weight w4 - lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 6, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xdd\xdd", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +3), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +3), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xdd\xdd", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); // make id14 with weight w5 - lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, 10, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +4), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 2, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 5, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 9, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_DATA, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 14, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); ''' [cases.test_rbyd_sparse_mixed_traverse] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "unrelated", 9), // make id0 with weight w1 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xaa\xaa", 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xaa\xaa", 2), // make id2 with weight w2 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +1), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +1), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xbb\xbb", 2), // make id5 with weight w3 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xcc\xcc", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +2), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xcc\xcc", 2), // make id9 with weight w4 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xdd\xdd", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +3), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +3), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xdd\xdd", 2), // make id14 with weight w5 - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xee\xee\xee\xee", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xee\xee", 2), - LFSR_RATTR( - LFSR_TAG_GROW, +4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +4), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xee\xee", 2))) => 0; // traverse, finding tags and weights - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 9); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 0); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 0); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 2); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 2); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 5); assert(weight_ == 3); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 5); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 9); assert(weight_ == 4); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 9); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == 14); assert(weight_ == 5); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == 14); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_sparse_mixed_permutations] @@ -13451,19 +13452,19 @@ defines.W = 5 defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -13472,11 +13473,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -13500,10 +13501,10 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "unrelated", 9))) => 0; for (unsigned j = 0; j < N; j++) { @@ -13515,51 +13516,51 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, names[perm[j] % 6], 2), - LFSR_RATTR( - LFSR_TAG_GROW, +W-1), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +W-1), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, names[perm[j] % 6], 2))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); + assert(lfs3_data_size(data_) == 9); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, j*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_ATTR(1), + assert(lfs3_data_size(data_) == 4); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, j*W+W-1, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == j*W+W-1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_ATTR(2), + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, j*W+W-1, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == j*W+W-1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookup(&lfs3, &rbyd, j*W+W-1, LFS3_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } } @@ -13573,19 +13574,19 @@ defines.W = 5 defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -13594,11 +13595,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -13622,10 +13623,10 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(3), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(3), 0, "unrelated", 9))) => 0; for (unsigned j = 0; j < N; j++) { @@ -13637,58 +13638,58 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, names[perm[j] % 6], 2), - LFSR_RATTR( - LFSR_TAG_GROW, +W-1), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR( + LFS3_TAG_GROW, +W-1), + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, names[perm[j] % 6], 2))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); // try traversing all tags tag_ = 0; rid_ = -1; - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(3)); + assert(tag_ == LFS3_TAG_ATTR(3)); assert(rid_ == -1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 9); + assert(lfs3_data_size(data_) == 9); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == j*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == j*W+W-1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + assert(lfs3_data_size(data_) == 2); + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == j*W+W-1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; } ''' @@ -13704,19 +13705,19 @@ defines.D = [1, 2] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -13725,11 +13726,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -13753,7 +13754,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -13763,18 +13764,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -13782,45 +13783,45 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, +D))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_GROW, +D))) => 0; assert(rbyd.weight == N*W+D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W+D); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1+D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1+D); assert(weight_ == W+D); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else if (k > j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1+D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1+D); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -13836,19 +13837,19 @@ defines.D = [1, 2] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -13857,11 +13858,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[6]; // test all permutations of a given size @@ -13885,7 +13886,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -13895,18 +13896,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -13914,54 +13915,57 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_GROW | LFSR_TAG_DATA, +D, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_GROW | LFS3_TAG_DATA, +D, names[j % 6], 6))) => 0; assert(rbyd.weight == N*W+D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W+D); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1+D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1+D); assert(weight_ == W+D); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else if (k > j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1+D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1+D); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -13970,7 +13974,7 @@ code = ''' ''' # I don't know if this actually happens in littlefs, but this tests a specific -# code path in lfsr_rbyd_append (split altgt + shrinking) +# code path in lfs3_rbyd_append (split altgt + shrinking) [cases.test_rbyd_sparse_grappend_permutations] defines.N = 'range(1, 7)' defines.W = 5 @@ -13980,19 +13984,19 @@ defines.D = [1, 2] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -14001,11 +14005,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[6]; // test all permutations of a given size @@ -14029,7 +14033,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -14039,18 +14043,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -14058,69 +14062,73 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_GROW | LFSR_TAG_ATTR(1), +D, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_GROW | LFS3_TAG_ATTR(1), +D, names[j % 6], 6))) => 0; assert(rbyd.weight == N*W+D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W+D); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1+D, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1+D, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == k*W+W-1+D); assert(weight_ == W+D); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1+D, LFSR_TAG_ATTR(2), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1+D, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == k*W+W-1+D); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else if (k > j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1+D, LFSR_TAG_ATTR(2), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1+D, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == k*W+W-1+D); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1, LFSR_TAG_ATTR(2), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -14137,19 +14145,19 @@ defines.D = [1, 2] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -14158,11 +14166,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -14186,7 +14194,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -14196,18 +14204,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -14215,45 +14223,45 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, -D))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_GROW, -D))) => 0; assert(rbyd.weight == N*W-D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W-D); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1-D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1-D); assert(weight_ == W-D); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else if (k > j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1-D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1-D); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -14269,19 +14277,19 @@ defines.D = [1, 2] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -14290,11 +14298,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[6]; // test all permutations of a given size @@ -14318,7 +14326,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -14328,18 +14336,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -14347,54 +14355,57 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_GROW | LFSR_TAG_DATA, -D, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_GROW | LFS3_TAG_DATA, -D, names[j % 6], 6))) => 0; assert(rbyd.weight == N*W-D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W-D); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1-D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1-D); assert(weight_ == W-D); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else if (k > j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1-D, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1-D); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -14403,7 +14414,7 @@ code = ''' ''' # I don't know if this actually happens in littlefs, but this tests a specific -# code path in lfsr_rbyd_append (split altgt + shrinking) +# code path in lfs3_rbyd_append (split altgt + shrinking) [cases.test_rbyd_sparse_shrappend_permutations] defines.N = 'range(1, 7)' defines.W = 5 @@ -14413,19 +14424,19 @@ defines.D = [1, 2] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -14434,11 +14445,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[6]; // test all permutations of a given size @@ -14462,7 +14473,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -14472,18 +14483,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -14491,69 +14502,73 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_GROW | LFSR_TAG_ATTR(1), -D, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_GROW | LFS3_TAG_ATTR(1), -D, names[j % 6], 6))) => 0; assert(rbyd.weight == N*W-D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W-D); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1-D, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1-D, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == k*W+W-1-D); assert(weight_ == W-D); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1-D, LFSR_TAG_ATTR(2), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1-D, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == k*W+W-1-D); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else if (k > j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1-D, LFSR_TAG_ATTR(2), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1-D, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == k*W+W-1-D); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1, LFSR_TAG_ATTR(2), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1, LFS3_TAG_ATTR(2), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -14569,19 +14584,19 @@ defines.W = 5 defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -14590,11 +14605,11 @@ code = ''' "\xee\xee\xee\xee\xee\xee", "\xff\xff\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[6]; // test all permutations of a given size @@ -14618,7 +14633,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -14628,18 +14643,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -14647,77 +14662,81 @@ code = ''' printf("--- deleting: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -W))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -W))) => 0; assert(rbyd.weight == (N-1)*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == (N-1)*W); for (unsigned k = 0; k < N-1; k++) { if (k >= j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[j % 6], 6))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 6; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 6) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, + NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -14733,19 +14752,19 @@ defines.W = 5 defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -14754,11 +14773,11 @@ code = ''' "\xee\xee\xee\xee", "\xff\xff\xff\xff", }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; // test all permutations of a given size @@ -14782,7 +14801,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -14792,18 +14811,18 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +W, + lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try appending an rattr to each rid, this should not affect // weights at all! @@ -14812,101 +14831,101 @@ code = ''' printf("--- appending: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, names[j % 6], 2))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == k*W+W-1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } // now try removing the rattr printf("--- removing: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_ATTR(1), - NULL, &data) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_ATTR(1), + NULL, &data) => LFS3_ERR_NOENT; } } // and try putting the rattr back just for good measure printf("--- appending: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, names[j % 6], 2))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, k*W+W-1, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(rid_ == k*W+W-1); assert(weight_ == W); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 4; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, - k*W+W-1, LFSR_TAG_ATTR(1), + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + k*W+W-1, LFS3_TAG_ATTR(1), &rid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(rid_ == k*W+W-1); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } } @@ -14923,34 +14942,34 @@ defines.SEED = 'range(1000)' fuzz = 'SEED' # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_data_t data; uint8_t buffer[4]; printf("perm: ["); uint32_t prng = SEED; - lfs_size_t count = 0; + lfs3_size_t count = 0; for (unsigned i = 0; i < N; i++) { // choose create/delete or rattr append/remove uint8_t op = TEST_PRNG(&prng) % 4; // choose an rid - lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); + lfs3_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose an rattr uint8_t u = TEST_PRNG(&prng) % M; - if (rid == (lfs_ssize_t)count || op == 0) { + if (rid == (lfs3_ssize_t)count || op == 0) { printf("c%d=%c", rid, 'a'+(i % 26)); count += 1; } else if (op == 1) { @@ -14974,7 +14993,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -14982,50 +15001,50 @@ code = ''' // choose create/delete or rattr append/remove uint8_t op = TEST_PRNG(&prng) % 4; // choose an rid - lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); + lfs3_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose an rattr uint8_t u = TEST_PRNG(&prng) % M; - if (rid == (lfs_ssize_t)count || op == 0) { + if (rid == (lfs3_ssize_t)count || op == 0) { // update our sim memmove(sim+(rid+1)*(M+1), sim+rid*(M+1), (count-rid)*(M+1)); memset(&sim[rid*(M+1)], 0, M+1); sim[rid*(M+1)] = 'a'+(i % 26); count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else if (op == 1) { // update our sim memmove(sim+rid*(M+1), sim+(rid+1)*(M+1), (count-rid-1)*(M+1)); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = 'a'+(i % 26); // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(u), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(u), 0, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else if (op == 3) { // update our sim sim[rid*(M+1) + u+1] = '\0'; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(u), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(u), 0))) => 0; } } // compare rbyd vs simulation printf("expd: ["); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { printf("%c", sim[rid*(M+1)]); for (uint8_t u = 0; u < M; u++) { if (sim[rid*(M+1) + u+1]) { @@ -15034,41 +15053,41 @@ code = ''' printf("_"); } } - if (rid < (lfs_ssize_t)count-1) { + if (rid < (lfs3_ssize_t)count-1) { printf(", "); } } printf("]\n"); printf("rbyd: ["); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) { - int err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)rbyd.weight; rid++) { + int err = lfs3_rbyd_lookup(&lfs3, &rbyd, rid, LFS3_TAG_DATA, NULL, &data); if (!err) { - lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); + lfs3_ssize_t size = lfs3_data_read(&lfs3, &data, buffer, 4); printf("%.*s", size, buffer); } else { printf("?"); } for (uint8_t u = 0; u < M; u++) { - err = lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_ATTR(u), + err = lfs3_rbyd_lookup(&lfs3, &rbyd, rid, LFS3_TAG_ATTR(u), NULL, &data); if (!err) { - lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); + lfs3_ssize_t size = lfs3_data_read(&lfs3, &data, buffer, 4); printf("%.*s", size, buffer); } else { printf("_"); } } - if (rid < (lfs_ssize_t)count-1) { + if (rid < (lfs3_ssize_t)count-1) { printf(", "); } } printf("]\n"); assert(count == rbyd.weight); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { - lfsr_rbyd_lookup(&lfs, &rbyd, rid, LFSR_TAG_DATA, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { + lfs3_rbyd_lookup(&lfs3, &rbyd, rid, LFS3_TAG_DATA, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(&sim[rid*(M+1)], buffer, 1) == 0); } @@ -15083,38 +15102,38 @@ defines.SEED = 'range(1000)' fuzz = 'SEED' # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_data_t data; + lfs3_rbyd_t rbyd; + lfs3_tag_t tag_; + lfs3_ssize_t rid_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_data_t data; uint8_t buffer[4]; printf("perm: ["); uint32_t prng = SEED; - lfs_size_t count = 0; + lfs3_size_t count = 0; for (unsigned i = 0; i < N; i++) { // choose create/delete/grow/shrink uint8_t op = TEST_PRNG(&prng) % 4; // choose an rid - lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); + lfs3_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose a weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); - if (rid == (lfs_ssize_t)count || op == 0) { + if (rid == (lfs3_ssize_t)count || op == 0) { printf("c%dw%d=%c", rid, weight, 'a'+(i % 26)); count += 1; } else if (op == 1) { @@ -15134,13 +15153,13 @@ code = ''' // set up a simulation to compare against, fun fact this performs // worst than our actual rbyd block! char *sim = malloc(N); - lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim_weights = malloc(N*sizeof(lfs3_size_t)); memset(sim, 0, N); - memset(sim_weights, 0, N*sizeof(lfs_size_t)); + memset(sim_weights, 0, N*sizeof(lfs3_size_t)); // set up rbyd block rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -15148,28 +15167,28 @@ code = ''' // choose create/delete/grow/shrink uint8_t op = TEST_PRNG(&prng) % 4; // choose an rid - lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); + lfs3_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose a weight - lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); + lfs3_size_t weight = 1 + (TEST_PRNG(&prng) % W); // calculate actual rid in rbyd space - lfs_ssize_t weighted_rid = 0; - for (lfs_ssize_t j = 0; j < rid; j++) { + lfs3_ssize_t weighted_rid = 0; + for (lfs3_ssize_t j = 0; j < rid; j++) { weighted_rid += sim_weights[j]; } - if (rid == (lfs_ssize_t)count || op == 0) { + if (rid == (lfs3_ssize_t)count || op == 0) { // update our sim memmove(sim+rid+1, sim+rid, count-rid); memmove(sim_weights+rid+1, sim_weights+rid, - (count-rid)*sizeof(lfs_size_t)); + (count-rid)*sizeof(lfs3_size_t)); sim[rid] = 'a'+(i % 26); sim_weights[rid] = weight; count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +weight, + lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +weight, &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else if (op == 1) { // get the correct weight from the sim @@ -15177,55 +15196,55 @@ code = ''' // update our sim memmove(sim+rid, sim+rid+1, count-rid-1); memmove(sim_weights+rid, sim_weights+rid+1, - (count-rid-1)*sizeof(lfs_size_t)); + (count-rid-1)*sizeof(lfs3_size_t)); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -weight_))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid+weight_-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -weight_))) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; // update our sim sim_weights[rid] += weight; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, +weight))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid+weight_-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_GROW, +weight))) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; // don't let shrink go to zero here! this is already hard enough // to simulate - weight = lfs_min(weight, weight_-1); + weight = lfs3_min(weight, weight_-1); // update our sim sim_weights[rid] -= weight; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, -weight))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid+weight_-1, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_GROW, -weight))) => 0; } } // compare rbyd vs simulation printf("expd: ["); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { printf("%cw%d", sim[rid], sim_weights[rid]); - if (rid < (lfs_ssize_t)count-1) { + if (rid < (lfs3_ssize_t)count-1) { printf(", "); } } printf("]\n"); printf("rbyd: ["); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { // calculate actual rid in rbyd space - lfs_ssize_t weighted_rid = 0; - for (lfs_ssize_t j = 0; j < rid; j++) { + lfs3_ssize_t weighted_rid = 0; + for (lfs3_ssize_t j = 0; j < rid; j++) { weighted_rid += sim_weights[j]; } - int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, - weighted_rid, LFSR_TAG_DATA, + int err = lfs3_rbyd_lookupnext(&lfs3, &rbyd, + weighted_rid, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_); if (!err) { - lfs_ssize_t size = lfsr_data_read(&lfs, &data_, buffer, 4); + lfs3_ssize_t size = lfs3_data_read(&lfs3, &data_, buffer, 4); if (size >= 0) { printf("%.*sw%d", size, buffer, weight_); } else { @@ -15234,31 +15253,31 @@ code = ''' } else { printf("?"); } - if (rid < (lfs_ssize_t)count-1) { + if (rid < (lfs3_ssize_t)count-1) { printf(", "); } } printf("]\n"); // calculate total weight - lfs_size_t total_weight = 0; - for (lfs_ssize_t j = 0; j < (lfs_ssize_t)count; j++) { + lfs3_size_t total_weight = 0; + for (lfs3_ssize_t j = 0; j < (lfs3_ssize_t)count; j++) { total_weight += sim_weights[j]; } assert(total_weight == rbyd.weight); - for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + for (lfs3_ssize_t rid = 0; rid < (lfs3_ssize_t)count; rid++) { // calculate actual rid in rbyd space - lfs_ssize_t weighted_rid = 0; - for (lfs_ssize_t j = 0; j < rid; j++) { + lfs3_ssize_t weighted_rid = 0; + for (lfs3_ssize_t j = 0; j < rid; j++) { weighted_rid += sim_weights[j]; } - lfsr_rbyd_lookupnext(&lfs, &rbyd, - weighted_rid, LFSR_TAG_DATA, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, + weighted_rid, LFS3_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; - lfsr_data_read(&lfs, &data, buffer, 4) => 1; + lfs3_rbyd_lookup(&lfs3, &rbyd, rid_, tag_, NULL, &data) => 0; + lfs3_data_read(&lfs3, &data, buffer, 4) => 1; assert(memcmp(&sim[rid], buffer, 1) == 0); } @@ -15277,19 +15296,19 @@ defines.SHIFT = [0, 3, -3] # PERMUTATION=-1 => exhaust all permutations # PERMUTATION=n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -15320,7 +15339,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -15331,28 +15350,28 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); // test that we can lookup each rattr with a wide lookup - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_tag_t tag_; - lfsr_data_t data_; - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_tag_t tag_; + lfs3_data_t data_; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR((j + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((j + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } ''' @@ -15367,19 +15386,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -15410,7 +15429,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -15421,21 +15440,21 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -15443,56 +15462,56 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_ATTR, 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MASK8 | LFS3_TAG_ATTR, 0))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); if (k != j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, - &tag_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, + &tag_, &data_) => LFS3_ERR_NOENT; } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } } @@ -15512,19 +15531,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -15555,7 +15574,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -15566,21 +15585,21 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -15588,61 +15607,62 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, names[j % 6], 3))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 3); + assert(lfs3_data_size(data_) == 3); } else { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; if (k == j) { - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 3); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 3); } else { - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } } @@ -15658,19 +15678,19 @@ defines.SHIFT = [0, 3, -3] # PERMUTATION=-1 => exhaust all permutations # PERMUTATION=n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -15701,7 +15721,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -15712,31 +15732,31 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, names[perm[j] % 6], 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x80), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x80), 0, names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); // test that we can lookup each rattr with a wide lookup - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_tag_t tag_; - lfsr_data_t data_; - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_tag_t tag_; + lfs3_data_t data_; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR(0x7f & (j + SHIFT))); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR(0x7f & (j + SHIFT))); + assert(lfs3_data_size(data_) == 2); } } ''' @@ -15751,19 +15771,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -15794,7 +15814,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -15805,24 +15825,24 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, names[perm[j] % 6], 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x80), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x80), 0, names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -15830,63 +15850,63 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_ATTR, 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MASK8 | LFS3_TAG_ATTR, 0))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); if (k != j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(0x7f & (k + SHIFT))); + assert(tag_ == LFS3_TAG_ATTR(0x7f & (k + SHIFT))); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(0x80)); + assert(tag_ == LFS3_TAG_ATTR(0x80)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 1); + assert(lfs3_data_size(data_) == 1); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, - &tag_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, + &tag_, &data_) => LFS3_ERR_NOENT; } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } } @@ -15906,19 +15926,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -15949,7 +15969,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -15960,24 +15980,24 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, names[perm[j] % 6], 2), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x80), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x80), 0, names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -15985,68 +16005,69 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, names[j % 6], 3))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(0x7f & ~(k + SHIFT))); + assert(tag_ == LFS3_TAG_ATTR(0x7f & ~(k + SHIFT))); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 3); + assert(lfs3_data_size(data_) == 3); } else { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(0x7f & (k + SHIFT))); + assert(tag_ == LFS3_TAG_ATTR(0x7f & (k + SHIFT))); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(0x80)); + assert(tag_ == LFS3_TAG_ATTR(0x80)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 1); + assert(lfs3_data_size(data_) == 1); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; if (k == j) { - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 3); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 3); } else { - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } } @@ -16062,19 +16083,19 @@ defines.SHIFT = [0, 3, -3] # PERMUTATION=-1 => exhaust all permutations # PERMUTATION=n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -16105,7 +16126,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -16116,25 +16137,25 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); // test that we can lookup each rattr with a wide lookup - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_tag_t tag_; - lfsr_data_t data_; - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_tag_t tag_; + lfs3_data_t data_; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR((j + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 4); + assert(tag_ == LFS3_TAG_ATTR((j + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 4); } } ''' @@ -16149,19 +16170,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -16192,7 +16213,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -16203,18 +16224,18 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -16222,59 +16243,59 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MASK8 | LFSR_TAG_ATTR, 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MASK8 | LFS3_TAG_ATTR, 0))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { assert(rid_ == k+1); - assert(tag_ == LFSR_TAG_ATTR((k+1 + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k+1 + SHIFT) & 0x7f)); assert(weight_ == 2); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else if (k > j) { assert(rid_ == k+1); - assert(tag_ == LFSR_TAG_ATTR((k+1 + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k+1 + SHIFT) & 0x7f)); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } else { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, - &tag_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, + &tag_, &data_) => LFS3_ERR_NOENT; } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 4); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 4); } } } @@ -16294,19 +16315,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -16337,7 +16358,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -16348,18 +16369,18 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -16367,54 +16388,55 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, names[j % 6], 6))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 6); + assert(lfs3_data_size(data_) == 6); } else { assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; if (k == j) { - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 6); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 6); } else { - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 4); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 4); } } } @@ -16431,19 +16453,19 @@ defines.SHIFT = [0, 3, -3] # PERMUTATION=-1 => exhaust all permutations # PERMUTATION=n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -16474,7 +16496,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -16485,28 +16507,28 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); // a supwide rattr lookup only gets the file type - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_tag_t tag_; - lfsr_data_t data_; - lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_MASK12, + lfs3_tag_t tag_; + lfs3_data_t data_; + lfs3_rbyd_lookup(&lfs3, &rbyd, j, LFS3_TAG_MASK12, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_DATA); - assert(lfsr_data_size(data_) == 4); + assert(tag_ == LFS3_TAG_DATA); + assert(lfs3_data_size(data_) == 4); } } ''' @@ -16521,19 +16543,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -16564,7 +16586,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -16575,21 +16597,21 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -16597,57 +16619,57 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_MASK12 | LFSR_TAG_ATTR, + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_MASK12 | LFS3_TAG_ATTR, 0))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { if (k != j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == ((k == j+1) ? 2 : 1)); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, - &tag_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, + &tag_, &data_) => LFS3_ERR_NOENT; } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, - LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } } @@ -16667,19 +16689,19 @@ defines.SHIFT = [0, 3, -3] defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -16710,7 +16732,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -16721,21 +16743,21 @@ code = ''' } // give each rattr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, names[perm[j] % 6], 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); // copy block so we can reset after each remove - lfsr_rbyd_t backup_rbyd = rbyd; - uint8_t *backup_block = malloc(lfsr_rbyd_eoff(&rbyd)); + lfs3_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(lfs3_rbyd_eoff(&rbyd)); CFG->read(CFG, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; + backup_block, lfs3_rbyd_eoff(&rbyd)) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -16743,64 +16765,65 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, - backup_block, lfsr_rbyd_eoff(&rbyd), + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_bd_prog(&lfs3, rbyd.blocks[0], 0, + backup_block, lfs3_rbyd_eoff(&rbyd), NULL, false) => 0; - lfsr_bd_flush(&lfs, + lfs3_bd_flush(&lfs3, NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK12 | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), + lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK12 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, names[j % 6], 3))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; - lfsr_tag_t tag_ = 0; - lfs_ssize_t rid_ = -1; - lfs_size_t weight_; - lfsr_data_t data_; + lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; + lfs3_tag_t tag_ = 0; + lfs3_ssize_t rid_ = -1; + lfs3_size_t weight_; + lfs3_data_t data_; for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 3); + assert(lfs3_data_size(data_) == 3); } else { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == k); - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 2); + assert(lfs3_data_size(data_) == 2); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, rid_, tag_+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfs3_rbyd_lookup(&lfs3, &rbyd, k, + LFS3_TAG_MASK8 | LFS3_TAG_ATTR, &tag_, &data_) => 0; if (k == j) { - assert(tag_ == LFSR_TAG_ATTR(~(k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 3); + assert(tag_ == LFS3_TAG_ATTR(~(k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 3); } else { - assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); - assert(lfsr_data_size(data_) == 2); + assert(tag_ == LFS3_TAG_ATTR((k + SHIFT) & 0x7f)); + assert(lfs3_data_size(data_) == 2); } } } @@ -16817,299 +16840,299 @@ code = ''' # up with an awkward null tag in our rbyd. Need to test we handle this # correctly. [cases.test_rbyd_unreachable_hole] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // create a null tag hole rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(0), 0))) => 0; assert(rbyd.weight == 0); // can we still access things? - lfs_ssize_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_ssize_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == -1); - assert(tag_ == LFSR_TAG_ATTR(1)); + assert(tag_ == LFS3_TAG_ATTR(1)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); uint8_t rbuf[32]; - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1)+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1)+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_unreachable_hole_rm] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // create a null tag hole rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(2), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(2), 0, "\xcc\xcc\xcc\xcc", 4), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(0), 0))) => 0; assert(rbyd.weight == 0); // remove a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(1), 0))) => 0; assert(rbyd.weight == 0); // can we still access things? - lfs_ssize_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_ssize_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == -1); - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); uint8_t rbuf[32]; - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2)+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2)+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_unreachable_hole_delete] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // create a null tag hole rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xcc\xcc\xcc\xcc", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(0), 0))) => 0; assert(rbyd.weight == 2); // delete a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( + LFS3_RATTR(LFS3_TAG_RM, -1))) => 0; assert(rbyd.weight == 1); // can we still access things? - lfs_ssize_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_ssize_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == 0); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); uint8_t rbuf[32]; - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_unreachable_hole_subwide] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // create a null tag hole rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x00), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x00), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x01), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x01), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0x80), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0x80), 0, "\xdd\xdd\xdd\xdd", 4), - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(0), 0))) => 0; assert(rbyd.weight == 0); // subwide replace a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK8 | LFSR_TAG_ATTR(0x02), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK8 | LFS3_TAG_ATTR(0x02), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 0); // can we still access things? - lfs_ssize_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_ssize_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == -1); - assert(tag_ == LFSR_TAG_ATTR(0x02)); + assert(tag_ == LFS3_TAG_ATTR(0x02)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); uint8_t rbuf[32]; - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2)+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2)+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == -1); - assert(tag_ == LFSR_TAG_ATTR(0x80)); + assert(tag_ == LFS3_TAG_ATTR(0x80)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xdd\xdd\xdd\xdd", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(0x80)+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(0x80)+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_rbyd_unreachable_hole_supwide] -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfs_init(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_init(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_rbyd_t init_rbyd = { + lfs3_rbyd_t init_rbyd = { .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, .weight = 0, }; - lfsr_rbyd_t rbyd; + lfs3_rbyd_t rbyd; // create a null tag hole rbyd = init_rbyd; - lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(0), 0, + lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(0), 0, "\xaa\xaa\xaa\xaa", 4), - LFSR_RATTR_BUF( - LFSR_TAG_ATTR(1), 0, + LFS3_RATTR_BUF( + LFS3_TAG_ATTR(1), 0, "\xbb\xbb\xbb\xbb", 4), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, +1, + LFS3_RATTR_BUF( + LFS3_TAG_DATA, +1, "\xdd\xdd\xdd\xdd", 4))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0))) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR( + LFS3_TAG_RM | LFS3_TAG_ATTR(0), 0))) => 0; assert(rbyd.weight == 1); // supwide replace a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR_BUF( - LFSR_TAG_MASK12 | LFSR_TAG_ATTR(2), 0, + lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( + LFS3_RATTR_BUF( + LFS3_TAG_MASK12 | LFS3_TAG_ATTR(2), 0, "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 1); // can we still access things? - lfs_ssize_t rid_; - lfsr_tag_t tag_; - lfs_size_t weight_; - lfsr_data_t data_; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + lfs3_ssize_t rid_; + lfs3_tag_t tag_; + lfs3_size_t weight_; + lfs3_data_t data_; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == -1); - assert(tag_ == LFSR_TAG_ATTR(2)); + assert(tag_ == LFS3_TAG_ATTR(2)); assert(weight_ == 0); - assert(lfsr_data_size(data_) == 4); + assert(lfs3_data_size(data_) == 4); uint8_t rbuf[32]; - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2)+1, + lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(2)+1, &rid_, &tag_, &weight_, &data_) => 0; assert(rid_ == 0); - assert(tag_ == LFSR_TAG_DATA); + assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); - assert(lfsr_data_size(data_) == 4); - lfsr_data_read(&lfs, &data_, rbuf, 32) => 4; + assert(lfs3_data_size(data_) == 4); + lfs3_data_read(&lfs3, &data_, rbuf, 32) => 4; assert(memcmp(rbuf, "\xdd\xdd\xdd\xdd", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA+1, - &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA+1, + &rid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; ''' diff --git a/tests/test_relocations.toml b/tests/test_relocations.toml index 2c015bed..22285d98 100644 --- a/tests/test_relocations.toml +++ b/tests/test_relocations.toml @@ -16,79 +16,79 @@ after = [ defines.BLOCK_RECYCLES = [4, 1, 0] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_relocations_spam_dir_fuzz] @@ -98,24 +98,24 @@ defines.OPS = 1024 defines.SEED = 'range(10)' fuzz = 'SEED' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -123,7 +123,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -134,47 +134,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -186,59 +186,59 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # files + relocations may create problems for shrubs @@ -256,63 +256,63 @@ defines.SIZE = [ ] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_relocations_spam_file_fuzz] @@ -332,29 +332,29 @@ defines.SEED = 'range(10)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -363,7 +363,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -378,24 +378,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -403,25 +403,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -434,7 +434,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -442,7 +442,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -457,74 +457,74 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # open files + relocations may create problems for uncreats/zombies @@ -545,28 +545,28 @@ defines.SEED = 'range(10)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -577,13 +577,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -597,23 +597,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -625,7 +625,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -634,7 +634,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -654,26 +654,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -684,7 +684,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -700,8 +700,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -709,10 +709,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -723,7 +723,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -731,10 +731,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -752,17 +752,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -770,7 +770,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -783,9 +783,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -794,16 +794,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -819,7 +819,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -829,7 +829,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -843,7 +843,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -857,94 +857,94 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # open files + dirs + relocations can cause so many problems it's not worth @@ -966,29 +966,29 @@ defines.SEED = 'range(10)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -999,13 +999,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -1022,23 +1022,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -1050,7 +1050,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1059,7 +1059,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1082,26 +1082,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -1112,7 +1112,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -1128,19 +1128,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -1151,7 +1151,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -1159,10 +1159,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -1182,17 +1182,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1202,7 +1202,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1215,14 +1215,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -1240,16 +1240,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1268,7 +1268,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -1280,7 +1280,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1297,7 +1297,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -1311,9 +1311,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -1326,14 +1326,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -1349,7 +1349,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -1358,110 +1358,110 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -1495,65 +1495,66 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDWR | LFS_O_CREAT) => 0; - lfs_ssize_t d = lfsr_file_read(&lfs, &state_file, &state, sizeof(state)); + lfs3_file_t state_file; + lfs3_file_open(&lfs3, &state_file, + "state", LFS3_O_RDWR | LFS3_O_CREAT) => 0; + lfs3_ssize_t d = lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)); assert(d == 0 || d == sizeof(state)); // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST); + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST); uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 0 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; uint32_t wprng = TEST_PRNG(&prng); // create a file here @@ -1561,7 +1562,7 @@ code = ''' sprintf(name, "test/amethyst%03x", x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -1570,45 +1571,45 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "test/%s", info.name); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % count; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t y = TEST_PRNG(&prng) % N; // find the file - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this file char old_name[256]; @@ -1616,75 +1617,75 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // update our state file state.i = i; state.prng = prng; - lfsr_file_rewind(&lfs, &state_file) => 0; - lfsr_file_write(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_rewind(&lfs3, &state_file) => 0; + lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_sync(&lfs, &state_file) => 0; + lfs3_file_sync(&lfs3, &state_file) => 0; } // go ahead and close our state file in case we remount - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // at least try to read the files char name[256]; sprintf(name, "test/%s", info.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # A general purpose powerloss fuzz test, with directories! @@ -1716,108 +1717,109 @@ if = '(SIZE*N)/BLOCK_SIZE <= 16' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // keep some test state on disk to survive powerloss typedef struct fuzz_state { - lfs_size_t i; + lfs3_size_t i; uint32_t prng; } fuzz_state_t; fuzz_state_t state = {.i = 0, .prng = SEED}; - lfsr_file_t state_file; - lfsr_file_open(&lfs, &state_file, "state", LFS_O_RDWR | LFS_O_CREAT) => 0; - lfs_ssize_t d = lfsr_file_read(&lfs, &state_file, &state, sizeof(state)); + lfs3_file_t state_file; + lfs3_file_open(&lfs3, &state_file, + "state", LFS3_O_RDWR | LFS3_O_CREAT) => 0; + lfs3_ssize_t d = lfs3_file_read(&lfs3, &state_file, &state, sizeof(state)); assert(d == 0 || d == sizeof(state)); // keep test files in a separate directory - err = lfsr_mkdir(&lfs, "test"); - assert(!err || err == LFS_ERR_EXIST); + err = lfs3_mkdir(&lfs3, "test"); + assert(!err || err == LFS3_ERR_EXIST); uint32_t prng = state.prng; - for (lfs_size_t i = state.i; i < OPS; i++) { + for (lfs3_size_t i = state.i; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 6; // how many dirs do we have? - lfs_size_t dir_count = 0; - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t dir_count = 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("quartz...")); assert(memcmp(info.name, "quartz", strlen("quartz")) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); dir_count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // dir op? if (op < 3 || dir_count == 0) { // creating a new dir? if (op == 0 || dir_count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // create a dir here char name[256]; sprintf(name, "test/quartz%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); // deleting a dir? } else if (op == 1) { // choose a random dir to delete - lfs_size_t j = TEST_PRNG(&prng) % dir_count; + lfs3_size_t j = TEST_PRNG(&prng) % dir_count; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // try to delete this dir, ignore non-empty dirs! char name[256]; assert(strlen(info.name) == strlen("quartz...")); sprintf(name, "test/%s", info.name); - int err = lfsr_remove(&lfs, name); - assert(!err || err == LFS_ERR_NOTEMPTY); + int err = lfs3_remove(&lfs3, name); + assert(!err || err == LFS3_ERR_NOTEMPTY); // renaming a dir? } else { // choose a random dir to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % dir_count; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % dir_count; + lfs3_size_t y = TEST_PRNG(&prng) % N; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // rename this dir, ignore conflicts! char old_name[256]; @@ -1825,56 +1827,56 @@ code = ''' sprintf(old_name, "test/%s", info.name); char new_name[256]; sprintf(new_name, "test/quartz%03x", y); - int err = lfsr_rename(&lfs, old_name, new_name); - assert(!err || err == LFS_ERR_NOTEMPTY); + int err = lfs3_rename(&lfs3, old_name, new_name); + assert(!err || err == LFS3_ERR_NOTEMPTY); } // file op? } else { // choose a pseudo-random dir - lfs_size_t dir_i = TEST_PRNG(&prng) % dir_count; + lfs3_size_t dir_i = TEST_PRNG(&prng) % dir_count; // find the dir - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= dir_i; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= dir_i; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; char dir_path[256]; sprintf(dir_path, "test/%s", info.name); // how many files do we have? - lfs_size_t count = 0; - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_size_t count = 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("amethyst...")); assert(memcmp( info.name, "amethyst", strlen("amethyst")) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); count++; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // creating a new file? if (op == 3 || count == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % M; + lfs3_size_t x = TEST_PRNG(&prng) % M; uint32_t wprng = TEST_PRNG(&prng); // create a file here @@ -1882,7 +1884,7 @@ code = ''' sprintf(name, "%s/amethyst%03x", dir_path, x); uint8_t wbuf[SIZE]; uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE-1; j++) { + for (lfs3_size_t j = 0; j < SIZE-1; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); ck = (ck + (wbuf[j] - 'a')) % 26; } @@ -1891,58 +1893,58 @@ code = ''' wbuf[SIZE-1] = 'a' + ((26 - ck) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 4) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // delete this file char name[256]; assert(strlen(info.name) == strlen("amethyst...")); sprintf(name, "%s/%s", dir_path, info.name); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename - lfs_size_t j = TEST_PRNG(&prng) % count; + lfs3_size_t j = TEST_PRNG(&prng) % count; // find the file - lfsr_dir_open(&lfs, &dir, dir_path) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; - for (lfs_size_t k = 0; k <= j; k++) { - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, dir_path) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; + for (lfs3_size_t k = 0; k <= j; k++) { + lfs3_dir_read(&lfs3, &dir, &info) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // choose a random dir to rename to - lfs_size_t dir_j = TEST_PRNG(&prng) % dir_count; + lfs3_size_t dir_j = TEST_PRNG(&prng) % dir_count; // find the dir - struct lfs_info info_; - lfsr_dir_open(&lfs, &dir, "test") => 0; - lfsr_dir_read(&lfs, &dir, &info_) => 0; - lfsr_dir_read(&lfs, &dir, &info_) => 0; - for (lfs_size_t k = 0; k <= dir_j; k++) { - lfsr_dir_read(&lfs, &dir, &info_) => 0; + struct lfs3_info info_; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + lfs3_dir_read(&lfs3, &dir, &info_) => 0; + lfs3_dir_read(&lfs3, &dir, &info_) => 0; + for (lfs3_size_t k = 0; k <= dir_j; k++) { + lfs3_dir_read(&lfs3, &dir, &info_) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; // choose a random file to rename to - lfs_size_t y = TEST_PRNG(&prng) % M; + lfs3_size_t y = TEST_PRNG(&prng) % M; // rename this file char old_name[256]; @@ -1950,104 +1952,104 @@ code = ''' sprintf(old_name, "%s/%s", dir_path, info.name); char new_name[256]; sprintf(new_name, "test/%s/amethyst%03x", info_.name, y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } } // update our state file state.i = i; state.prng = prng; - lfsr_file_rewind(&lfs, &state_file) => 0; - lfsr_file_write(&lfs, &state_file, &state, sizeof(state)) + lfs3_file_rewind(&lfs3, &state_file) => 0; + lfs3_file_write(&lfs3, &state_file, &state, sizeof(state)) => sizeof(state); - lfsr_file_sync(&lfs, &state_file) => 0; + lfs3_file_sync(&lfs3, &state_file) => 0; } // go ahead and close our state file in case we remount - lfsr_file_close(&lfs, &state_file) => 0; + lfs3_file_close(&lfs3, &state_file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that things look more-or-less ok - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "test") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "test") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); while (true) { - int err = lfsr_dir_read(&lfs, &dir, &info); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_dir_read(&lfs3, &dir, &info); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info.name) == strlen("quartz...")); assert(memcmp(info.name, "quartz", strlen("quartz")) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // check that our dirs look more-or-less ok char name[256]; sprintf(name, "test/%s", info.name); - lfsr_dir_t dir_; - lfsr_dir_open(&lfs, &dir_, name) => 0; - struct lfs_info info_; - lfsr_dir_read(&lfs, &dir_, &info_) => 0; + lfs3_dir_t dir_; + lfs3_dir_open(&lfs3, &dir_, name) => 0; + struct lfs3_info info_; + lfs3_dir_read(&lfs3, &dir_, &info_) => 0; assert(strcmp(info_.name, ".") == 0); - assert(info_.type == LFS_TYPE_DIR); + assert(info_.type == LFS3_TYPE_DIR); assert(info_.size == 0); - lfsr_dir_read(&lfs, &dir_, &info_) => 0; + lfs3_dir_read(&lfs3, &dir_, &info_) => 0; assert(strcmp(info_.name, "..") == 0); - assert(info_.type == LFS_TYPE_DIR); + assert(info_.type == LFS3_TYPE_DIR); assert(info_.size == 0); while (true) { - err = lfsr_dir_read(&lfs, &dir_, &info_); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + err = lfs3_dir_read(&lfs3, &dir_, &info_); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } assert(strlen(info_.name) == strlen("amethyst...")); assert(memcmp( info_.name, "amethyst", strlen("amethyst")) == 0); - assert(info_.type == LFS_TYPE_REG); + assert(info_.type == LFS3_TYPE_REG); assert(info_.size == SIZE); // at least try to read the files sprintf(name, "test/%s/%s", info.name, info_.name); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; // all data should be lowercase ascii - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { assert(rbuf[j] >= 'a' && rbuf[j] <= 'z'); } // sum should be equal to 'a' mod 26 uint8_t ck = 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { ck = (ck + (rbuf[j] - 'a')) % 26; } assert(ck == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_dir_close(&lfs, &dir_) => 0; + lfs3_dir_close(&lfs3, &dir_) => 0; } - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_stickynotes.toml b/tests/test_stickynotes.toml index edaf366b..05c25a67 100644 --- a/tests/test_stickynotes.toml +++ b/tests/test_stickynotes.toml @@ -13,206 +13,207 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // check that the file doesn't _really_ exist - lfs_t lfs_; - lfsr_mount(&lfs_, LFS_M_RDONLY, CFG) => 0; + lfs3_t lfs3_; + lfs3_mount(&lfs3_, LFS3_M_RDONLY, CFG) => 0; // via stat - struct lfs_info info; - lfsr_stat(&lfs_, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3_, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_unmount(&lfs_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_unmount(&lfs3_) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // check that the file still doesn't _really_ exist - lfsr_mount(&lfs_, LFS_M_RDONLY, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDONLY, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3_, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_unmount(&lfs_) => 0; + lfs3_file_open(&lfs3_, &file_, + "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_unmount(&lfs3_) => 0; } if (SYNC) { // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // now it should show up - lfsr_mount(&lfs_, LFS_M_RDONLY, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDONLY, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => 0; + lfs3_stat(&lfs3_, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs_, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3_, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs_, &file_) => 0; - lfsr_unmount(&lfs_) => 0; + lfs3_file_close(&lfs3_, &file_) => 0; + lfs3_unmount(&lfs3_) => 0; } // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // now it should show up - lfsr_mount(&lfs_, LFS_M_RDONLY, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDONLY, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => 0; + lfs3_stat(&lfs3_, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs_, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3_, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs_, &file_) => 0; - lfsr_unmount(&lfs_) => 0; + lfs3_file_close(&lfs3_, &file_) => 0; + lfs3_unmount(&lfs3_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // should still be there - lfsr_mount(&lfs_, LFS_M_RDONLY, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDONLY, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => 0; + lfs3_stat(&lfs3_, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs_, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3_, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs_, &file_) => 0; - lfsr_unmount(&lfs_) => 0; + lfs3_file_close(&lfs3_, &file_) => 0; + lfs3_unmount(&lfs3_) => 0; ''' @@ -226,72 +227,72 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create a file // // note the excl flag - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || err == LFS_ERR_EXIST); + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || err == LFS3_ERR_EXIST); - if (err != LFS_ERR_EXIST) { + if (err != LFS3_ERR_EXIST) { // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // we should be able to read the file now - lfsr_file_open(&lfs, &file, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "batman", LFS3_O_RDONLY) => 0; uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // and after remounting - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test files don't exist until first sync/close, even under powerloss @@ -305,81 +306,81 @@ defines.N = 128 reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create N files - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { // note the excl flag char name[256]; sprintf(name, "batman%03x", j); - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL); - assert(!err || err == LFS_ERR_EXIST); + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL); + assert(!err || err == LFS3_ERR_EXIST); - if (err != LFS_ERR_EXIST) { + if (err != LFS3_ERR_EXIST) { // write to the file uint32_t prng = 42 + j; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // we should be able to read the files now - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "batman%03x", j); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t prng = 42 + j; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // and after remounting - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "batman%03x", j); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t prng = 42 + j; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test files only exist as stickynotes until first sync/close @@ -392,217 +393,217 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // uncommitted files appear as stickynotes // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } // but we should still recieve sync broadcasts on sync/close - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } if (SYNC) { // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file__) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file__) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_sync_rw] @@ -614,211 +615,211 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // open a second reference - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // uncommitted files appear as stickynotes // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // write to the second file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (SYNC) { // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close the second file - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_wdwr] @@ -830,344 +831,344 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // open a second reference - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // and a third for checking sync broadcasts - lfsr_file_t file___; - lfsr_file_open(&lfs, &file___, "batman", - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_t file___; + lfs3_file_open(&lfs3, &file___, "batman", + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // write to the first file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // uncommitted files appear as stickynotes // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // uncommitted files appear as stickynotes // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (SYNC) { // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close the second file - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // now sync the first file, this should overwrite what is written - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // and close, this shouldn't change anything // // note we must sync to clear the desync flag - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file___) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file___) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_open] @@ -1180,83 +1181,83 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the uncreat - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // our uncreat should have been overwritten - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_excl] @@ -1269,20 +1270,20 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // attempt to create a new file over the uncreat @@ -1290,78 +1291,78 @@ code = ''' // this errors, otherwise it's easy to create the same file twice // with excl, which would be super duper confusing for users // - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => LFS3_ERR_EXIST; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the excl file had no effect // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_mkdir] @@ -1374,96 +1375,96 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // attempt to mkdir // // this should fail because of the stickynote // - lfsr_mkdir(&lfs, "batman") => LFS_ERR_EXIST; + lfs3_mkdir(&lfs3, "batman") => LFS3_ERR_EXIST; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the excl file had no effect // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can remove stickynotes @@ -1477,68 +1478,68 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // remove the stickynote - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // the stickynote should be gone // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "catman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "catman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can rename stickynotes @@ -1552,93 +1553,93 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename the stickynote - lfsr_rename(&lfs, "batman", "catman") => 0; + lfs3_rename(&lfs3, "batman", "catman") => 0; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the stickynote survived the rename // via stat - struct lfs_info info; - lfsr_stat(&lfs, "catman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "catman", &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "catman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "catman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can rename stickynotes onto files @@ -1652,101 +1653,101 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreate - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // create another file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "catman", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "catman", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename the stickynote - lfsr_rename(&lfs, "batman", "catman") => 0; + lfs3_rename(&lfs3, "batman", "catman") => 0; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the stickynote survived the rename // via stat - struct lfs_info info; - lfsr_stat(&lfs, "catman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "catman", &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "catman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "catman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can rename stickynotes onto other files @@ -1760,107 +1761,107 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreate - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename the stickynote - lfsr_rename(&lfs, "batman", "catman") => 0; + lfs3_rename(&lfs3, "batman", "catman") => 0; // we should still be able to read our uncreate/file - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); - lfsr_file_rewind(&lfs, &file) => 0; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the stickynote survived the rename // via stat - struct lfs_info info; - lfsr_stat(&lfs, "catman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "catman", &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "catman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "catman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can rename files onto stickynotes @@ -1874,107 +1875,107 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreate - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename onto the stickynote - lfsr_rename(&lfs, "catman", "batman") => 0; + lfs3_rename(&lfs3, "catman", "batman") => 0; // we should still be able to read our uncreate/file - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); - lfsr_file_rewind(&lfs, &file) => 0; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &file) => 0; + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // test that the file replaced the stickynote // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test we can rename stickynotes onto other stickynotes @@ -1988,107 +1989,107 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreate - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // create another uncreate - lfsr_file_t uncreat_; - lfsr_file_open(&lfs, &uncreat_, "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat_, "WoO~", strlen("WoO~")) + lfs3_file_t uncreat_; + lfs3_file_open(&lfs3, &uncreat_, "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat_, "WoO~", strlen("WoO~")) => strlen("WoO~"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename the stickynote - lfsr_rename(&lfs, "batman", "catman") => 0; + lfs3_rename(&lfs3, "batman", "catman") => 0; // we should still be able to read our uncreates - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); - lfsr_file_rewind(&lfs, &uncreat_) => 0; - lfsr_file_read(&lfs, &uncreat_, rbuf, sizeof(rbuf)) + lfs3_file_rewind(&lfs3, &uncreat_) => 0; + lfs3_file_read(&lfs3, &uncreat_, rbuf, sizeof(rbuf)) => strlen("WoO~"); assert(memcmp(rbuf, "WoO~", strlen("WoO~")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; - lfsr_file_close(&lfs, &uncreat_) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat_) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the stickynote survived the rename // via stat - struct lfs_info info; - lfsr_stat(&lfs, "catman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "catman", &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "catman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "catman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "catman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; - lfsr_file_close(&lfs, &uncreat_) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat_) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test renaming a stickynote onto itself does nothing @@ -2102,93 +2103,93 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreate - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename the stickynote - lfsr_rename(&lfs, "batman", "batman") => 0; + lfs3_rename(&lfs3, "batman", "batman") => 0; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the stickynote survived the rename // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_not_dir] @@ -2201,105 +2202,105 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // attempt to rename a dir onto the stickynote // // this should fail because of the stickynote // - lfsr_mkdir(&lfs, "datman") => 0; - lfsr_rename(&lfs, "datman", "batman") => LFS_ERR_NOTDIR; + lfs3_mkdir(&lfs3, "datman") => 0; + lfs3_rename(&lfs3, "datman", "batman") => LFS3_ERR_NOTDIR; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the mkdir had no effect // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_stat(&lfs, "datman", &info) => 0; + lfs3_stat(&lfs3, "datman", &info) => 0; assert(strcmp(info.name, "datman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "datman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_not_stickynote] @@ -2312,105 +2313,105 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // attempt to rename the stickynote onto a dir // // this should fail because of the stickynote // - lfsr_mkdir(&lfs, "datman") => 0; - lfsr_rename(&lfs, "batman", "datman") => LFS_ERR_ISDIR; + lfs3_mkdir(&lfs3, "datman") => 0; + lfs3_rename(&lfs3, "batman", "datman") => LFS3_ERR_ISDIR; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the mkdir had no effect // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_stat(&lfs, "datman", &info) => 0; + lfs3_stat(&lfs3, "datman", &info) => 0; assert(strcmp(info.name, "datman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "datman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_not_root] @@ -2423,20 +2424,20 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // attempt to rename the stickynote onto the root @@ -2446,76 +2447,76 @@ code = ''' // well, because of the root really, but also because of the // stickynote // - lfsr_rename(&lfs, "batman", "/") => LFS_ERR_INVAL; + lfs3_rename(&lfs3, "batman", "/") => LFS3_ERR_INVAL; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the mkdir had no effect // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_uncreat_not_noent] @@ -2528,20 +2529,20 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // attempt to rename the stickynote onto an invalid path @@ -2551,76 +2552,76 @@ code = ''' // well, because of the invalid path really, but also because of the // stickynote // - lfsr_rename(&lfs, "batman", "no/batman") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "batman", "no/batman") => LFS3_ERR_NOENT; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the mkdir had no effect // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (CLOSE == 1) { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("WoOoOoOoOoO")); } else { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; if (CLOSE == 1) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -2634,208 +2635,209 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // check that the file doesn't _really_ exist - lfs_t lfs_; - lfsr_mount(&lfs_, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3_; + lfs3_mount(&lfs3_, LFS3_M_RDWR, CFG) => 0; // via stat - struct lfs_info info; - lfsr_stat(&lfs_, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3_, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_unmount(&lfs_) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_unmount(&lfs3_) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // check that the file still doesn't _really_ exist - lfsr_mount(&lfs_, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDWR, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3_, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfsr_unmount(&lfs_) => 0; + lfs3_file_open(&lfs3_, &file_, + "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; + lfs3_unmount(&lfs3_) => 0; } if (SYNC) { // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // now it should show up - lfsr_mount(&lfs_, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDWR, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => 0; + lfs3_stat(&lfs3_, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs_, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3_, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs_, &file_) => 0; - lfsr_unmount(&lfs_) => 0; + lfs3_file_close(&lfs3_, &file_) => 0; + lfs3_unmount(&lfs3_) => 0; } // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // now it should show up - lfsr_mount(&lfs_, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDWR, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => 0; + lfs3_stat(&lfs3_, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs_, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3_, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs_, &file_) => 0; - lfsr_unmount(&lfs_) => 0; + lfs3_file_close(&lfs3_, &file_) => 0; + lfs3_unmount(&lfs3_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; // should still be there - lfsr_mount(&lfs_, LFS_M_RDWR, CFG) => 0; + lfs3_mount(&lfs3_, LFS3_M_RDWR, CFG) => 0; // via stat - lfsr_stat(&lfs_, "batman", &info) => 0; + lfs3_stat(&lfs3_, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs_, &dir, "/") => 0; - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_open(&lfs3_, &dir, "/") => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs_, &dir, &info) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs_, &dir) => 0; + lfs3_dir_read(&lfs3_, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3_, &dir) => 0; // via open - lfsr_file_open(&lfs_, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3_, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs_, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3_, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs_, &file_) => 0; - lfsr_unmount(&lfs_) => 0; + lfs3_file_close(&lfs3_, &file_) => 0; + lfs3_unmount(&lfs3_) => 0; ''' # test desync files don't exist until first sync + close, even under powerloss @@ -2848,74 +2850,74 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create a desync file // // note the excl flag - lfsr_file_t file; - err = lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC); - assert(!err || err == LFS_ERR_EXIST); + lfs3_file_t file; + err = lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC); + assert(!err || err == LFS3_ERR_EXIST); - if (err != LFS_ERR_EXIST) { + if (err != LFS3_ERR_EXIST) { // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // we should be able to read the file now - lfsr_file_open(&lfs, &file, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "batman", LFS3_O_RDONLY) => 0; uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // and after remounting - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test desync files don't exist until first sync + close, even under powerloss @@ -2929,89 +2931,89 @@ defines.N = 128 reentrant = true code = ''' // format once per test - lfs_t lfs; - int err = lfsr_mount(&lfs, LFS_M_RDWR, CFG); + lfs3_t lfs3; + int err = lfs3_mount(&lfs3, LFS3_M_RDWR, CFG); if (err) { - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // create N desync files - lfsr_file_t files[N]; + lfs3_file_t files[N]; bool exists[N]; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { // note the excl flag char name[256]; sprintf(name, "batman%03x", j); - err = lfsr_file_open(&lfs, &files[j], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC); - assert(!err || err == LFS_ERR_EXIST); + err = lfs3_file_open(&lfs3, &files[j], name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC); + assert(!err || err == LFS3_ERR_EXIST); - exists[j] = (err == LFS_ERR_EXIST); + exists[j] = (err == LFS3_ERR_EXIST); if (!exists[j]) { // write to the file uint32_t prng = 42 + j; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[j], wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &files[j], wbuf, CHUNK) => CHUNK; } } } // sync and close - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { if (!exists[j]) { // sync the file - lfsr_file_sync(&lfs, &files[j]) => 0; + lfs3_file_sync(&lfs3, &files[j]) => 0; // close the file - lfsr_file_close(&lfs, &files[j]) => 0; + lfs3_file_close(&lfs3, &files[j]) => 0; } } // we should be able to read the files now - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "batman%03x", j); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t prng = 42 + j; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // and after remounting - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - for (lfs_size_t j = 0; j < N; j++) { + for (lfs3_size_t j = 0; j < N; j++) { char name[256]; sprintf(name, "batman%03x", j); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t prng = 42 + j; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test desync files aren't even openable until first sync + close @@ -3024,204 +3026,206 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // as far as the filesystem is concerned, the file does not exist yet // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // as far as the filesystem is concerned, the file does not exist yet // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, + "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, + "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; } // but we should still recieve sync broadcasts on sync + close - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } if (SYNC) { // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // sync the file - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // close the file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file__) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file__) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_undesync_sync_rw] @@ -3233,213 +3237,213 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // open a second desync reference - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_DESYNC) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_DESYNC) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // uncommitted files appear as stickynotes // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // write to the second file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (SYNC) { // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // close the second file - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_undesync_wdwr] @@ -3451,345 +3455,345 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // open a second desync reference - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // and a third for checking sync broadcasts - lfsr_file_t file___; - lfsr_file_open(&lfs, &file___, "batman", - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_t file___; + lfs3_file_open(&lfs3, &file___, "batman", + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // write to the first file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (SYNC) { // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // close the second file - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // now sync the first file, this should overwrite what is written - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // now it should show up // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // and close, this shouldn't change anything // // note we must sync to clear the desync flag - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file___) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file___) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_undesync_open] @@ -3802,83 +3806,83 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desynced uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the uncreat - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_undesync_excl] @@ -3891,93 +3895,93 @@ defines.REMOUNT = [0, 1] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desynced uncreat - lfsr_file_t uncreat; - lfsr_file_open(&lfs, &uncreat, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &uncreat, + lfs3_file_t uncreat; + lfs3_file_open(&lfs3, &uncreat, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &uncreat, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the uncreat // // while it's still possible for the desynced uncreat to create the - // file by explicitly calling lfsr_file_sync, for the most part we + // file by explicitly calling lfs3_file_sync, for the most part we // treat desynced files like zombies and allow excl creates // - // this makes lfsr_file_sync/resync roughly the same as opening the + // this makes lfs3_file_sync/resync roughly the same as opening the // file after the excl create succeeds, and if you're using desynced // files you should probably be aware of littlefs's snapshot model // anyways // - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // we should still be able to read our uncreat - lfsr_file_rewind(&lfs, &uncreat) => 0; + lfs3_file_rewind(&lfs3, &uncreat) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &uncreat, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &uncreat, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &uncreat) => 0; + lfs3_file_close(&lfs3, &uncreat) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -3992,120 +3996,122 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // as far as the filesystem is concerned, the file does not exist yet // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, + "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, + "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // because the file was desynced, it should still not exist // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // even after a remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // because the file was desynced, it should still not exist // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_wdwr] @@ -4117,301 +4123,301 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' # SYNC=0x1 => sync before orphaning # SYNC=0x2 => sync after orphaning defines.SYNC = [0, 1, 2, 3] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; // open a second reference - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // and a third for checking sync broadcasts - lfsr_file_t file___; - lfsr_file_open(&lfs, &file___, "batman", - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_t file___; + lfs3_file_open(&lfs3, &file___, "batman", + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // write to the first file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (SYNC & 0x1) { // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close the first file, this should do nothing but discard the // file contents - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (SYNC & 0x2) { // sync the second file - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close the second file - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // now it should show up // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // recieved sync broadcast? - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file___) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file___) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_unrelated] @@ -4426,218 +4432,218 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create N orphans - lfsr_file_t orphans[N]; - for (lfs_size_t o = 0; o < N; o++) { + lfs3_file_t orphans[N]; + for (lfs3_size_t o = 0; o < N; o++) { char name[256]; sprintf(name, "aatman%03x", o); - lfsr_file_open(&lfs, &orphans[o], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[o], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; uint32_t prng = 42+o; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &orphans[o], wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &orphans[o], wbuf, CHUNK) => CHUNK; } } // and an unrelated file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint32_t prng = 52; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // as far as the filesystem is concerned, none of the orphans exist // via stat - struct lfs_info info; - for (lfs_size_t o = 0; o < N; o++) { + struct lfs3_info info; + for (lfs3_size_t o = 0; o < N; o++) { char name[256]; sprintf(name, "aatman%03x", o); - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; + lfs3_file_t file_; uint8_t rbuf[CHUNK]; - for (lfs_size_t o = 0; o < N; o++) { + for (lfs3_size_t o = 0; o < N; o++) { char name[256]; sprintf(name, "aatman%03x", o); // rdonly rejected - lfsr_file_open(&lfs, &file_, name, LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, name, LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, name, LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, name, LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, name, LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, name, LFS3_O_RDWR) => LFS3_ERR_NOENT; } - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // but we should still be able to read our orphans - for (lfs_size_t o = 0; o < N; o++) { - lfsr_file_rewind(&lfs, &orphans[o]) => 0; + for (lfs3_size_t o = 0; o < N; o++) { + lfs3_file_rewind(&lfs3, &orphans[o]) => 0; prng = 42+o; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &orphans[o], rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &orphans[o], rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 52; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close M orphans - for (lfs_size_t o = 0; o < M && o < N; o++) { - lfsr_file_close(&lfs, &orphans[o]) => 0; + for (lfs3_size_t o = 0; o < M && o < N; o++) { + lfs3_file_close(&lfs3, &orphans[o]) => 0; } // create a new unrelated file, this should trigger // and orphan cleanup - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; prng = 62; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } - lfsr_file_close(&lfs, &file__); + lfs3_file_close(&lfs3, &file__); // and now close our original unrelated file - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // and close the remaining orphans - for (lfs_size_t o = M; o < N; o++) { - lfsr_file_close(&lfs, &orphans[o]) => 0; + for (lfs3_size_t o = M; o < N; o++) { + lfs3_file_close(&lfs3, &orphans[o]) => 0; } // now our file should exist, but none of our orphans // via stat - for (lfs_size_t o = 0; o < N; o++) { + for (lfs3_size_t o = 0; o < N; o++) { char name[256]; sprintf(name, "aatman%03x", o); - lfsr_stat(&lfs, name, &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, name, &info) => LFS3_ERR_NOENT; } - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, "catman", &info) => 0; + lfs3_stat(&lfs3, "catman", &info) => 0; assert(strcmp(info.name, "catman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "catman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - for (lfs_size_t o = 0; o < N; o++) { + for (lfs3_size_t o = 0; o < N; o++) { char name[256]; sprintf(name, "aatman%03x", o); // rdonly rejected - lfsr_file_open(&lfs, &file_, name, LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, name, LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, name, LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, name, LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, name, LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, name, LFS3_O_RDWR) => LFS3_ERR_NOENT; } - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 52; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; - lfsr_file_open(&lfs, &file_, "catman", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "catman", LFS3_O_RDONLY) => 0; prng = 62; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_open] @@ -4648,95 +4654,98 @@ defines.ORPHANS = [1, 2, 3, 100] defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create neighboring orphaned files // // more orphans requires different techniques for cleaning up orphans - lfsr_file_t orphans[ORPHANS-1]; - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_t orphans[ORPHANS-1]; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { char name[256]; sprintf(name, "aatman%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &orphans[i], + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &orphans[i], "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // create an orphaned file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &file, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // close all orphans at once, or else the open calls would just // clean up each orphans - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the orphan - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_excl] @@ -4747,99 +4756,102 @@ defines.ORPHANS = [1, 2, 3, 100] defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create neighboring orphaned files // // more orphans requires different techniques for cleaning up orphans - lfsr_file_t orphans[ORPHANS-1]; - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_t orphans[ORPHANS-1]; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { char name[256]; sprintf(name, "aatman%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &orphans[i], + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &orphans[i], "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // create an orphaned file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &file, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // close all orphans at once, or else the open calls would just // clean up each orphans - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the zombie // - // orphaned files will never exist again, so LFS_O_EXCL should not + // orphaned files will never exist again, so LFS3_O_EXCL should not // fail here // - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_mkdir] @@ -4850,84 +4862,87 @@ defines.ORPHANS = [1, 2, 3, 100] defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create neighboring orphaned files // // more orphans requires different techniques for cleaning up orphans - lfsr_file_t orphans[ORPHANS-1]; - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_t orphans[ORPHANS-1]; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { char name[256]; sprintf(name, "aatman%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &orphans[i], + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &orphans[i], "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // create an orphaned file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &file, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // close all orphans at once, or else the open calls would just // clean up each orphans - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new dir over the orphan - lfsr_mkdir(&lfs, "batman") => 0; + lfs3_mkdir(&lfs3, "batman") => 0; if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new dir is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_rm] @@ -4938,77 +4953,80 @@ defines.ORPHANS = [1, 2, 3, 100] defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create neighboring orphaned files // // more orphans requires different techniques for cleaning up orphans - lfsr_file_t orphans[ORPHANS-1]; - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_t orphans[ORPHANS-1]; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { char name[256]; sprintf(name, "aatman%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &orphans[i], + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &orphans[i], "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // create an orphaned file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &file, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // close all orphans at once, or else the open calls would just // clean up each orphans - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // orphans aren't real, so remove should fail - lfsr_remove(&lfs, "batman") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "batman") => LFS3_ERR_NOENT; if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // just make sure things look ok // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_mv_dst] @@ -5022,149 +5040,153 @@ defines.ORPHANS = [1, 2, 3, 100] defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // make our src file before orphans, otherwise open just cleans // things up if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "a/datman" : "datman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "a/datman" : "datman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/datman" : "datman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/datman" : "datman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create neighboring orphaned files // // more orphans requires different techniques for cleaning up orphans - lfsr_file_t orphans[ORPHANS-1]; - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_t orphans[ORPHANS-1]; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { char name[256]; sprintf(name, (INTERDIR) ? "c/aatman%03x" : "aatman%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &orphans[i], + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &orphans[i], "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // create an orphaned file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &file, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // close all orphans at once, or else the open calls would just // clean up each orphans - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename onto orphan - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "a/datman" : "datman", (INTERDIR) ? "c/batman" : "batman") => 0; if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "c/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "c/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } - lfsr_stat(&lfs, (INTERDIR) ? "a/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "a/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "c" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "c" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open if (DIR) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "c/batman" : "batman", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "c/batman" : "batman", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; } else { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "c/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "c/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_orphan_mv_src] @@ -5175,78 +5197,81 @@ defines.ORPHANS = [1, 2, 3, 100] defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create neighboring orphaned files // // more orphans requires different techniques for cleaning up orphans - lfsr_file_t orphans[ORPHANS-1]; - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_t orphans[ORPHANS-1]; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { char name[256]; sprintf(name, "aatman%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &orphans[i], + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &orphans[i], "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // create an orphaned file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; - lfsr_file_write(&lfs, &file, + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; + lfs3_file_write(&lfs3, &file, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); // close all orphans at once, or else the open calls would just // clean up each orphans - for (lfs_size_t i = 0; i < ORPHANS-1; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS-1; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // orphans aren't real, so rename should fail - lfsr_rename(&lfs, "batman", "catman") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "batman", "catman") => LFS3_ERR_NOENT; if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // just make sure things look ok // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "catman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "catman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -5261,130 +5286,130 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // need to sync so we can remove - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // as far as the filesystem is concerned, the file does not exist yet // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // syncing removed files is a noop - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // resyncing removed files is an error - lfsr_file_resync(&lfs, &file) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file) => LFS3_ERR_NOENT; // but we should still be able to read our file handle - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // because the file was removed, it should still not exist // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // even after a remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_posthumous] @@ -5396,130 +5421,130 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // need to sync so we can remove - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // as far as the filesystem is concerned, the file does not exist yet // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // syncing removed files is a noop - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // resyncing removed files is an error - lfsr_file_resync(&lfs, &file) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file) => LFS3_ERR_NOENT; // but we should still be able to read our file handle - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // because the file was removed, it should still not exist // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // even after a remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_rwrw] @@ -5531,256 +5556,256 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // need to sync so we can remove - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // as far as the filesystem is concerned, this file does not exist anymore // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // create a second file - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // syncing removed files is a noop - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // resyncing removed files is an error - lfsr_file_resync(&lfs, &file) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file) => LFS3_ERR_NOENT; // syncing our second file should actually sync - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // second file should appear on disk now // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // the perhaps surprising thing is we should still be able // to read both file handles - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // check disk again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check disk again again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_rwrw_posthumous] @@ -5792,256 +5817,256 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // need to sync so we can remove - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // as far as the filesystem is concerned, this file does not exist anymore // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // create a second file - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the second file uint32_t prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } // write to the first file prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // syncing removed files is a noop - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // resyncing removed files is an error - lfsr_file_resync(&lfs, &file) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file) => LFS3_ERR_NOENT; // syncing our second file should actually sync - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // second file should appear on disk now // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // the perhaps surprising thing is we should still be able // to read both file handles - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_close(&lfs, &file__) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_close(&lfs3, &file__) => 0; // check disk again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check disk again again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_zombie_rwrwrw] @@ -6053,313 +6078,313 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // need to sync so we can remove - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // as far as the filesystem is concerned, this file does not exist anymore // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // create a second file - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } // need to sync so we can remove - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // still doesn't exist // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // create a third file - lfsr_file_t file___; - lfsr_file_open(&lfs, &file___, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file___; + lfs3_file_open(&lfs3, &file___, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the third file prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file___, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file___, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // syncing removed files is a noop - lfsr_file_sync(&lfs, &file) => 0; - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // resyncing removed files is an error - lfsr_file_resync(&lfs, &file) => LFS_ERR_NOENT; - lfsr_file_resync(&lfs, &file__) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file) => LFS3_ERR_NOENT; + lfs3_file_resync(&lfs3, &file__) => LFS3_ERR_NOENT; // syncing our third file should actually sync - lfsr_file_sync(&lfs, &file___) => 0; + lfs3_file_sync(&lfs3, &file___) => 0; // third file should appear on disk now // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // the perhaps surprising thing is we should still be able // to read all file handles - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_close(&lfs, &file__) => 0; - lfsr_file_close(&lfs, &file___) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_close(&lfs3, &file__) => 0; + lfs3_file_close(&lfs3, &file___) => 0; // check disk again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check disk again again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_zombie_rwrwrw_posthumous] @@ -6371,313 +6396,313 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // need to sync so we can remove - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // as far as the filesystem is concerned, this file does not exist anymore // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // create a second file - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // need to sync so we can remove - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; // still doesn't exist // via stat - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // rdonly rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => LFS3_ERR_NOENT; // non-create rejected - lfsr_file_open(&lfs, &file_, "batman", LFS_O_WRONLY) => LFS_ERR_NOENT; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDWR) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_WRONLY) => LFS3_ERR_NOENT; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDWR) => LFS3_ERR_NOENT; // create a third file - lfsr_file_t file___; - lfsr_file_open(&lfs, &file___, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file___; + lfs3_file_open(&lfs3, &file___, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the third file uint32_t prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file___, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file___, wbuf, CHUNK) => CHUNK; } // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } // write to the first file prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // still appears as a stickynote // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open uint8_t rbuf[CHUNK]; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // syncing removed files is a noop - lfsr_file_sync(&lfs, &file) => 0; - lfsr_file_sync(&lfs, &file__) => 0; + lfs3_file_sync(&lfs3, &file) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; // resyncing removed files is an error - lfsr_file_resync(&lfs, &file) => LFS_ERR_NOENT; - lfsr_file_resync(&lfs, &file__) => LFS_ERR_NOENT; + lfs3_file_resync(&lfs3, &file) => LFS3_ERR_NOENT; + lfs3_file_resync(&lfs3, &file__) => LFS3_ERR_NOENT; // syncing our third file should actually sync - lfsr_file_sync(&lfs, &file___) => 0; + lfs3_file_sync(&lfs3, &file___) => 0; // third file should appear on disk now // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // the perhaps surprising thing is we should still be able // to read all file handles - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file___) => 0; + lfs3_file_rewind(&lfs3, &file___) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file___, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file___, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; - lfsr_file_close(&lfs, &file__) => 0; - lfsr_file_close(&lfs, &file___) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_file_close(&lfs3, &file__) => 0; + lfs3_file_close(&lfs3, &file___) => 0; // check disk again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check disk again again // via stat - lfsr_stat(&lfs, "batman", &info) => 0; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // via readdir - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; prng = 42+2; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_open] @@ -6693,103 +6718,103 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, "batman") => 0; if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the zombie - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_excl] @@ -6805,107 +6830,107 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, "batman") => 0; if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new file over the zombie // - // zombie files will never exist again, so LFS_O_EXCL should not + // zombie files will never exist again, so LFS3_O_EXCL should not // fail here // - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, "batman", LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, "batman", LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_mkdir] @@ -6921,91 +6946,91 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, "batman") => 0; if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // create a new dir over the zombie - lfsr_mkdir(&lfs, "batman") => 0; + lfs3_mkdir(&lfs3, "batman") => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new dir is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_rm] @@ -7021,84 +7046,84 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, "batman") => 0; if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // zombies aren't real, so remove should fail - lfsr_remove(&lfs, "batman") => LFS_ERR_NOENT; + lfs3_remove(&lfs3, "batman") => LFS3_ERR_NOENT; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // just make sure things look ok // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_mv_dst] @@ -7117,155 +7142,156 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // make our src file before zombies, just in case if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "c/datman" : "datman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "c/datman" : "datman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, (INTERDIR) ? "a/batman" : "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, (INTERDIR) ? "a/batman" : "batman") => 0; if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename onto zombie - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } - lfsr_stat(&lfs, (INTERDIR) ? "a/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "a/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open if (DIR) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; } else { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombie_mv_src] @@ -7281,85 +7307,85 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, "batman") => 0; if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // zombies aren't real, so rename should fail - lfsr_rename(&lfs, "batman", "catman") => LFS_ERR_NOENT; + lfs3_rename(&lfs3, "batman", "catman") => LFS3_ERR_NOENT; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // just make sure things look ok // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; - lfsr_stat(&lfs, "catman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; + lfs3_stat(&lfs3, "catman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -7372,16 +7398,16 @@ defines.REMOUNT = [false, true] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a desync file, not a zombie yet - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } @@ -7389,61 +7415,61 @@ code = ''' // use mkdir on the same name, the file hasn't been created yet, // so this shouldn't fail, but because we have an open file handle // we create a zombie - lfsr_mkdir(&lfs, "batman") => 0; + lfs3_mkdir(&lfs3, "batman") => 0; if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new dir is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; if (!CLOSE) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_zombify_mv_dst] @@ -7460,145 +7486,146 @@ if = [ '!DIR || ORPHAN', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // make our src file before zombies, just in case if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "c/datman" : "datman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "c/datman" : "datman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a desync file, not a zombie yet - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL | LFS3_O_DESYNC) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } if (!ORPHAN) { - lfsr_file_sync(&lfs, &zombie) => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; } // rename onto the same name, this shouldn't fail (note the test // conditions), but because we have an open file handle we create // a zombie - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } - lfsr_stat(&lfs, (INTERDIR) ? "a/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "a/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open if (DIR) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; } else { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (!CLOSE) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_fileonzombie_rm] @@ -7615,96 +7642,96 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, "batman") => 0; // create a file on top of the zombie if (DIR) { - lfsr_mkdir(&lfs, "batman") => 0; + lfs3_mkdir(&lfs3, "batman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // remove the file - lfsr_remove(&lfs, "batman") => 0; + lfs3_remove(&lfs3, "batman") => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // just make sure things look ok // via stat - struct lfs_info info; - lfsr_stat(&lfs, "batman", &info) => LFS_ERR_NOENT; + struct lfs3_info info; + lfs3_stat(&lfs3, "batman", &info) => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_fileonzombie_mv_dst] @@ -7723,167 +7750,168 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // make our src file before zombies, just in case if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "c/datman" : "datman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "c/datman" : "datman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, (INTERDIR) ? "a/batman" : "batman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, (INTERDIR) ? "a/batman" : "batman") => 0; // create a file on top of the zombie if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "a/batman" : "batman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "a/batman" : "batman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename onto the file - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our zombie - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } - lfsr_stat(&lfs, (INTERDIR) ? "a/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "a/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open if (DIR) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; } else { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -7904,11 +7932,11 @@ defines.N = [0, 1, 2, 3, 10, 100] defines.REMOUNT = [false, true] defines.BOOKENDS = [0x0, 0x1, 0x2, 0x3] if = '(SIZE*N)/BLOCK_SIZE <= 32' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; @@ -7916,31 +7944,31 @@ code = ''' // doesn't break other filesystem things uint32_t bookend_prngs[2] = {0, 0}; if (BOOKENDS & 0x1) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "aatman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "aatman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[0] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } if (BOOKENDS & 0x2) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "catman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "catman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[1] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // create this many orphaned files @@ -7950,85 +7978,88 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "batman%03x", i); - lfsr_file_open(&lfs, &files[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } // remount? this has no effect on orphans if (REMOUNT) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - // calling lfsr_fs_mkconsistent should clean things up - lfsr_fs_mkconsistent(&lfs) => 0; + // calling lfs3_fs_mkconsistent should clean things up + lfs3_fs_mkconsistent(&lfs3) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_MKCONSISTENT)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_MKCONSISTENT)); // double check the actual disk state, it's easy for littlefs to // lie here - assert(lfsr_mtree_weight(&lfs) - <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); + assert(lfs3_mtree_weight(&lfs3) + <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits)); + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS)); // check that other files are unaffected for (int remount = 0; remount < 2; remount++) { if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (BOOKENDS & 0x1) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "aatman", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "aatman", LFS3_O_RDONLY) => 0; uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file); + lfs3_file_close(&lfs3, &file); } if (BOOKENDS & 0x2) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "catman", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "catman", LFS3_O_RDONLY) => 0; uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file); + lfs3_file_close(&lfs3, &file); } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_cleanup_open] @@ -8045,11 +8076,11 @@ defines.SIZE = [ defines.N = [0, 1, 2, 3, 10, 100] defines.BOOKENDS = [0x0, 0x1, 0x2, 0x3] if = '(SIZE*N)/BLOCK_SIZE <= 32' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; @@ -8057,32 +8088,32 @@ code = ''' // orphans doesn't break other filesystem things // // note we leave these open in this test - lfsr_file_t bookend_files[2]; + lfs3_file_t bookend_files[2]; uint32_t bookend_prngs[2] = {0, 0}; if (BOOKENDS & 0x1) { - lfsr_file_open(&lfs, &bookend_files[0], "aatman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &bookend_files[0], "aatman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[0] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &bookend_files[0], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &bookend_files[0]) => 0; + lfs3_file_write(&lfs3, &bookend_files[0], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &bookend_files[0]) => 0; } if (BOOKENDS & 0x2) { - lfsr_file_open(&lfs, &bookend_files[1], "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &bookend_files[1], "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[1] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &bookend_files[1], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &bookend_files[1]) => 0; + lfs3_file_write(&lfs3, &bookend_files[1], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &bookend_files[1]) => 0; } // create this many orphaned files @@ -8092,95 +8123,98 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "batman%03x", i); - lfsr_file_open(&lfs, &files[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } - // calling lfsr_fs_mkconsistent should clean things up - lfsr_fs_mkconsistent(&lfs) => 0; + // calling lfs3_fs_mkconsistent should clean things up + lfs3_fs_mkconsistent(&lfs3) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_MKCONSISTENT)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_MKCONSISTENT)); // double check the actual disk state, it's easy for littlefs to // lie here - assert(lfsr_mtree_weight(&lfs) - <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); + assert(lfs3_mtree_weight(&lfs3) + <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits)); + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS)); // check that other files are unaffected for (int remount = 0; remount < 2; remount++) { if (remount) { if (BOOKENDS & 0x1) { - lfsr_file_close(&lfs, &bookend_files[0]) => 0; + lfs3_file_close(&lfs3, &bookend_files[0]) => 0; } if (BOOKENDS & 0x2) { - lfsr_file_close(&lfs, &bookend_files[1]) => 0; + lfs3_file_close(&lfs3, &bookend_files[1]) => 0; } - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (BOOKENDS & 0x1) { - lfsr_file_open(&lfs, &bookend_files[0], "aatman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &bookend_files[0], "aatman", + LFS3_O_RDONLY) => 0; } if (BOOKENDS & 0x2) { - lfsr_file_open(&lfs, &bookend_files[1], "catman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &bookend_files[1], "catman", + LFS3_O_RDONLY) => 0; } } if (BOOKENDS & 0x1) { - lfsr_file_rewind(&lfs, &bookend_files[0]) => 0; + lfs3_file_rewind(&lfs3, &bookend_files[0]) => 0; uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &bookend_files[0], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &bookend_files[0], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } if (BOOKENDS & 0x2) { - lfsr_file_rewind(&lfs, &bookend_files[1]) => 0; + lfs3_file_rewind(&lfs3, &bookend_files[1]) => 0; uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &bookend_files[1], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &bookend_files[1], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } if (BOOKENDS & 0x1) { - lfsr_file_close(&lfs, &bookend_files[0]); + lfs3_file_close(&lfs3, &bookend_files[0]); } if (BOOKENDS & 0x2) { - lfsr_file_close(&lfs, &bookend_files[1]); + lfs3_file_close(&lfs3, &bookend_files[1]); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_cleanup_uncreat] @@ -8197,11 +8231,11 @@ defines.SIZE = [ defines.N = [0, 1, 2, 3, 10, 100] defines.BOOKENDS = [0x0, 0x1, 0x2, 0x3] if = '(SIZE*N)/BLOCK_SIZE <= 32' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; @@ -8209,30 +8243,30 @@ code = ''' // orphans doesn't break other filesystem things // // note we leave these uncreated + open in this test - lfsr_file_t bookend_files[2]; + lfs3_file_t bookend_files[2]; uint32_t bookend_prngs[2] = {0, 0}; if (BOOKENDS & 0x1) { - lfsr_file_open(&lfs, &bookend_files[0], "aatman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &bookend_files[0], "aatman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[0] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &bookend_files[0], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &bookend_files[0], wbuf, SIZE) => SIZE; } if (BOOKENDS & 0x2) { - lfsr_file_open(&lfs, &bookend_files[1], "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &bookend_files[1], "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[1] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &bookend_files[1], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &bookend_files[1], wbuf, SIZE) => SIZE; } // create this many orphaned files @@ -8242,95 +8276,98 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "batman%03x", i); - lfsr_file_open(&lfs, &files[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } - // calling lfsr_fs_mkconsistent should clean things up - lfsr_fs_mkconsistent(&lfs) => 0; + // calling lfs3_fs_mkconsistent should clean things up + lfs3_fs_mkconsistent(&lfs3) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_MKCONSISTENT)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_MKCONSISTENT)); // double check the actual disk state, it's easy for littlefs to // lie here - assert(lfsr_mtree_weight(&lfs) - <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); + assert(lfs3_mtree_weight(&lfs3) + <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits)); + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS)); // check that other files are unaffected for (int remount = 0; remount < 2; remount++) { if (remount) { if (BOOKENDS & 0x1) { - lfsr_file_close(&lfs, &bookend_files[0]) => 0; + lfs3_file_close(&lfs3, &bookend_files[0]) => 0; } if (BOOKENDS & 0x2) { - lfsr_file_close(&lfs, &bookend_files[1]) => 0; + lfs3_file_close(&lfs3, &bookend_files[1]) => 0; } - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; if (BOOKENDS & 0x1) { - lfsr_file_open(&lfs, &bookend_files[0], "aatman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &bookend_files[0], "aatman", + LFS3_O_RDONLY) => 0; } if (BOOKENDS & 0x2) { - lfsr_file_open(&lfs, &bookend_files[1], "catman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &bookend_files[1], "catman", + LFS3_O_RDONLY) => 0; } } if (BOOKENDS & 0x1) { - lfsr_file_rewind(&lfs, &bookend_files[0]) => 0; + lfs3_file_rewind(&lfs3, &bookend_files[0]) => 0; uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &bookend_files[0], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &bookend_files[0], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } if (BOOKENDS & 0x2) { - lfsr_file_rewind(&lfs, &bookend_files[1]) => 0; + lfs3_file_rewind(&lfs3, &bookend_files[1]) => 0; uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &bookend_files[1], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &bookend_files[1], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } if (BOOKENDS & 0x1) { - lfsr_file_close(&lfs, &bookend_files[0]); + lfs3_file_close(&lfs3, &bookend_files[0]); } if (BOOKENDS & 0x2) { - lfsr_file_close(&lfs, &bookend_files[1]); + lfs3_file_close(&lfs3, &bookend_files[1]); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_cleanup_zombie] @@ -8347,11 +8384,11 @@ defines.SIZE = [ defines.N = [0, 1, 2, 3, 10, 100] defines.BOOKENDS = [0x0, 0x1, 0x2, 0x3] if = '(SIZE*N)/BLOCK_SIZE <= 32' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; @@ -8359,36 +8396,36 @@ code = ''' // orphans doesn't break other filesystem things // // note we leave these zombied + open in this test - lfsr_file_t bookend_files[2]; + lfs3_file_t bookend_files[2]; uint32_t bookend_prngs[2] = {0, 0}; if (BOOKENDS & 0x1) { - lfsr_file_open(&lfs, &bookend_files[0], "aatman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &bookend_files[0], "aatman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[0] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &bookend_files[0], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &bookend_files[0]) => 0; + lfs3_file_write(&lfs3, &bookend_files[0], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &bookend_files[0]) => 0; - lfsr_remove(&lfs, "aatman") => 0; + lfs3_remove(&lfs3, "aatman") => 0; } if (BOOKENDS & 0x2) { - lfsr_file_open(&lfs, &bookend_files[1], "catman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &bookend_files[1], "catman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; bookend_prngs[1] = TEST_PRNG(&prng); uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } - lfsr_file_write(&lfs, &bookend_files[1], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &bookend_files[1]) => 0; + lfs3_file_write(&lfs3, &bookend_files[1], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &bookend_files[1]) => 0; - lfsr_remove(&lfs, "catman") => 0; + lfs3_remove(&lfs3, "catman") => 0; } // create this many orphaned files @@ -8398,74 +8435,77 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t files[N]; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_file_t files[N]; + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "batman%03x", i); - lfsr_file_open(&lfs, &files[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } - // calling lfsr_fs_mkconsistent should clean things up - lfsr_fs_mkconsistent(&lfs) => 0; + // calling lfs3_fs_mkconsistent should clean things up + lfs3_fs_mkconsistent(&lfs3) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; - assert(!(fsinfo.flags & LFS_I_MKCONSISTENT)); + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; + assert(!(fsinfo.flags & LFS3_I_MKCONSISTENT)); // double check the actual disk state, it's easy for littlefs to // lie here - assert(lfsr_mtree_weight(&lfs) - <= ((1+lfs_popc(BOOKENDS)) << lfs.mbits)); - lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - assert(mdir.rbyd.weight <= 1+lfs_popc(BOOKENDS)); + assert(lfs3_mtree_weight(&lfs3) + <= ((1+lfs3_popc(BOOKENDS)) << lfs3.mbits)); + lfs3_mdir_t mdir; + lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; + assert(mdir.rbyd.weight <= 1+lfs3_popc(BOOKENDS)); // check that other files are unaffected if (BOOKENDS & 0x1) { - lfsr_file_rewind(&lfs, &bookend_files[0]) => 0; + lfs3_file_rewind(&lfs3, &bookend_files[0]) => 0; uint32_t prng_ = bookend_prngs[0]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &bookend_files[0], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &bookend_files[0], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } if (BOOKENDS & 0x2) { - lfsr_file_rewind(&lfs, &bookend_files[1]) => 0; + lfs3_file_rewind(&lfs3, &bookend_files[1]) => 0; uint32_t prng_ = bookend_prngs[1]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng_) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &bookend_files[1], rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &bookend_files[1], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } if (BOOKENDS & 0x1) { - lfsr_file_close(&lfs, &bookend_files[0]); + lfs3_file_close(&lfs3, &bookend_files[0]); } if (BOOKENDS & 0x2) { - lfsr_file_close(&lfs, &bookend_files[1]); + lfs3_file_close(&lfs3, &bookend_files[1]); } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -8484,237 +8524,240 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.EXISTS = [false, true] defines.INTERDIR = [false, true] defines.DISTANCE = [0, 1, 100] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create our destination first, just in case if (EXISTS) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // need to sync so we can rename - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // rename the file - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // the file should have been renamed // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // but we should still be able to read our file handle - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // close should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // remount should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_file_mv_postmv] @@ -8726,297 +8769,300 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.EXISTS = [false, true] defines.INTERDIR = [false, true] defines.DISTANCE = [0, 1, 100] defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create our destination first, just in case if (EXISTS) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // need to sync so we can rename - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // rename the file - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // the file should have been renamed, but zero sized // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // but we should still be able to read our file handle - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } if (SYNC) { // sync - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // the data should now be visible // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) - => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // we should still be able to read our file handle - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // the data should now be visible // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // remount should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_file_mv_file_rwrw] @@ -9028,346 +9074,349 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.EXISTS = [false, true] defines.INTERDIR = [false, true] defines.DISTANCE = [0, 1, 100] defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create our destination first, just in case if (EXISTS) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // write to the file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // need to sync so we can rename - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // create a second file - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_TRUNC) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_TRUNC) => 0; // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } // rename the file - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // the file should have been renamed // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // but we should still be able to read both file handles - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } if (SYNC) { // sync, note the order - lfsr_file_sync(&lfs, &file__) => 0; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // the second file's data should now be visible // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) - => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // both file handles should be updated - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close, note the order - lfsr_file_close(&lfs, &file__) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file__) => 0; + lfs3_file_close(&lfs3, &file) => 0; // close should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // remount should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_file_mv_rwrw_postmv] @@ -9379,338 +9428,341 @@ defines.SIZE = [ '2*BLOCK_SIZE', '4*BLOCK_SIZE', ] -defines.CHUNK = 'LFS_MIN(64, SIZE)' +defines.CHUNK = 'LFS3_MIN(64, SIZE)' defines.EXISTS = [false, true] defines.INTERDIR = [false, true] defines.DISTANCE = [0, 1, 100] defines.SYNC = [false, true] defines.MKCONSISTENT = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create our destination first, just in case if (EXISTS) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // need to sync so we can rename - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // create a second file - lfsr_file_t file__; - lfsr_file_open(&lfs, &file__, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_TRUNC) => 0; + lfs3_file_t file__; + lfs3_file_open(&lfs3, &file__, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_TRUNC) => 0; // rename the file - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; // write to the first file uint32_t prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file, wbuf, CHUNK) => CHUNK; } // write to the second file prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file__, wbuf, CHUNK) => CHUNK; + lfs3_file_write(&lfs3, &file__, wbuf, CHUNK) => CHUNK; } // mkconsistent should have no effect if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // the file should have been renamed, but zero sized // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => 0; - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // but we should still be able to read both file handles - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } if (SYNC) { // sync, note the order - lfsr_file_sync(&lfs, &file__) => 0; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file__) => 0; + lfs3_file_sync(&lfs3, &file) => 0; // the second file's data should now be visible // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) - => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // both file handles should be updated - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_rewind(&lfs, &file__) => 0; + lfs3_file_rewind(&lfs3, &file__) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file__, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file__, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } } // close, note the order - lfsr_file_close(&lfs, &file__) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file__) => 0; + lfs3_file_close(&lfs3, &file) => 0; // close should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; // remount - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // remount should have no effect // via stat - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; prng = 42+1; - for (lfs_off_t i = 0; i < SIZE; i += CHUNK) { + for (lfs3_off_t i = 0; i < SIZE; i += CHUNK) { uint8_t wbuf[CHUNK]; - for (lfs_size_t j = 0; j < CHUNK; j++) { + for (lfs3_size_t j = 0; j < CHUNK; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[CHUNK]; - lfsr_file_read(&lfs, &file_, rbuf, CHUNK) => CHUNK; + lfs3_file_read(&lfs3, &file_, rbuf, CHUNK) => CHUNK; assert(memcmp(wbuf, rbuf, CHUNK) == 0); } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_file_mv_mv_src] @@ -9730,154 +9782,155 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create our destination first, just in case if (EXISTS) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_sync(&lfs3, &file) => 0; if (!POSTMV) { - lfsr_file_write(&lfs, &file, + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } } if (CLOSE == 2) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename while open - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTMV) { - lfsr_file_write(&lfs, &file, + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } } // we should still be able to read our file - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &file, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); if ((SYNC || CLOSE >= 1) && !(POSTMV && CLOSE >= 2)) { assert(info.size == strlen("catman!")); } else { assert(info.size == 0); } - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); if ((SYNC || CLOSE >= 1) && !(POSTMV && CLOSE >= 2)) { assert(info.size == strlen("catman!")); } else { assert(info.size == 0); } if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; if ((SYNC || CLOSE >= 1) && !(POSTMV && CLOSE >= 2)) { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); } else { - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => 0; + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => 0; } - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; if (CLOSE == 0) { - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_file_fileonzombie_mv_src] @@ -9897,169 +9950,170 @@ defines.REMOUNT = [0, 1, 2] defines.MKCONSISTENT = [false, true] if = 'REMOUNT <= CLOSE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create an interesting directory structure if (INTERDIR) { - lfsr_mkdir(&lfs, "a") => 0; - lfsr_mkdir(&lfs, "b") => 0; - lfsr_mkdir(&lfs, "c") => 0; + lfs3_mkdir(&lfs3, "a") => 0; + lfs3_mkdir(&lfs3, "b") => 0; + lfs3_mkdir(&lfs3, "c") => 0; } - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "b/catman%03x" : "catman%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // create our destination first, just in case if (EXISTS) { if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "a/batman" : "batman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "a/batman" : "batman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "a/batman" : "batman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "hmmmmmmmm", strlen("hmmmmmmmm")) => strlen("hmmmmmmmm"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // create a zombie - lfsr_file_t zombie; - lfsr_file_open(&lfs, &zombie, (INTERDIR) ? "c/datman" : "datman", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t zombie; + lfs3_file_open(&lfs3, &zombie, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; if (!POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } - lfsr_file_sync(&lfs, &zombie) => 0; - lfsr_remove(&lfs, (INTERDIR) ? "c/datman" : "datman") => 0; + lfs3_file_sync(&lfs3, &zombie) => 0; + lfs3_remove(&lfs3, (INTERDIR) ? "c/datman" : "datman") => 0; // create a file on top of the zombie if (DIR) { - lfsr_mkdir(&lfs, (INTERDIR) ? "c/datman" : "datman") => 0; + lfs3_mkdir(&lfs3, (INTERDIR) ? "c/datman" : "datman") => 0; } else { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, (INTERDIR) ? "c/datman" : "datman", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, "catman!", strlen("catman!")) + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, (INTERDIR) ? "c/datman" : "datman", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, "catman!", strlen("catman!")) => strlen("catman!"); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } if (CLOSE == 2) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 2) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // rename while open - lfsr_rename(&lfs, + lfs3_rename(&lfs3, (INTERDIR) ? "c/datman" : "datman", (INTERDIR) ? "a/batman" : "batman") => 0; if (CLOSE <= 1 && REMOUNT <= 1) { if (POSTHUMOUS) { - lfsr_file_write(&lfs, &zombie, + lfs3_file_write(&lfs3, &zombie, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) => strlen("WoOoOoOoOoO"); } // we should still be able to read our file - lfsr_file_rewind(&lfs, &zombie) => 0; + lfs3_file_rewind(&lfs3, &zombie) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &zombie, rbuf, sizeof(rbuf)) + lfs3_file_read(&lfs3, &zombie, rbuf, sizeof(rbuf)) => strlen("WoOoOoOoOoO"); assert(memcmp(rbuf, "WoOoOoOoOoO", strlen("WoOoOoOoOoO")) == 0); if (CLOSE == 1) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } if (REMOUNT == 1) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } } if (MKCONSISTENT) { - lfsr_fs_mkconsistent(&lfs) => 0; + lfs3_fs_mkconsistent(&lfs3) => 0; } // make sure the new file is readable // via stat - struct lfs_info info; - lfsr_stat(&lfs, (INTERDIR) ? "a/batman" : "batman", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, (INTERDIR) ? "a/batman" : "batman", &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } - lfsr_stat(&lfs, (INTERDIR) ? "c/datman" : "datman", &info) => LFS_ERR_NOENT; + lfs3_stat(&lfs3, (INTERDIR) ? "c/datman" : "datman", &info) + => LFS3_ERR_NOENT; // via readdir - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, (INTERDIR) ? "a" : "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, (INTERDIR) ? "a" : "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "batman") == 0); if (DIR) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == strlen("catman!")); } if (!INTERDIR) { - for (lfs_size_t i = 0; i < DISTANCE; i++) { + for (lfs3_size_t i = 0; i < DISTANCE; i++) { char name[256]; sprintf(name, (INTERDIR) ? "a/catman%03x" : "catman%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == 0); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // via open if (DIR) { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => LFS3_ERR_ISDIR; } else { - lfsr_file_t file_; - lfsr_file_open(&lfs, &file_, (INTERDIR) ? "a/batman" : "batman", - LFS_O_RDONLY) => 0; + lfs3_file_t file_; + lfs3_file_open(&lfs3, &file_, (INTERDIR) ? "a/batman" : "batman", + LFS3_O_RDONLY) => 0; uint8_t rbuf[256]; - lfsr_file_read(&lfs, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); + lfs3_file_read(&lfs3, &file_, rbuf, sizeof(rbuf)) => strlen("catman!"); assert(memcmp(rbuf, "catman!", strlen("catman!")) == 0); - lfsr_file_close(&lfs, &file_) => 0; + lfs3_file_close(&lfs3, &file_) => 0; } if (CLOSE == 0) { - lfsr_file_close(&lfs, &zombie) => 0; + lfs3_file_close(&lfs3, &zombie) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -10089,332 +10143,332 @@ defines.DESYNC = [false, true] defines.ZOMBIE = [false, true] if = '(SIZE*N*(1+DESYNC+ZOMBIE))/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // we need a file handle for each file + desync + zombie - lfsr_file_t files[N]; - lfsr_file_t desyncs[N]; - lfsr_file_t zombies[N]; + lfs3_file_t files[N]; + lfs3_file_t desyncs[N]; + lfs3_file_t zombies[N]; // create this many files while renaming uint32_t prng = 42; uint32_t unsync_prng = 43; uint32_t desync_prng = 44; uint32_t zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // create a zombie? if (ZOMBIE) { - lfsr_file_open(&lfs, &zombies[i], "batman!!!", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &zombies[i], "batman!!!", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } - lfsr_file_write(&lfs, &zombies[i], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &zombies[i]) => 0; - lfsr_remove(&lfs, "batman!!!") => 0; + lfs3_file_write(&lfs3, &zombies[i], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &zombies[i]) => 0; + lfs3_remove(&lfs3, "batman!!!") => 0; } // always create as first file - lfsr_file_open(&lfs, &files[i], "batman!!!", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &files[i], "batman!!!", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &files[i]) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &files[i]) => 0; // keep unsynced data? if (UNSYNC) { - lfsr_file_rewind(&lfs, &files[i]) => 0; + lfs3_file_rewind(&lfs3, &files[i]) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&unsync_prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // keep a desynced file open? if (DESYNC) { - lfsr_file_open(&lfs, &desyncs[i], "batman!!!", - LFS_O_RDWR | LFS_O_DESYNC | LFS_O_TRUNC) => 0; + lfs3_file_open(&lfs3, &desyncs[i], "batman!!!", + LFS3_O_RDWR | LFS3_O_DESYNC | LFS3_O_TRUNC) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } - lfsr_file_write(&lfs, &desyncs[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &desyncs[i], wbuf, SIZE) => SIZE; } // rename! char name[256]; sprintf(name, "batman%03x", i); - lfsr_rename(&lfs, "batman!!!", name) => 0; + lfs3_rename(&lfs3, "batman!!!", name) => 0; } // check that renames worked prng = 42; - struct lfs_info info; - lfsr_stat(&lfs, "batman!!!", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + struct lfs3_info info; + lfs3_stat(&lfs3, "batman!!!", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "batman%03x", i); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that file handles are as expected prng = (!UNSYNC) ? 42 : 43; desync_prng = 44; zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check size - assert(lfsr_file_size(&lfs, &files[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &files[i]) == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // check any desynced files if (DESYNC) { - assert(lfsr_file_size(&lfs, &desyncs[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &desyncs[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &desyncs[i]) => 0; - lfsr_file_read(&lfs, &desyncs[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &desyncs[i]) => 0; + lfs3_file_read(&lfs3, &desyncs[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // check any zombied files if (ZOMBIE) { - assert(lfsr_file_size(&lfs, &zombies[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &zombies[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &zombies[i]) => 0; - lfsr_file_read(&lfs, &zombies[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &zombies[i]) => 0; + lfs3_file_read(&lfs3, &zombies[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } // try syncing any unsynced files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_sync(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_sync(&lfs3, &files[i]) => 0; } // check that sync worked prng = (!UNSYNC) ? 42 : 43; - lfsr_stat(&lfs, "batman!!!", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_stat(&lfs3, "batman!!!", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "batman%03x", i); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that file handles are as expected prng = (!UNSYNC) ? 42 : 43; desync_prng = 44; zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check size - assert(lfsr_file_size(&lfs, &files[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &files[i]) == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // check any desynced files if (DESYNC) { - assert(lfsr_file_size(&lfs, &desyncs[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &desyncs[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &desyncs[i]) => 0; - lfsr_file_read(&lfs, &desyncs[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &desyncs[i]) => 0; + lfs3_file_read(&lfs3, &desyncs[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // check any zombied files if (ZOMBIE) { - assert(lfsr_file_size(&lfs, &zombies[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &zombies[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &zombies[i]) => 0; - lfsr_file_read(&lfs, &zombies[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &zombies[i]) => 0; + lfs3_file_read(&lfs3, &zombies[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } // try rewriting our open files uint32_t rewrite_prng = 52; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_rewind(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_rewind(&lfs3, &files[i]) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&rewrite_prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &files[i]) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &files[i]) => 0; } // check that rewrites worked rewrite_prng = 52; - lfsr_stat(&lfs, "batman!!!", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_stat(&lfs3, "batman!!!", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "batman%03x", i); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&rewrite_prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that file handles are as expected rewrite_prng = 52; desync_prng = 44; zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check size - assert(lfsr_file_size(&lfs, &files[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &files[i]) == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&rewrite_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // check any desynced files if (DESYNC) { - assert(lfsr_file_size(&lfs, &desyncs[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &desyncs[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &desyncs[i]) => 0; - lfsr_file_read(&lfs, &desyncs[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &desyncs[i]) => 0; + lfs3_file_read(&lfs3, &desyncs[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // check any zombied files if (ZOMBIE) { - assert(lfsr_file_size(&lfs, &zombies[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &zombies[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &zombies[i]) => 0; - lfsr_file_read(&lfs, &zombies[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &zombies[i]) => 0; + lfs3_file_read(&lfs3, &zombies[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } // cleanup files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } if (DESYNC) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &desyncs[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &desyncs[i]) => 0; } } if (ZOMBIE) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &zombies[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &zombies[i]) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_stickynotes_file_mv_split_backwards] @@ -10436,332 +10490,332 @@ defines.DESYNC = [false, true] defines.ZOMBIE = [false, true] if = '(SIZE*N*(1+DESYNC+ZOMBIE))/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // we need a file handle for each file + desync + zombie - lfsr_file_t files[N]; - lfsr_file_t desyncs[N]; - lfsr_file_t zombies[N]; + lfs3_file_t files[N]; + lfs3_file_t desyncs[N]; + lfs3_file_t zombies[N]; // create this many files while renaming uint32_t prng = 42; uint32_t unsync_prng = 43; uint32_t desync_prng = 44; uint32_t zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // create a zombie? if (ZOMBIE) { - lfsr_file_open(&lfs, &zombies[i], "batman???", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &zombies[i], "batman???", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } - lfsr_file_write(&lfs, &zombies[i], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &zombies[i]) => 0; - lfsr_remove(&lfs, "batman???") => 0; + lfs3_file_write(&lfs3, &zombies[i], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &zombies[i]) => 0; + lfs3_remove(&lfs3, "batman???") => 0; } // always create as last file - lfsr_file_open(&lfs, &files[i], "batman???", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &files[i], "batman???", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &files[i]) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &files[i]) => 0; // keep unsynced data? if (UNSYNC) { - lfsr_file_rewind(&lfs, &files[i]) => 0; + lfs3_file_rewind(&lfs3, &files[i]) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&unsync_prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // keep a desynced file open? if (DESYNC) { - lfsr_file_open(&lfs, &desyncs[i], "batman???", - LFS_O_RDWR | LFS_O_DESYNC | LFS_O_TRUNC) => 0; + lfs3_file_open(&lfs3, &desyncs[i], "batman???", + LFS3_O_RDWR | LFS3_O_DESYNC | LFS3_O_TRUNC) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } - lfsr_file_write(&lfs, &desyncs[i], wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &desyncs[i], wbuf, SIZE) => SIZE; } // rename! char name[256]; sprintf(name, "batman%03x", (uint32_t)(N-1-i)); - lfsr_rename(&lfs, "batman???", name) => 0; + lfs3_rename(&lfs3, "batman???", name) => 0; } // check that renames worked prng = 42; - struct lfs_info info; - lfsr_stat(&lfs, "batman???", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + struct lfs3_info info; + lfs3_stat(&lfs3, "batman???", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "batman%03x", (uint32_t)(N-1-i)); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that file handles are as expected prng = (!UNSYNC) ? 42 : 43; desync_prng = 44; zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check size - assert(lfsr_file_size(&lfs, &files[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &files[i]) == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // check any desynced files if (DESYNC) { - assert(lfsr_file_size(&lfs, &desyncs[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &desyncs[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &desyncs[i]) => 0; - lfsr_file_read(&lfs, &desyncs[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &desyncs[i]) => 0; + lfs3_file_read(&lfs3, &desyncs[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // check any zombied files if (ZOMBIE) { - assert(lfsr_file_size(&lfs, &zombies[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &zombies[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &zombies[i]) => 0; - lfsr_file_read(&lfs, &zombies[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &zombies[i]) => 0; + lfs3_file_read(&lfs3, &zombies[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } // try syncing any unsynced files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_sync(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_sync(&lfs3, &files[i]) => 0; } // check that sync worked prng = (!UNSYNC) ? 42 : 43; - lfsr_stat(&lfs, "batman???", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_stat(&lfs3, "batman???", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "batman%03x", (uint32_t)(N-1-i)); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that file handles are as expected prng = (!UNSYNC) ? 42 : 43; desync_prng = 44; zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check size - assert(lfsr_file_size(&lfs, &files[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &files[i]) == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // check any desynced files if (DESYNC) { - assert(lfsr_file_size(&lfs, &desyncs[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &desyncs[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &desyncs[i]) => 0; - lfsr_file_read(&lfs, &desyncs[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &desyncs[i]) => 0; + lfs3_file_read(&lfs3, &desyncs[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // check any zombied files if (ZOMBIE) { - assert(lfsr_file_size(&lfs, &zombies[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &zombies[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &zombies[i]) => 0; - lfsr_file_read(&lfs, &zombies[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &zombies[i]) => 0; + lfs3_file_read(&lfs3, &zombies[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } // try rewriting our open files uint32_t rewrite_prng = 52; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_rewind(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_rewind(&lfs3, &files[i]) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&rewrite_prng) % 26); } - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &files[i]) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &files[i]) => 0; } // check that rewrites worked rewrite_prng = 52; - lfsr_stat(&lfs, "batman???", &info) => LFS_ERR_NOENT; - for (lfs_size_t i = 0; i < N; i++) { + lfs3_stat(&lfs3, "batman???", &info) => LFS3_ERR_NOENT; + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "batman%03x", (uint32_t)(N-1-i)); - lfsr_stat(&lfs, name, &info) => 0; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&rewrite_prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that file handles are as expected rewrite_prng = 52; desync_prng = 44; zombie_prng = 45; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check size - assert(lfsr_file_size(&lfs, &files[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &files[i]) == SIZE); // try reading the file uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&rewrite_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); // check any desynced files if (DESYNC) { - assert(lfsr_file_size(&lfs, &desyncs[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &desyncs[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&desync_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &desyncs[i]) => 0; - lfsr_file_read(&lfs, &desyncs[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &desyncs[i]) => 0; + lfs3_file_read(&lfs3, &desyncs[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // check any zombied files if (ZOMBIE) { - assert(lfsr_file_size(&lfs, &zombies[i]) == SIZE); + assert(lfs3_file_size(&lfs3, &zombies[i]) == SIZE); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&zombie_prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &zombies[i]) => 0; - lfsr_file_read(&lfs, &zombies[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &zombies[i]) => 0; + lfs3_file_read(&lfs3, &zombies[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } } // cleanup files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } if (DESYNC) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &desyncs[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &desyncs[i]) => 0; } } if (ZOMBIE) { - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &zombies[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &zombies[i]) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -10784,28 +10838,28 @@ defines.SEED = 'range(20)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -10816,13 +10870,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -10836,23 +10890,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -10864,7 +10918,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -10873,7 +10927,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -10893,26 +10947,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -10923,7 +10977,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -10939,8 +10993,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -10948,10 +11002,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -10962,7 +11016,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -10970,10 +11024,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -10991,17 +11045,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -11009,7 +11063,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -11022,9 +11076,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -11033,16 +11087,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -11058,7 +11112,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -11068,7 +11122,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -11082,7 +11136,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -11096,94 +11150,94 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # fuzz tests involving many uncreats + zombies + dirs, this gets a bit crazy @@ -11204,29 +11258,29 @@ defines.SEED = 'range(20)' fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -11237,13 +11291,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -11260,23 +11314,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -11288,7 +11342,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -11297,7 +11351,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -11320,26 +11374,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -11350,7 +11404,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -11366,19 +11420,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -11389,7 +11443,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -11397,10 +11451,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -11420,17 +11474,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -11440,7 +11494,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -11453,14 +11507,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -11478,16 +11532,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -11506,7 +11560,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -11518,7 +11572,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -11535,7 +11589,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -11549,9 +11603,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -11564,14 +11618,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -11587,7 +11641,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -11596,109 +11650,109 @@ code = ''' } // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' diff --git a/tests/test_traversal.toml b/tests/test_traversal.toml index 028e51c5..05617aa4 100644 --- a/tests/test_traversal.toml +++ b/tests/test_traversal.toml @@ -15,30 +15,30 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # can we rewind? @@ -49,39 +49,39 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfsr_traversal_rewind(&lfs, &t) => 0; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_rewind(&lfs3, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we don't get extra anything after end of traversal @@ -92,38 +92,38 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -134,51 +134,51 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // traverse to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("traversal: btype %d block 0x%x\n", tinfo.btype, tinfo.block); - assert(tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE); + assert(tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE); // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -190,44 +190,44 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_clobber_files] @@ -245,63 +245,63 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("traversal: btype %d block 0x%x\n", tinfo.btype, tinfo.block); - assert(tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA); + assert(tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA); // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -313,37 +313,37 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_clobber_files_opened] @@ -361,62 +361,62 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files - lfsr_file_t files[N]; + lfs3_file_t files[N]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_open(&lfs, &files[i], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // traverse to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("traversal: btype %d block 0x%x\n", tinfo.btype, tinfo.block); - assert(tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA); + assert(tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA); // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -426,58 +426,58 @@ code = ''' // then check that reading our files still works after clobbering prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // and everything is fine after saving the files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -488,60 +488,60 @@ defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // traverse to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - lfs_block_t r = 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + lfs3_block_t r = 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); if (i == r) { - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; memset(seen, 0, (BLOCK_COUNT+7)/8); r += 1; i = -1; continue; } - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("traversal: btype %d block 0x%x\n", tinfo.btype, tinfo.block); - assert(tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE); + assert(tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE); // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -553,44 +553,44 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_rewind_clobber_files] @@ -608,72 +608,72 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - lfs_block_t r = 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + lfs3_block_t r = 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); if (i == r) { - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; memset(seen, 0, (BLOCK_COUNT+7)/8); r += 1; i = -1; continue; } - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("traversal: btype %d block 0x%x\n", tinfo.btype, tinfo.block); - assert(tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA); + assert(tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA); // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -685,37 +685,37 @@ code = ''' for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_rewind_clobber_files_opened] @@ -733,71 +733,71 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files - lfsr_file_t files[N]; + lfs3_file_t files[N]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_open(&lfs, &files[i], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // traverse to find all blocks in use uint8_t *seen = malloc((BLOCK_COUNT+7)/8); memset(seen, 0, (BLOCK_COUNT+7)/8); - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDONLY - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - lfs_block_t r = 0; - for (lfs_block_t i = 0;; i++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDONLY + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + lfs3_block_t r = 0; + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); if (i == r) { - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; memset(seen, 0, (BLOCK_COUNT+7)/8); r += 1; i = -1; continue; } - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } printf("traversal: btype %d block 0x%x\n", tinfo.btype, tinfo.block); - assert(tinfo.btype == LFS_BTYPE_MDIR - || tinfo.btype == LFS_BTYPE_BTREE - || tinfo.btype == LFS_BTYPE_DATA); + assert(tinfo.btype == LFS3_BTYPE_MDIR + || tinfo.btype == LFS3_BTYPE_BTREE + || tinfo.btype == LFS3_BTYPE_DATA); // keep track of seen blocks seen[tinfo.block / 8] |= 1 << (tinfo.block % 8); } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // clobber every other block uint8_t clobber_buf[BLOCK_SIZE]; memset(clobber_buf, 0xcc, BLOCK_SIZE); - for (lfs_block_t block = 0; block < BLOCK_COUNT; block++) { + for (lfs3_block_t block = 0; block < BLOCK_COUNT; block++) { if (!(seen[block / 8] & (1 << (block % 8)))) { CFG->erase(CFG, block) => 0; CFG->prog(CFG, block, 0, clobber_buf, BLOCK_SIZE) => 0; @@ -807,58 +807,58 @@ code = ''' // then check that reading our files still works after clobbering prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_rewind(&lfs, &files[i]) => 0; - lfsr_file_read(&lfs, &files[i], rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &files[i]) => 0; + lfs3_file_read(&lfs3, &files[i], rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } // and everything is fine after saving the files - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "file%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -867,38 +867,38 @@ code = ''' [cases.test_traversal_ckmdir_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' - for (lfs_block_t i = 0;; i += 2) { + for (lfs3_block_t i = 0;; i += 2) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_MDIR) { + if (tinfo.btype == LFS3_BTYPE_MDIR) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -908,7 +908,7 @@ code = ''' CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (k == i+1) { - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -918,21 +918,21 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -952,49 +952,49 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - for (lfs_block_t i = 0;; i += 2) { + for (lfs3_block_t i = 0;; i += 2) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_MDIR) { + if (tinfo.btype == LFS3_BTYPE_MDIR) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1004,7 +1004,7 @@ code = ''' CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (k == i+1) { - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -1014,21 +1014,21 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1048,51 +1048,51 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - for (lfs_block_t i = 0;; i += 2) { + for (lfs3_block_t i = 0;; i += 2) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files - lfsr_file_t files[N]; + lfs3_file_t files[N]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_open(&lfs, &files[i], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_MDIR) { + if (tinfo.btype == LFS3_BTYPE_MDIR) { if (k == i || k == i+1) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1102,7 +1102,7 @@ code = ''' CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; if (k == i+1) { - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } } @@ -1112,25 +1112,25 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_desync(&lfs, &files[i]) => 0; - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_desync(&lfs3, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1141,38 +1141,38 @@ done:; [cases.test_traversal_ckbtree_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1181,7 +1181,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1190,21 +1190,21 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1224,49 +1224,49 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1275,7 +1275,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1284,21 +1284,21 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1318,51 +1318,51 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files - lfsr_file_t files[N]; + lfs3_file_t files[N]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_open(&lfs, &files[i], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_BTREE) { + if (tinfo.btype == LFS3_BTYPE_BTREE) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1371,7 +1371,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1380,25 +1380,25 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKMETA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKMETA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_desync(&lfs, &files[i]) => 0; - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_desync(&lfs3, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1409,38 +1409,38 @@ done:; [cases.test_traversal_ckdata_dirs] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_DATA) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1449,7 +1449,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1458,21 +1458,21 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKDATA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1492,49 +1492,49 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - lfsr_unmount(&lfs) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_DATA) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1543,7 +1543,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1552,21 +1552,21 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKDATA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1586,51 +1586,51 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' - for (lfs_block_t i = 0;; i++) { + for (lfs3_block_t i = 0;; i++) { // a bit hacky, but this catches infinite loops assert(i < 2*BLOCK_COUNT); - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create this many files - lfsr_file_t files[N]; + lfs3_file_t files[N]; uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "file%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_open(&lfs, &files[i], name, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &files[i], wbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &files[i], name, + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &files[i], wbuf, SIZE) => SIZE; } // traverse to find blocks - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY) => 0; - lfs_block_t k = 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY) => 0; + lfs3_block_t k = 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { - lfsr_traversal_close(&lfs, &t) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_close(&lfs, &files[i]) => 0; + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_close(&lfs3, &t) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_close(&lfs3, &files[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; goto done; } - if (tinfo.btype == LFS_BTYPE_DATA) { + if (tinfo.btype == LFS3_BTYPE_DATA) { if (k == i) { // clobber this block printf("clobbering 0x%x\n", tinfo.block); @@ -1639,7 +1639,7 @@ code = ''' CFG->erase(CFG, tinfo.block) => 0; CFG->prog(CFG, tinfo.block, 0, clobber_buf, BLOCK_SIZE) => 0; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; goto clobbered; } k += 1; @@ -1648,25 +1648,25 @@ code = ''' clobbered:; // traverse again, we should detect the clobbered metadata - lfsr_traversal_open(&lfs, &t, LFS_T_RDONLY | LFS_T_CKDATA) => 0; - for (lfs_block_t j = 0;; j++) { + lfs3_traversal_open(&lfs3, &t, LFS3_T_RDONLY | LFS3_T_CKDATA) => 0; + for (lfs3_block_t j = 0;; j++) { assert(j < 2*BLOCK_COUNT); - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_CORRUPT); + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_CORRUPT); // found the clobbered metadata? - if (err == LFS_ERR_CORRUPT) { + if (err == LFS3_ERR_CORRUPT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - for (lfs_size_t i = 0; i < N; i++) { - lfsr_file_desync(&lfs, &files[i]) => 0; - lfsr_file_close(&lfs, &files[i]) => 0; + for (lfs3_size_t i = 0; i < N; i++) { + lfs3_file_desync(&lfs3, &files[i]) => 0; + lfs3_file_close(&lfs3, &files[i]) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; } done:; ''' @@ -1681,50 +1681,50 @@ defines.COMPACT = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // check flags before - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_MKCONSISTENT - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_MKCONSISTENT + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // check flags after - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!MKCONSISTENT) ? LFS_I_MKCONSISTENT : 0) - | ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) - | ((!COMPACT) ? LFS_I_COMPACT : 0) + ((!MKCONSISTENT) ? LFS3_I_MKCONSISTENT : 0) + | ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) + | ((!COMPACT) ? LFS3_I_COMPACT : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we detect filesystem mutation during traversal @@ -1734,61 +1734,61 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; if (WHEN == 0) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 1) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 2) { - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # test that we don't get extra anything after end of traversal @@ -1797,72 +1797,72 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // mutate - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try another mutation just for good measure - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // we should _not_ update lookahead/compact/ckmeta/ckdata - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mkdir] @@ -1871,52 +1871,52 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; if (WHEN == 0) { - lfsr_mkdir(&lfs, "spider") => 0; + lfs3_mkdir(&lfs3, "spider") => 0; } - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 1) { - lfsr_mkdir(&lfs, "spider") => 0; + lfs3_mkdir(&lfs3, "spider") => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 2) { - lfsr_mkdir(&lfs, "spider") => 0; + lfs3_mkdir(&lfs3, "spider") => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_rm] @@ -1925,58 +1925,58 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // make a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; if (WHEN == 0) { - lfsr_remove(&lfs, "spider") => 0; + lfs3_remove(&lfs3, "spider") => 0; } - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 1) { - lfsr_remove(&lfs, "spider") => 0; + lfs3_remove(&lfs3, "spider") => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 2) { - lfsr_remove(&lfs, "spider") => 0; + lfs3_remove(&lfs3, "spider") => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mv] @@ -1985,58 +1985,58 @@ defines.LOOKAHEAD = [false, true] defines.CKMETA = [false, true] defines.CKDATA = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // make a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; if (WHEN == 0) { - lfsr_rename(&lfs, "spider", "scorpion") => 0; + lfs3_rename(&lfs3, "spider", "scorpion") => 0; } - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 1) { - lfsr_rename(&lfs, "spider", "scorpion") => 0; + lfs3_rename(&lfs3, "spider", "scorpion") => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (WHEN == 2) { - lfsr_rename(&lfs, "spider", "scorpion") => 0; + lfs3_rename(&lfs3, "spider", "scorpion") => 0; } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' # some more complex mutation tests @@ -2053,69 +2053,69 @@ defines.SIZE = [ '8*BLOCK_SIZE', ] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; while (true) { // rewrite the file every step of the traversal - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_TRUNC) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_TRUNC) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // step traversal - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_fwrite_opened] @@ -2132,79 +2132,79 @@ defines.SIZE = [ ] defines.SYNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file) => 0; if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; while (true) { // rewrite the file every step of the traversal - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // step traversal - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; // and after close? - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -2219,85 +2219,85 @@ defines.CKDATA = [false, true] defines.SIZE = 'FILE_CACHE_SIZE/2' defines.TRUNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // rewrite the file - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY - | ((TRUNC) ? LFS_O_TRUNC : 0)) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY + | ((TRUNC) ? LFS3_O_TRUNC : 0)) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_file_btree] @@ -2308,99 +2308,99 @@ defines.SIZE = '2*BLOCK_SIZE' defines.INLINE_SIZE = 0 defines.TRUNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY - | ((TRUNC) ? LFS_O_TRUNC : 0)) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY + | ((TRUNC) ? LFS3_O_TRUNC : 0)) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_file_bshrub] @@ -2410,93 +2410,93 @@ defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' defines.TRUNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY - | ((TRUNC) ? LFS_O_TRUNC : 0)) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY + | ((TRUNC) ? LFS3_O_TRUNC : 0)) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_uncreat_bsprout] @@ -2505,88 +2505,88 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = 'FILE_CACHE_SIZE/2' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // rewrite the file - lfsr_file_rewind(&lfs, &file1) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file1) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; // check the file contents - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_uncreat_btree] @@ -2596,102 +2596,102 @@ defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' defines.INLINE_SIZE = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file - lfsr_file_rewind(&lfs, &file1) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file1) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; // check the file contents - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_uncreat_bshrub] @@ -2700,96 +2700,96 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite the file - lfsr_file_rewind(&lfs, &file1) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file1) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; // check the file contents - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_close_bsprout] @@ -2799,94 +2799,94 @@ defines.CKDATA = [false, true] defines.SIZE = 'FILE_CACHE_SIZE/2' defines.DESYNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // close the file if (DESYNC) { - lfsr_file_desync(&lfs, &file1) => 0; + lfs3_file_desync(&lfs3, &file1) => 0; } - lfsr_file_close(&lfs, &file1) => 0; + lfs3_file_close(&lfs3, &file1) => 0; // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((DESYNC) ? LFS_I_MKCONSISTENT : 0) - | ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((DESYNC) ? LFS3_I_MKCONSISTENT : 0) + | ((!(LOOKAHEAD && DESYNC)) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta | ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC)) - ? LFS_I_CKMETA + ? LFS3_I_CKMETA : 0) - | ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0))); + | ((!(CKDATA && DESYNC)) ? LFS3_I_CKDATA : 0))); - lfsr_file_close(&lfs, &file2) => 0; + lfs3_file_close(&lfs3, &file2) => 0; // check the file contents - lfsr_file_t file; + lfs3_file_t file; if (DESYNC) { - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => LFS3_ERR_NOENT; } else { - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_close_btree] @@ -2897,108 +2897,108 @@ defines.SIZE = '2*BLOCK_SIZE' defines.INLINE_SIZE = 0 defines.DESYNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // close the file if (DESYNC) { - lfsr_file_desync(&lfs, &file1) => 0; + lfs3_file_desync(&lfs3, &file1) => 0; } - lfsr_file_close(&lfs, &file1) => 0; + lfs3_file_close(&lfs3, &file1) => 0; // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((DESYNC) ? LFS_I_MKCONSISTENT : 0) - | ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((DESYNC) ? LFS3_I_MKCONSISTENT : 0) + | ((!(LOOKAHEAD && DESYNC)) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta | ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC)) - ? LFS_I_CKMETA + ? LFS3_I_CKMETA : 0) - | ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0))); + | ((!(CKDATA && DESYNC)) ? LFS3_I_CKDATA : 0))); - lfsr_file_close(&lfs, &file2) => 0; + lfs3_file_close(&lfs3, &file2) => 0; // check the file contents - lfsr_file_t file; + lfs3_file_t file; if (DESYNC) { - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => LFS3_ERR_NOENT; } else { - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_close_bshrub] @@ -3008,102 +3008,102 @@ defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' defines.DESYNC = [false, true] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // close the file if (DESYNC) { - lfsr_file_desync(&lfs, &file1) => 0; + lfs3_file_desync(&lfs3, &file1) => 0; } - lfsr_file_close(&lfs, &file1) => 0; + lfs3_file_close(&lfs3, &file1) => 0; // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((DESYNC) ? LFS_I_MKCONSISTENT : 0) - | ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((DESYNC) ? LFS3_I_MKCONSISTENT : 0) + | ((!(LOOKAHEAD && DESYNC)) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta | ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC)) - ? LFS_I_CKMETA + ? LFS3_I_CKMETA : 0) - | ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0))); + | ((!(CKDATA && DESYNC)) ? LFS3_I_CKDATA : 0))); - lfsr_file_close(&lfs, &file2) => 0; + lfs3_file_close(&lfs3, &file2) => 0; // check the file contents - lfsr_file_t file; + lfs3_file_t file; if (DESYNC) { - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => LFS3_ERR_NOENT; } else { - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_rm_bshrub] @@ -3112,87 +3112,87 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // remove the file - lfsr_remove(&lfs, "spider") => 0; + lfs3_remove(&lfs3, "spider") => 0; // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/etc, unless we're desynced - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((DESYNC) ? LFS_I_MKCONSISTENT : 0) - | ((!(LOOKAHEAD && DESYNC)) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((DESYNC) ? LFS3_I_MKCONSISTENT : 0) + | ((!(LOOKAHEAD && DESYNC)) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta | ((!(CKMETA && DESYNC) && !(CKDATA && DESYNC)) - ? LFS_I_CKMETA + ? LFS3_I_CKMETA : 0) - | ((!(CKDATA && DESYNC)) ? LFS_I_CKDATA : 0))); + | ((!(CKDATA && DESYNC)) ? LFS3_I_CKDATA : 0))); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mv_src_bshrub] @@ -3201,102 +3201,102 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create three files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rename one file over another - lfsr_rename(&lfs, "spider", "tarantula") => 0; + lfs3_rename(&lfs3, "spider", "tarantula") => 0; // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mv_dst_bshrub] @@ -3305,97 +3305,97 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rename one file over another - lfsr_rename(&lfs, "tarantula", "spider") => 0; + lfs3_rename(&lfs3, "tarantula", "spider") => 0; // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => LFS3_ERR_NOENT; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_split] @@ -3404,103 +3404,103 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // create enough files for mroot to split - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "uloborus%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_split_bshrub_l] @@ -3509,121 +3509,121 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create three files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "tarantula", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse a data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mroot to split - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "uloborus%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "tarantula", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "tarantula", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_split_bshrub_r] @@ -3632,116 +3632,116 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create three files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "zodarion", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "zodarion", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // and another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mroot to split - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "uloborus%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "zodarion", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "zodarion", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_extend] @@ -3752,96 +3752,96 @@ defines.SIZE = '2*BLOCK_SIZE' # force early relocations defines.BLOCK_RECYCLES = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "uloborus") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "uloborus") => 0; } // traverse mroot - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_extend_bshrub] @@ -3852,95 +3852,95 @@ defines.SIZE = '2*BLOCK_SIZE' # force early relocations defines.BLOCK_RECYCLES = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse a data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "uloborus") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "uloborus") => 0; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_relocate] @@ -3951,63 +3951,63 @@ defines.SIZE = '2*BLOCK_SIZE' # force early relocations defines.BLOCK_RECYCLES = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "uloborus") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "uloborus") => 0; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // rewrite enough files for mroot to relocate - lfs_block_t orig = lfs.mroot.rbyd.blocks[0]; - while (lfs.mroot.rbyd.blocks[0] == orig - || lfs.mroot.rbyd.blocks[0] == orig) { - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "uloborus") => 0; + lfs3_block_t orig = lfs3.mroot.rbyd.blocks[0]; + while (lfs3.mroot.rbyd.blocks[0] == orig + || lfs3.mroot.rbyd.blocks[0] == orig) { + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "uloborus") => 0; } // it's a bit unclear if clobbered mroot chain traversals should @@ -4015,46 +4015,46 @@ code = ''' // I wouldn't worry too much about it // // traverse mroot - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mroot_relocate_bshrub] @@ -4065,109 +4065,109 @@ defines.SIZE = '2*BLOCK_SIZE' # force early relocations defines.BLOCK_RECYCLES = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "uloborus") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "uloborus") => 0; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroots - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse a data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to relocate - lfs_block_t orig = lfs.mroot.rbyd.blocks[0]; - while (lfs.mroot.rbyd.blocks[0] == orig - || lfs.mroot.rbyd.blocks[0] == orig) { - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "uloborus") => 0; + lfs3_block_t orig = lfs3.mroot.rbyd.blocks[0]; + while (lfs3.mroot.rbyd.blocks[0] == orig + || lfs3.mroot.rbyd.blocks[0] == orig) { + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "uloborus") => 0; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_split] @@ -4176,174 +4176,174 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // create enough files for mdir to split again i = 0; - orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "vulsor%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_split_bshrub_l] @@ -4352,181 +4352,181 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mdir to split again i = 0; - orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "vulsor%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_split_bshrub_r] @@ -4535,175 +4535,175 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // create enough files for mdir to split again i = 0; - orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "vulsor%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_extend] @@ -4712,172 +4712,172 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // switch to early relocations after extending - lfsr_unmount(&lfs) => 0; - struct lfs_config cfg = *CFG; + lfs3_unmount(&lfs3) => 0; + struct lfs3_config cfg = *CFG; cfg.block_recycles = 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "vulsor", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "vulsor") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "vulsor", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "vulsor") => 0; } // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_extend_bshrub] @@ -4886,179 +4886,179 @@ defines.CKMETA = [false, true] defines.CKDATA = [false, true] defines.SIZE = '2*BLOCK_SIZE' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // switch to early relocations after extending - lfsr_unmount(&lfs) => 0; - struct lfs_config cfg = *CFG; + lfs3_unmount(&lfs3) => 0; + struct lfs3_config cfg = *CFG; cfg.block_recycles = 0; - lfsr_mount(&lfs, LFS_M_RDWR, &cfg) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, &cfg) => 0; // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "vulsor", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "vulsor") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "vulsor", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "vulsor") => 0; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_relocate] @@ -5069,176 +5069,176 @@ defines.SIZE = '2*BLOCK_SIZE' # force early relocations defines.BLOCK_RECYCLES = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "vulsor", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "vulsor") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "vulsor", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "vulsor") => 0; } // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // rewrite enough files for mroot to relocate - orig = lfs.mroot.rbyd.blocks[0]; - while (lfs.mroot.rbyd.blocks[0] == orig - || lfs.mroot.rbyd.blocks[0] == orig) { - lfsr_file_open(&lfs, &file, "vulsor", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "vulsor") => 0; + orig = lfs3.mroot.rbyd.blocks[0]; + while (lfs3.mroot.rbyd.blocks[0] == orig + || lfs3.mroot.rbyd.blocks[0] == orig) { + lfs3_file_open(&lfs3, &file, "vulsor", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "vulsor") => 0; } // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mutation_mtree_relocate_bshrub] @@ -5249,187 +5249,187 @@ defines.SIZE = '2*BLOCK_SIZE' # force early relocations defines.BLOCK_RECYCLES = 0 code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "spider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "spider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf1, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf1, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "uloborus", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf2, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf2, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "wolfspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf3, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf3, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf4, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf4, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // rewrite enough files for mroot to extend - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_open(&lfs, &file, "vulsor", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "vulsor") => 0; + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_open(&lfs3, &file, "vulsor", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "vulsor") => 0; } // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "tarantula%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "xnotata%03x", i); - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // try traversing - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroots - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse one data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // rewrite enough files for mroot to relocate - orig = lfs.mroot.rbyd.blocks[0]; - while (lfs.mroot.rbyd.blocks[0] == orig - || lfs.mroot.rbyd.blocks[0] == orig) { - lfsr_file_open(&lfs, &file, "vulsor", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; - lfsr_remove(&lfs, "vulsor") => 0; + orig = lfs3.mroot.rbyd.blocks[0]; + while (lfs3.mroot.rbyd.blocks[0] == orig + || lfs3.mroot.rbyd.blocks[0] == orig) { + lfs3_file_open(&lfs3, &file, "vulsor", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_remove(&lfs3, "vulsor") => 0; } // traverse another data block - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse two data blocks - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_DATA); // we should be at end of traversal now - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should _not_ update lookahead/compact/ckmeta/ckdata - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check the file contents - lfsr_file_open(&lfs, &file, "spider", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "spider", LFS3_O_RDONLY) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "uloborus", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "uloborus", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "wolfspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "wolfspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_file_open(&lfs, &file, "yellowcrabspider", LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, "yellowcrabspider", LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -5443,106 +5443,106 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // write to our mdir until >gc_compact_thresh full - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // hack, don't use the internals like this uint8_t wbuf[SIZE]; while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } // we should be marked as uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing and compacting - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // mdir should have been compacted assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // but because we mutated, we're still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mdir should have been compacted assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_compact_mrootchain] @@ -5554,136 +5554,136 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' # force early relocations defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // write to our mdir until mroot extends - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf[SIZE]; - while (lfs.mroot.rbyd.blocks[0] == 0 - || lfs.mroot.rbyd.blocks[0] == 1) { - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + while (lfs3.mroot.rbyd.blocks[0] == 0 + || lfs3.mroot.rbyd.blocks[0] == 1) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } // now write to our mdir until mrootanchor >gc_compact_thresh full while (true) { // we need internals to check this - lfsr_mdir_t mrootanchor; - lfsr_mdir_fetch(&lfs, &mrootanchor, - -1, LFSR_MPTR_MROOTANCHOR()) => 0; - if (lfsr_rbyd_eoff(&mrootanchor.rbyd) > GC_COMPACT_THRESH) { + lfs3_mdir_t mrootanchor; + lfs3_mdir_fetch(&lfs3, &mrootanchor, + -1, LFS3_MPTR_MROOTANCHOR()) => 0; + if (lfs3_rbyd_eoff(&mrootanchor.rbyd) > GC_COMPACT_THRESH) { break; } - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } // we should be marked as uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing and compacting - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mrootanchor - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mroot - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // mrootanchor should have been compacted - lfsr_mdir_t mrootanchor; - lfsr_mdir_fetch(&lfs, &mrootanchor, - -1, LFSR_MPTR_MROOTANCHOR()) => 0; - assert(lfsr_rbyd_eoff(&mrootanchor.rbyd) <= GC_COMPACT_THRESH); + lfs3_mdir_t mrootanchor; + lfs3_mdir_fetch(&lfs3, &mrootanchor, + -1, LFS3_MPTR_MROOTANCHOR()) => 0; + assert(lfs3_rbyd_eoff(&mrootanchor.rbyd) <= GC_COMPACT_THRESH); // but because we mutated, we're still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mrootanchor should have been compacted - lfsr_mdir_fetch(&lfs, &mrootanchor, - -1, LFSR_MPTR_MROOTANCHOR()) => 0; - assert(lfsr_rbyd_eoff(&mrootanchor.rbyd) <= GC_COMPACT_THRESH); + lfs3_mdir_fetch(&lfs3, &mrootanchor, + -1, LFS3_MPTR_MROOTANCHOR()) => 0; + assert(lfs3_rbyd_eoff(&mrootanchor.rbyd) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_compact_mroot_extend] @@ -5695,110 +5695,110 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' # force early relocations defines.BLOCK_RECYCLES = 0 -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // write to our mdir until >gc_compact_thresh full - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // hack, don't use the internals like this uint8_t wbuf[SIZE]; while ((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file) => 0; } // we should be marked as uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing and compacting - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // it's a bit unclear if we should follow the mroot or stay on the // mroot anchor during extends, so if this breaks in the future // I wouldn't worry too much about it // // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // mdir should have been compacted assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // but because we mutated, we're still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mdir should have been compacted assert((file.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the file for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file, "jellyfish", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file, "jellyfish", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file) => 0; + lfs3_file_rewind(&lfs3, &file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_compact_mroot_split] @@ -5808,42 +5808,42 @@ defines.CKDATA = [false, true] defines.SIZE = 'FILE_CACHE_SIZE/2' # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create enough files to both compact and split - lfs_size_t i = 0; + lfs3_size_t i = 0; while (true) { // we should not have split yet - assert(lfs.mtree.weight == 0); + assert(lfs3.mtree.weight == 0); // we need internals to check this - lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs, + lfs3_ssize_t estimate = lfs3_mdir_estimate__(&lfs3, &file1.b.o.mdir, -1, -1, NULL); assert(estimate >= 0); @@ -5854,113 +5854,113 @@ code = ''' char name[256]; sprintf(name, "medusaaaaaaaaaaaaaaaa%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // we should be marked as uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing and compacting - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // should have split, traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // mdirs should have been compacted assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // but because we mutated, we're still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mdirs should have been compacted assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "jellyfish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "jellyfish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_compact_mtree] @@ -5972,64 +5972,64 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' defines.COMPACTSET = 'range(0x8)' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create three files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; - lfsr_file_t file3; - lfsr_file_open(&lfs, &file3, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file3; + lfs3_file_open(&lfs3, &file3, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file3, wbuf3, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file3) => 0; + lfs3_file_write(&lfs3, &file3, wbuf3, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file3) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "hydroid%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "medusa%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } @@ -6037,83 +6037,83 @@ code = ''' if (COMPACTSET & 0x1) { // hack, don't use the internals like this while ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file1) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file1) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; } } if (COMPACTSET & 0x2) { // hack, don't use the internals like this while ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file2) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file2) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; } } if (COMPACTSET & 0x4) { // hack, don't use the internals like this while ((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file3) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file3) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file3, wbuf3, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file3) => 0; + lfs3_file_write(&lfs3, &file3, wbuf3, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file3) => 0; } } // we should be marked as uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing and compacting - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; if (COMPACTSET) { // mdirs should have been compacted @@ -6122,24 +6122,24 @@ code = ''' assert((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // but because we mutated, we're still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mdirs should have been compacted assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -6147,45 +6147,45 @@ code = ''' assert((file3.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_file_close(&lfs, &file3) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "jellyfish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file3, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_file_close(&lfs3, &file3) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "jellyfish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file3, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_rewind(&lfs, &file3) => 0; - lfsr_file_read(&lfs, &file3, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file3) => 0; + lfs3_file_read(&lfs3, &file3, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_file_close(&lfs, &file3) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_file_close(&lfs3, &file3) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_compact_mtree_split] @@ -6195,87 +6195,87 @@ defines.CKDATA = [false, true] defines.SIZE = 'FILE_CACHE_SIZE/2' # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' -in = 'lfs.c' +in = 'lfs3.c' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create four files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "jellyfish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "jellyfish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; - lfsr_file_t file3; - lfsr_file_open(&lfs, &file3, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file3; + lfs3_file_open(&lfs3, &file3, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf3[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf3[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file3, wbuf3, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file3) => 0; + lfs3_file_write(&lfs3, &file3, wbuf3, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file3) => 0; - lfsr_file_t file4; - lfsr_file_open(&lfs, &file4, "squid", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file4; + lfs3_file_open(&lfs3, &file4, "squid", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf4[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf4[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file4, wbuf4, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file4) => 0; + lfs3_file_write(&lfs3, &file4, wbuf4, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file4) => 0; // create enough files for mroot to split twice - lfs_size_t i = 0; - while (lfs.mtree.weight == 0) { + lfs3_size_t i = 0; + while (lfs3.mtree.weight == 0) { char name[256]; sprintf(name, "hydroid%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } i = 0; - lfs_size_t orig = lfs.mtree.weight; - while (lfs.mtree.weight == orig) { + lfs3_size_t orig = lfs3.mtree.weight; + while (lfs3.mtree.weight == orig) { char name[256]; sprintf(name, "polyp%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // create enough files to both compact and split i = 0; - orig = lfs.mtree.weight; + orig = lfs3.mtree.weight; while (true) { // we should not have split yet - assert(lfs.mtree.weight == orig); + assert(lfs3.mtree.weight == orig); // we need internals to check this - lfs_ssize_t estimate = lfsr_mdir_estimate__(&lfs, + lfs3_ssize_t estimate = lfs3_mdir_estimate__(&lfs3, &file2.b.o.mdir, -1, -1, NULL); assert(estimate >= 0); @@ -6286,62 +6286,62 @@ code = ''' char name[256]; sprintf(name, "medusaaaaaaaaaaaaaaaa%03x", i); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_close(&lfs3, &file) => 0; i += 1; } // we should be marked as uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing and compacting - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // should have split, traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse mdir - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // mdirs should have been compacted assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -6350,23 +6350,23 @@ code = ''' assert((file4.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // but because we mutated, we're still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mdirs should have been compacted assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); @@ -6375,52 +6375,52 @@ code = ''' assert((file4.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_file_close(&lfs, &file3) => 0; - lfsr_file_close(&lfs, &file4) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "jellyfish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file3, "octopus", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file4, "squid", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_file_close(&lfs3, &file3) => 0; + lfs3_file_close(&lfs3, &file4) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "jellyfish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file3, "octopus", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file4, "squid", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); - lfsr_file_rewind(&lfs, &file3) => 0; - lfsr_file_read(&lfs, &file3, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file3) => 0; + lfs3_file_read(&lfs3, &file3, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf3, SIZE) == 0); - lfsr_file_rewind(&lfs, &file4) => 0; - lfsr_file_read(&lfs, &file4, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file4) => 0; + lfs3_file_read(&lfs3, &file4, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf4, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_file_close(&lfs, &file3) => 0; - lfsr_file_close(&lfs, &file4) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_file_close(&lfs3, &file3) => 0; + lfs3_file_close(&lfs3, &file4) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -6438,32 +6438,32 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create this many orphaned files // @@ -6472,104 +6472,107 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // we should be marked as inconsistent now - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS > 0) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS > 0) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS > 3) { // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); // which means there shouldn't be that many files left - assert(lfs.mtree.weight <= (2 << lfs.mbits)); + assert(lfs3.mtree.weight <= (2 << lfs3.mbits)); assert(file1.b.o.mdir.rbyd.weight <= 3); assert(file2.b.o.mdir.rbyd.weight <= 3); // and we should be marked as consistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((!LOOKAHEAD || ORPHANS > 0) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta - | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0) - | ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0))); + | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS3_I_CKMETA : 0) + | ((!CKDATA || ORPHANS > 0) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_conflict] @@ -6581,54 +6584,54 @@ defines.SIZE = 'FILE_CACHE_SIZE/2' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // we should not be marked as inconsistent - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // create this many orphaned files @@ -6638,80 +6641,83 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // keep traversing if (ORPHANS <= 3) { // traverse mroot - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); } else { // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should be able to clean up grms - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); // if we introduce actual orphans, me _must not_ clear the orphan flag if (ORPHANS >= 3) { - assert(lfs.flags & LFS_I_MKCONSISTENT); + assert(lfs3.flags & LFS3_I_MKCONSISTENT); } // if we introduced actual orphans, we _must_ be marked as inconsistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS >= 3) ? LFS_I_MKCONSISTENT : 0) - | ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((ORPHANS >= 3) ? LFS3_I_MKCONSISTENT : 0) + | ((!LOOKAHEAD || ORPHANS > 0) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta - | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0) - | ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0))); + | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS3_I_CKMETA : 0) + | ((!CKDATA || ORPHANS > 0) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_btree] @@ -6727,32 +6733,32 @@ defines.SIZE = '2*FRAGMENT_SIZE' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create this many orphaned files // @@ -6761,118 +6767,121 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // we should be marked as inconsistent now - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS > 0) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS > 0) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); // which means there shouldn't be that many files left - assert(lfs.mtree.weight <= (2 << lfs.mbits)); + assert(lfs3.mtree.weight <= (2 << lfs3.mbits)); assert(file1.b.o.mdir.rbyd.weight <= 3); assert(file2.b.o.mdir.rbyd.weight <= 3); // and we should be marked as consistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((!LOOKAHEAD || ORPHANS > 0) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta - | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0) - | ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0))); + | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS3_I_CKMETA : 0) + | ((!CKDATA || ORPHANS > 0) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_btree_uncreat] @@ -6888,32 +6897,32 @@ defines.SIZE = '2*FRAGMENT_SIZE' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // create this many orphaned files // @@ -6922,118 +6931,121 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // we should be marked as inconsistent now - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS > 0) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS > 0) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse btree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); // which means there shouldn't be that many files left - assert(lfs.mtree.weight <= (2 << lfs.mbits)); + assert(lfs3.mtree.weight <= (2 << lfs3.mbits)); assert(file1.b.o.mdir.rbyd.weight <= 3); assert(file2.b.o.mdir.rbyd.weight <= 3); // and we should be marked as consistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((!LOOKAHEAD || ORPHANS > 0) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta - | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0) - | ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0))); + | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS3_I_CKMETA : 0) + | ((!CKDATA || ORPHANS > 0) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_bshrub] @@ -7050,32 +7062,32 @@ defines.SIZE = 'BLOCK_SIZE' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create this many orphaned files // @@ -7084,126 +7096,129 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // we should be marked as inconsistent now - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS > 0) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS > 0) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); // which means there shouldn't be that many files left - assert(lfs.mtree.weight <= (2 << lfs.mbits)); + assert(lfs3.mtree.weight <= (2 << lfs3.mbits)); assert(file1.b.o.mdir.rbyd.weight <= 3); assert(file2.b.o.mdir.rbyd.weight <= 3); // and we should be marked as consistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((!LOOKAHEAD || ORPHANS > 0) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta - | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0) - | ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0))); + | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS3_I_CKMETA : 0) + | ((!CKDATA || ORPHANS > 0) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_bshrub_uncreat] @@ -7220,32 +7235,32 @@ defines.SIZE = 'BLOCK_SIZE' # >2 => requires orphans defines.ORPHANS = [0, 1, 2, 3, 100] code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_flush(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_flush(&lfs3, &file2) => 0; // create this many orphaned files // @@ -7254,126 +7269,129 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // we should be marked as inconsistent now - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS > 0) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS > 0) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS <= 3) { // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } else { // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); // traverse bshrub - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); // which means there shouldn't be that many files left - assert(lfs.mtree.weight <= (2 << lfs.mbits)); + assert(lfs3.mtree.weight <= (2 << lfs3.mbits)); assert(file1.b.o.mdir.rbyd.weight <= 3); assert(file2.b.o.mdir.rbyd.weight <= 3); // and we should be marked as consistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD || ORPHANS > 0) ? LFS_I_LOOKAHEAD : 0) - | LFS_I_COMPACT + ((!LOOKAHEAD || ORPHANS > 0) ? LFS3_I_LOOKAHEAD : 0) + | LFS3_I_COMPACT // note ckdata implies ckmeta - | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS_I_CKMETA : 0) - | ((!CKDATA || ORPHANS > 0) ? LFS_I_CKDATA : 0))); + | (((!CKMETA && !CKDATA) || ORPHANS > 0) ? LFS3_I_CKMETA : 0) + | ((!CKDATA || ORPHANS > 0) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_compact] @@ -7387,32 +7405,32 @@ defines.ORPHANS = [0, 1, 2, 3, 100] # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // create this many orphaned files // @@ -7421,88 +7439,91 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // write to our mdirs until >gc_compact_thresh full // // hack, don't use the internals like this while ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file1) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file1) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; } while ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file2) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file2) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; } // we should be marked as inconsistent and uncompacted - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS > 0) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS > 0) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); if (ORPHANS > 3) { // traverse mtree - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_BTREE); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_BTREE); // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; // we should have cleaned up all grms/orphans - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); - assert(!(lfs.flags & LFS_I_MKCONSISTENT)); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); + assert(!(lfs3.flags & LFS3_I_MKCONSISTENT)); // which means there shouldn't be that many files left - assert(lfs.mtree.weight <= (2 << lfs.mbits)); + assert(lfs3.mtree.weight <= (2 << lfs3.mbits)); assert(file1.b.o.mdir.rbyd.weight <= 3); assert(file2.b.o.mdir.rbyd.weight <= 3); @@ -7512,61 +7533,61 @@ code = ''' // we should be marked as consistent, but because we mutated, we're // still marked as uncompacted - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // running another traversal should clear the uncompacted flag - lfsr_traversal_rewind(&lfs, &t) => 0; + lfs3_traversal_rewind(&lfs3, &t) => 0; while (true) { - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); - if (err == LFS_ERR_NOENT) { + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); + if (err == LFS3_ERR_NOENT) { break; } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // mdirs should have been compacted assert((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // uncompacted flag should have been cleared - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((!LOOKAHEAD) ? LFS_I_LOOKAHEAD : 0) + ((!LOOKAHEAD) ? LFS3_I_LOOKAHEAD : 0) // note ckdata implies ckmeta - | ((!CKMETA && !CKDATA) ? LFS_I_CKMETA : 0) - | ((!CKDATA) ? LFS_I_CKDATA : 0))); + | ((!CKMETA && !CKDATA) ? LFS3_I_CKMETA : 0) + | ((!CKDATA) ? LFS3_I_CKDATA : 0))); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_mkconsistent_compact_conflict] @@ -7580,76 +7601,76 @@ defines.ORPHANS = [0, 1, 2, 3, 100] # set compact thresh to minimum defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' code = ''' - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; uint32_t prng = 42; // create two files - lfsr_file_t file1; - lfsr_file_open(&lfs, &file1, "cuttlefish", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file1; + lfs3_file_open(&lfs3, &file1, "cuttlefish", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf1[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; - lfsr_file_t file2; - lfsr_file_open(&lfs, &file2, "octopus", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file2; + lfs3_file_open(&lfs3, &file2, "octopus", + LFS3_O_RDWR | LFS3_O_CREAT | LFS3_O_EXCL) => 0; uint8_t wbuf2[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; // write to our mdirs until >gc_compact_thresh full // // hack, don't use the internals like this while ((file1.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file1) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file1) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf1[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file1, wbuf1, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file1) => 0; + lfs3_file_write(&lfs3, &file1, wbuf1, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file1) => 0; } while ((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH) { - lfsr_file_rewind(&lfs, &file2) => 0; - for (lfs_size_t j = 0; j < SIZE; j++) { + lfs3_file_rewind(&lfs3, &file2) => 0; + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf2[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file2, wbuf2, SIZE) => SIZE; - lfsr_file_sync(&lfs, &file2) => 0; + lfs3_file_write(&lfs3, &file2, wbuf2, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &file2) => 0; } // we should not be marked as inconsistent - struct lfs_fsinfo fsinfo; - lfsr_fs_stat(&lfs, &fsinfo) => 0; + struct lfs3_fsinfo fsinfo; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // try traversing with mkconsistent - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | LFS_T_MKCONSISTENT - | LFS_T_COMPACT - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | LFS3_T_MKCONSISTENT + | LFS3_T_COMPACT + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // traverse mroot - struct lfs_tinfo tinfo; - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + struct lfs3_tinfo tinfo; + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); // create this many orphaned files @@ -7659,43 +7680,46 @@ code = ''' // to close them after all open calls, otherwise we just end up with // one orphan (littlefs is eager to clean up orphans) // - lfsr_file_t orphans[ORPHANS]; - for (lfs_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_t orphans[ORPHANS]; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { char name[256]; sprintf(name, "jellyfish%03x", i); - lfsr_file_open(&lfs, &orphans[i], name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL | LFS_O_DESYNC) => 0; + lfs3_file_open(&lfs3, &orphans[i], name, + LFS3_O_WRONLY + | LFS3_O_CREAT + | LFS3_O_EXCL + | LFS3_O_DESYNC) => 0; } - for (lfs_size_t i = 0; i < ORPHANS; i++) { - lfsr_file_close(&lfs, &orphans[i]) => 0; + for (lfs3_size_t i = 0; i < ORPHANS; i++) { + lfs3_file_close(&lfs3, &orphans[i]) => 0; } // keep traversing if (ORPHANS <= 3) { // traverse mroot - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); assert(tinfo.block == 0 || tinfo.block == 1); } else { // traverse mdirs - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); - lfsr_traversal_read(&lfs, &t, &tinfo) => 0; - assert(tinfo.btype == LFS_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); + lfs3_traversal_read(&lfs3, &t, &tinfo) => 0; + assert(tinfo.btype == LFS3_BTYPE_MDIR); } - lfsr_traversal_read(&lfs, &t, &tinfo) => LFS_ERR_NOENT; - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_read(&lfs3, &t, &tinfo) => LFS3_ERR_NOENT; + lfs3_traversal_close(&lfs3, &t) => 0; // we should be able to clean up grms - assert(lfs.grm.queue[0] == 0); - assert(lfs.grm.queue[1] == 0); + assert(lfs3.grm.queue[0] == 0); + assert(lfs3.grm.queue[1] == 0); // if we introduce actual orphans, me _must not_ clear the orphan flag if (ORPHANS >= 3) { - assert(lfs.flags & LFS_I_MKCONSISTENT); + assert(lfs3.flags & LFS3_I_MKCONSISTENT); } // mdirs should have been compacted @@ -7703,39 +7727,39 @@ code = ''' assert((file2.b.o.mdir.rbyd.eoff & 0x7fffffff) <= GC_COMPACT_THRESH); // if we introduced actual orphans, we _must_ be marked as inconsistent - lfsr_fs_stat(&lfs, &fsinfo) => 0; + lfs3_fs_stat(&lfs3, &fsinfo) => 0; assert(fsinfo.flags == ( - ((ORPHANS >= 3) ? LFS_I_MKCONSISTENT : 0) - | LFS_I_LOOKAHEAD - | LFS_I_COMPACT - | LFS_I_CKMETA - | LFS_I_CKDATA)); + ((ORPHANS >= 3) ? LFS3_I_MKCONSISTENT : 0) + | LFS3_I_LOOKAHEAD + | LFS3_I_COMPACT + | LFS3_I_CKMETA + | LFS3_I_CKDATA)); // check we can still read the files for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_file_open(&lfs, &file1, "cuttlefish", LFS_O_RDONLY) => 0; - lfsr_file_open(&lfs, &file2, "octopus", LFS_O_RDONLY) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; + lfs3_file_open(&lfs3, &file1, "cuttlefish", LFS3_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file2, "octopus", LFS3_O_RDONLY) => 0; } - lfsr_file_rewind(&lfs, &file1) => 0; + lfs3_file_rewind(&lfs3, &file1) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file1, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file1, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf1, SIZE) == 0); - lfsr_file_rewind(&lfs, &file2) => 0; - lfsr_file_read(&lfs, &file2, rbuf, SIZE) => SIZE; + lfs3_file_rewind(&lfs3, &file2) => 0; + lfs3_file_read(&lfs3, &file2, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf2, SIZE) == 0); } - lfsr_file_close(&lfs, &file1) => 0; - lfsr_file_close(&lfs, &file2) => 0; - lfsr_unmount(&lfs) => 0; + lfs3_file_close(&lfs3, &file1) => 0; + lfs3_file_close(&lfs3, &file2) => 0; + lfs3_unmount(&lfs3) => 0; ''' @@ -7761,102 +7785,102 @@ defines.GC_COMPACT_THRESH = 'BLOCK_SIZE/2' defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] code = ''' // test creating directories - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // make this many directories - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - int err = lfsr_mkdir(&lfs, name); - assert(!err || (TEST_PLS && err == LFS_ERR_EXIST)); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || (TEST_PLS && err == LFS3_ERR_EXIST)); // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // check that our mkdir worked - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "dir%03x", i); - lfsr_dir_open(&lfs, &dir, name) => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_open(&lfs3, &dir, name) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_spam_dir_fuzz] @@ -7875,34 +7899,34 @@ defines.SEED = 42 fuzz = 'SEED' code = ''' // test fuzz with dirs - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); - lfs_size_t sim_size = 0; + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); + lfs3_size_t sim_size = 0; // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a pseudo-random op, either mkdir, remove, or rename uint8_t op = TEST_PRNG(&prng) % 3; if (op == 0 || sim_size == 0) { // choose a pseudo-random number, truncate to 3 hexadecimals - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -7910,7 +7934,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); sim_size += 1; sim[j] = x; } @@ -7921,47 +7945,47 @@ code = ''' // create a directory here char name[256]; sprintf(name, "dir%03x", x); - int err = lfsr_mkdir(&lfs, name); - assert(!err || err == LFS_ERR_EXIST); + int err = lfs3_mkdir(&lfs3, name); + assert(!err || err == LFS3_ERR_EXIST); } else if (op == 1) { // choose a pseudo-random entry to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; // remove this directory char name[256]; sprintf(name, "dir%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; } else { // choose a pseudo-random entry to rename, and a pseudo-random // number to rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // already seen and not a noop? if (k < sim_size && sim[k] == y && x != y) { // just delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); sim_size -= 1; } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); if (k > j) { k -= 1; } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); sim[k] = y; } break; @@ -7973,72 +7997,72 @@ code = ''' sprintf(old_name, "dir%03x", x); char new_name[256]; sprintf(new_name, "dir%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // grm should be zero here - assert(lfs.grm_p[0] == 0); + assert(lfs3.grm_p[0] == 0); // test that our directories match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; char name2[256]; sprintf(name2, "dir%03x", sim[j]); assert(strcmp(info.name, name2) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "dir%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_spam_file_many] @@ -8064,86 +8088,86 @@ defines.SIZE = [ if = '(SIZE*N)/BLOCK_SIZE <= 32' code = ''' // test creating files - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; // create this many files uint32_t prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { char name[256]; sprintf(name, "amethyst%03x", i); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our writes worked prng = 42; - for (lfs_size_t i = 0; i < N; i++) { + for (lfs3_size_t i = 0; i < N; i++) { // check with stat char name[256]; sprintf(name, "amethyst%03x", i); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); // try reading the file, note we reset prng above uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_t file; + lfs3_file_t file; uint8_t rbuf[SIZE]; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_spam_file_fuzz] @@ -8172,39 +8196,39 @@ fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' // test fuzz with files - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 3; // creating a new file? if (op == 0 || sim_size == 0) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // associate each file with a prng that generates its contents uint32_t wprng = TEST_PRNG(&prng); // insert into our sim - for (lfs_size_t j = 0;; j++) { + for (lfs3_size_t j = 0;; j++) { if (j >= sim_size || sim[j] >= x) { // already seen? if (j < sim_size && sim[j] == x) { @@ -8213,7 +8237,7 @@ code = ''' } else { // insert memmove(&sim[j+1], &sim[j], - (sim_size-j)*sizeof(lfs_size_t)); + (sim_size-j)*sizeof(lfs3_size_t)); memmove(&sim_prngs[j+1], &sim_prngs[j], (sim_size-j)*sizeof(uint32_t)); sim_size += 1; @@ -8228,24 +8252,24 @@ code = ''' char name[256]; sprintf(name, "amethyst%03x", x); uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - lfsr_file_write(&lfs, &file, wbuf, SIZE) => SIZE; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_TRUNC) => 0; + lfs3_file_write(&lfs3, &file, wbuf, SIZE) => SIZE; + lfs3_file_close(&lfs3, &file) => 0; // deleting a file? } else if (op == 1) { // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -8253,25 +8277,25 @@ code = ''' // delete this file char name[256]; sprintf(name, "amethyst%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // renaming a file? } else { // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); sim_size -= 1; @@ -8284,7 +8308,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); if (k > j) { @@ -8292,7 +8316,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); sim[k] = y; @@ -8307,87 +8331,87 @@ code = ''' sprintf(old_name, "amethyst%03x", x); char new_name[256]; sprintf(new_name, "amethyst%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; } // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check that our files match our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // check the file contents - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "amethyst%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_spam_fwrite_fuzz] @@ -8425,133 +8449,133 @@ if = [ ] code = ''' // test with complex file writes - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // create a file - lfsr_file_t file; - lfsr_file_open(&lfs, &file, "hello", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, "hello", + LFS3_O_WRONLY | LFS3_O_CREAT | LFS3_O_EXCL) => 0; // simulate our file in ram uint8_t sim[SIZE]; - lfs_off_t size; + lfs3_off_t size; uint32_t prng = SEED; if (INIT == 0) { memset(sim, 0, SIZE); size = 0; } else if (INIT == 1) { - for (lfs_size_t i = 0; i < SIZE; i++) { + for (lfs3_size_t i = 0; i < SIZE; i++) { sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } - lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; + lfs3_file_write(&lfs3, &file, sim, SIZE) => SIZE; size = SIZE; } else { memset(sim, 0, SIZE); - lfsr_file_truncate(&lfs, &file, SIZE) => 0; + lfs3_file_truncate(&lfs3, &file, SIZE) => 0; size = SIZE; } // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { // choose a random location - lfs_off_t off = TEST_PRNG(&prng) % SIZE; + lfs3_off_t off = TEST_PRNG(&prng) % SIZE; // and a random size, up to the chunk size - lfs_size_t chunk = lfs_min( + lfs3_size_t chunk = lfs3_min( (TEST_PRNG(&prng) % (CHUNK+1-1)) + 1, SIZE - off); // update sim - for (lfs_size_t j = 0; j < chunk; j++) { + for (lfs3_size_t j = 0; j < chunk; j++) { sim[off+j] = 'a' + (TEST_PRNG(&prng) % 26); } - size = lfs_max(size, off+chunk); + size = lfs3_max(size, off+chunk); // update file - lfsr_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfsr_file_write(&lfs, &file, &sim[off], chunk) => chunk; + lfs3_file_seek(&lfs3, &file, off, LFS3_SEEK_SET) => off; + lfs3_file_write(&lfs3, &file, &sim[off], chunk) => chunk; // sync? if (SYNC) { - lfsr_file_sync(&lfs, &file) => 0; + lfs3_file_sync(&lfs3, &file) => 0; } // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; for (int remount = 0; remount < 2; remount++) { // remount? if (remount) { - lfsr_unmount(&lfs) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_unmount(&lfs3) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; } // check our file with stat - struct lfs_info info; - lfsr_stat(&lfs, "hello", &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, "hello", &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); // and with dir read - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "hello") == 0); - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == size); - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; // try reading our file - lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs3_file_open(&lfs3, &file, "hello", LFS3_O_RDONLY) => 0; // is size correct? - lfsr_file_size(&lfs, &file) => size; + lfs3_file_size(&lfs3, &file) => size; // try reading uint8_t rbuf[2*SIZE]; memset(rbuf, 0xaa, 2*SIZE); - lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size; + lfs3_file_read(&lfs3, &file, rbuf, 2*SIZE) => size; // does our file match our simulation? assert(memcmp(rbuf, sim, size) == 0); - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_spam_uz_fuzz] @@ -8580,38 +8604,38 @@ fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' // test with uncreats, zombies, etc - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 5; @@ -8622,13 +8646,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = false; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { exist = true; wprng = sim_prngs[j]; @@ -8642,23 +8666,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -8670,7 +8694,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -8679,7 +8703,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -8699,26 +8723,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { // new prng sim_prngs[k] = wprng; @@ -8729,7 +8753,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -8745,8 +8769,8 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; bool sticky = sim_files[j]->sticky; bool zombie = sim_files[j]->zombie; @@ -8754,10 +8778,10 @@ code = ''' // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -8768,7 +8792,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -8776,10 +8800,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -8797,17 +8821,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -8815,7 +8839,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -8828,9 +8852,9 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; @@ -8839,16 +8863,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -8864,7 +8888,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -8874,7 +8898,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -8888,7 +8912,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -8901,108 +8925,108 @@ code = ''' } // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; ''' [cases.test_traversal_spam_uzd_fuzz] @@ -9031,39 +9055,39 @@ fuzz = 'SEED' if = '(SIZE*N)/BLOCK_SIZE <= 16' code = ''' // test with uncreats, zombies, dirs, etc - lfs_t lfs; - lfsr_format(&lfs, LFS_F_RDWR, CFG) => 0; - lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; + lfs3_t lfs3; + lfs3_format(&lfs3, LFS3_F_RDWR, CFG) => 0; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; // set up a simulation to compare against - lfs_size_t *sim = malloc(N*sizeof(lfs_size_t)); + lfs3_size_t *sim = malloc(N*sizeof(lfs3_size_t)); uint32_t *sim_prngs = malloc(N*sizeof(uint32_t)); bool *sim_isstickys = malloc(N*sizeof(bool)); bool *sim_isdirs = malloc(N*sizeof(bool)); - lfs_size_t sim_size = 0; + lfs3_size_t sim_size = 0; typedef struct sim_file { - lfs_size_t x; + lfs3_size_t x; bool sticky; bool zombie; uint32_t prng; - lfsr_file_t file; + lfs3_file_t file; } sim_file_t; sim_file_t **sim_files = malloc(N*sizeof(sim_file_t*)); - lfs_size_t sim_file_count = 0; + lfs3_size_t sim_file_count = 0; // open a traversal - lfsr_traversal_t t; - lfsr_traversal_open(&lfs, &t, - LFS_T_RDWR - | ((MKCONSISTENT) ? LFS_T_MKCONSISTENT : 0) - | ((LOOKAHEAD) ? LFS_T_LOOKAHEAD : 0) - | ((COMPACT) ? LFS_T_COMPACT : 0) - | ((CKMETA) ? LFS_T_CKMETA : 0) - | ((CKDATA) ? LFS_T_CKDATA : 0)) => 0; + lfs3_traversal_t t; + lfs3_traversal_open(&lfs3, &t, + LFS3_T_RDWR + | ((MKCONSISTENT) ? LFS3_T_MKCONSISTENT : 0) + | ((LOOKAHEAD) ? LFS3_T_LOOKAHEAD : 0) + | ((COMPACT) ? LFS3_T_COMPACT : 0) + | ((CKMETA) ? LFS3_T_CKMETA : 0) + | ((CKDATA) ? LFS3_T_CKDATA : 0)) => 0; uint32_t prng = SEED; - for (lfs_size_t i = 0; i < OPS; i++) { + for (lfs3_size_t i = 0; i < OPS; i++) { nonsense:; // choose which operation to do uint8_t op = TEST_PRNG(&prng) % 8; @@ -9074,13 +9098,13 @@ code = ''' goto nonsense; } // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; // already exists? bool exist = true; uint32_t wprng = 0; bool sticky = true; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim[j] == x) { if (sim_isdirs[j]) { goto nonsense; @@ -9097,23 +9121,23 @@ code = ''' sticky = true; } - lfs_size_t j = sim_file_count; + lfs3_size_t j = sim_file_count; sim_files[j] = malloc(sizeof(sim_file_t)); // open the actual file char name[256]; sprintf(name, "batman%03x", x); - lfsr_file_open(&lfs, &sim_files[j]->file, name, - LFS_O_RDWR | LFS_O_CREAT) => 0; + lfs3_file_open(&lfs3, &sim_files[j]->file, name, + LFS3_O_RDWR | LFS3_O_CREAT) => 0; // write some initial data if we don't exist if (!exist || sticky) { uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; } @@ -9125,7 +9149,7 @@ code = ''' sim_file_count++; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -9134,7 +9158,7 @@ code = ''' } else { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -9157,26 +9181,26 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; // choose a random seed uint32_t wprng = TEST_PRNG(&prng); // write to the file - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t wbuf[SIZE]; uint32_t wprng_ = wprng; - for (lfs_size_t k = 0; k < SIZE; k++) { + for (lfs3_size_t k = 0; k < SIZE; k++) { wbuf[k] = 'a' + (TEST_PRNG(&wprng_) % 26); } - lfsr_file_write(&lfs, &sim_files[j]->file, wbuf, SIZE) => SIZE; - lfsr_file_sync(&lfs, &sim_files[j]->file) => 0; + lfs3_file_write(&lfs3, &sim_files[j]->file, wbuf, SIZE) => SIZE; + lfs3_file_sync(&lfs3, &sim_files[j]->file) => 0; // update sim sim_files[j]->prng = wprng; if (!sim_files[j]->zombie) { // update in our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // new prng sim_prngs[k] = wprng; @@ -9187,7 +9211,7 @@ code = ''' } // update related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { // new prng sim_files[k]->prng = wprng; @@ -9203,19 +9227,19 @@ code = ''' goto nonsense; } // choose a random file handle - lfs_size_t j = TEST_PRNG(&prng) % sim_file_count; - lfs_size_t x = sim_files[j]->x; - lfs_size_t sticky = sim_files[j]->sticky; - lfs_size_t zombie = sim_files[j]->zombie; + lfs3_size_t j = TEST_PRNG(&prng) % sim_file_count; + lfs3_size_t x = sim_files[j]->x; + lfs3_size_t sticky = sim_files[j]->sticky; + lfs3_size_t zombie = sim_files[j]->zombie; // this doesn't really test anything, but if we don't close // files eventually everything will end up zombies // close the file without affected disk - lfsr_file_desync(&lfs, &sim_files[j]->file) => 0; - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + lfs3_file_desync(&lfs3, &sim_files[j]->file) => 0; + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; // clobber closed files to try to catch lingering references - memset(&sim_files[j]->file, 0xcc, sizeof(lfsr_file_t)); + memset(&sim_files[j]->file, 0xcc, sizeof(lfs3_file_t)); // remove from list free(sim_files[j]); @@ -9226,7 +9250,7 @@ code = ''' if (sticky && !zombie) { // orphaned? bool orphan = true; - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x && !sim_files[k]->zombie) { orphan = false; } @@ -9234,10 +9258,10 @@ code = ''' // if we were never synced, delete from sim if (orphan) { - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (sim[k] == x) { memmove(&sim[k], &sim[k+1], - (sim_size-(k+1))*sizeof(lfs_size_t)); + (sim_size-(k+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[k], &sim_prngs[k+1], (sim_size-(k+1))*sizeof(uint32_t)); memmove(&sim_isstickys[k], &sim_isstickys[k+1], @@ -9257,17 +9281,17 @@ code = ''' goto nonsense; } // choose a random file to delete - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; // delete this file char name[256]; sprintf(name, "batman%03x", x); - lfsr_remove(&lfs, name) => 0; + lfs3_remove(&lfs3, name) => 0; // delete from our sim memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -9277,7 +9301,7 @@ code = ''' sim_size -= 1; // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -9290,14 +9314,14 @@ code = ''' } // choose a random file to rename, and a random number to // rename to - lfs_size_t j = TEST_PRNG(&prng) % sim_size; - lfs_size_t x = sim[j]; - lfs_size_t y = TEST_PRNG(&prng) % N; + lfs3_size_t j = TEST_PRNG(&prng) % sim_size; + lfs3_size_t x = sim[j]; + lfs3_size_t y = TEST_PRNG(&prng) % N; uint32_t wprng = sim_prngs[j]; bool sticky = sim_isstickys[j]; bool dir = sim_isdirs[j]; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { @@ -9315,16 +9339,16 @@ code = ''' sprintf(old_name, "batman%03x", x); char new_name[256]; sprintf(new_name, "batman%03x", y); - lfsr_rename(&lfs, old_name, new_name) => 0; + lfs3_rename(&lfs3, old_name, new_name) => 0; // update our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= y) { // renaming and replacing if (k < sim_size && sim[k] == y && x != y) { // delete the original entry memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -9343,7 +9367,7 @@ code = ''' } else { // first delete memmove(&sim[j], &sim[j+1], - (sim_size-(j+1))*sizeof(lfs_size_t)); + (sim_size-(j+1))*sizeof(lfs3_size_t)); memmove(&sim_prngs[j], &sim_prngs[j+1], (sim_size-(j+1))*sizeof(uint32_t)); memmove(&sim_isstickys[j], &sim_isstickys[j+1], @@ -9355,7 +9379,7 @@ code = ''' } // then insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -9372,7 +9396,7 @@ code = ''' } // update any related sim files - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { // move source files if (sim_files[k]->x == x) { sim_files[k]->x = y; @@ -9386,9 +9410,9 @@ code = ''' // toss a directory into the mix } else if (op == 5) { // choose a pseudo-random number - lfs_size_t x = TEST_PRNG(&prng) % N; + lfs3_size_t x = TEST_PRNG(&prng) % N; - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // already seen? if (k < sim_size && sim[k] == x) { @@ -9401,14 +9425,14 @@ code = ''' // make the directory char name[256]; sprintf(name, "batman%03x", x); - lfsr_mkdir(&lfs, name) => 0; + lfs3_mkdir(&lfs3, name) => 0; // insert into our sim - for (lfs_size_t k = 0;; k++) { + for (lfs3_size_t k = 0;; k++) { if (k >= sim_size || sim[k] >= x) { // insert memmove(&sim[k+1], &sim[k], - (sim_size-k)*sizeof(lfs_size_t)); + (sim_size-k)*sizeof(lfs3_size_t)); memmove(&sim_prngs[k+1], &sim_prngs[k], (sim_size-k)*sizeof(uint32_t)); memmove(&sim_isstickys[k+1], &sim_isstickys[k], @@ -9424,7 +9448,7 @@ code = ''' } // mark any related sim files as zombied - for (lfs_size_t k = 0; k < sim_file_count; k++) { + for (lfs3_size_t k = 0; k < sim_file_count; k++) { if (sim_files[k]->x == x) { sim_files[k]->zombie = true; } @@ -9432,123 +9456,123 @@ code = ''' } // step the traversal - for (lfs_size_t s = 0; s < STEPS; s++) { - struct lfs_tinfo tinfo; - int err = lfsr_traversal_read(&lfs, &t, &tinfo); - assert(!err || err == LFS_ERR_NOENT); + for (lfs3_size_t s = 0; s < STEPS; s++) { + struct lfs3_tinfo tinfo; + int err = lfs3_traversal_read(&lfs3, &t, &tinfo); + assert(!err || err == LFS3_ERR_NOENT); // restart traversal - if (err == LFS_ERR_NOENT) { - lfsr_traversal_rewind(&lfs, &t) => 0; + if (err == LFS3_ERR_NOENT) { + lfs3_traversal_rewind(&lfs3, &t) => 0; } } } - lfsr_traversal_close(&lfs, &t) => 0; + lfs3_traversal_close(&lfs3, &t) => 0; // check that disk matches our simulation - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - struct lfs_info info; - lfsr_stat(&lfs, name, &info) => 0; + struct lfs3_info info; + lfs3_stat(&lfs3, name, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_t dir; - lfsr_dir_open(&lfs, &dir, "/") => 0; - struct lfs_info info; - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_t dir; + lfs3_dir_open(&lfs3, &dir, "/") => 0; + struct lfs3_info info; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, ".") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, "..") == 0); - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_dir_read(&lfs, &dir, &info) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => 0; assert(strcmp(info.name, name) == 0); if (sim_isdirs[j]) { - assert(info.type == LFS_TYPE_DIR); + assert(info.type == LFS3_TYPE_DIR); assert(info.size == 0); } else if (sim_isstickys[j]) { - assert(info.type == LFS_TYPE_STICKYNOTE); + assert(info.type == LFS3_TYPE_STICKYNOTE); assert(info.size == 0); } else { - assert(info.type == LFS_TYPE_REG); + assert(info.type == LFS3_TYPE_REG); assert(info.size == SIZE); } } - lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; - lfsr_dir_close(&lfs, &dir) => 0; + lfs3_dir_read(&lfs3, &dir, &info) => LFS3_ERR_NOENT; + lfs3_dir_close(&lfs3, &dir) => 0; - for (lfs_size_t j = 0; j < sim_size; j++) { + for (lfs3_size_t j = 0; j < sim_size; j++) { if (sim_isdirs[j]) { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) - => LFS_ERR_ISDIR; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) + => LFS3_ERR_ISDIR; } else { char name[256]; sprintf(name, "batman%03x", sim[j]); - lfsr_file_t file; - lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; + lfs3_file_t file; + lfs3_file_open(&lfs3, &file, name, LFS3_O_RDONLY) => 0; uint32_t wprng = sim_prngs[j]; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } uint8_t rbuf[SIZE]; if (sim_isstickys[j]) { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => 0; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => 0; } else { - lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - lfsr_file_close(&lfs, &file) => 0; + lfs3_file_close(&lfs3, &file) => 0; } } // check that our file handles match our simulation - for (lfs_size_t j = 0; j < sim_file_count; j++) { + for (lfs3_size_t j = 0; j < sim_file_count; j++) { uint32_t wprng = sim_files[j]->prng; uint8_t wbuf[SIZE]; - for (lfs_size_t j = 0; j < SIZE; j++) { + for (lfs3_size_t j = 0; j < SIZE; j++) { wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26); } - lfsr_file_rewind(&lfs, &sim_files[j]->file) => 0; + lfs3_file_rewind(&lfs3, &sim_files[j]->file) => 0; uint8_t rbuf[SIZE]; - lfsr_file_read(&lfs, &sim_files[j]->file, rbuf, SIZE) => SIZE; + lfs3_file_read(&lfs3, &sim_files[j]->file, rbuf, SIZE) => SIZE; assert(memcmp(rbuf, wbuf, SIZE) == 0); } - // clean up sim/lfs + // clean up sim/lfs3 free(sim); free(sim_prngs); free(sim_isstickys); free(sim_isdirs); - for (lfs_size_t j = 0; j < sim_file_count; j++) { - lfsr_file_close(&lfs, &sim_files[j]->file) => 0; + for (lfs3_size_t j = 0; j < sim_file_count; j++) { + lfs3_file_close(&lfs3, &sim_files[j]->file) => 0; free(sim_files[j]); } free(sim_files); - lfsr_unmount(&lfs) => 0; + lfs3_unmount(&lfs3) => 0; '''