Merge branch 'brent-cycle-detection' into rbyd-master

.gitattributes

@@ -1,4 +0,0 @@
-# GitHub really wants to mark littlefs as a python project, telling it to
-# reclassify our test .toml files as C code (which they are 95% of anyways)
-# remedies this
-*.toml linguist-language=c

.github/workflows/post-release.yml

@@ -10,7 +10,7 @@ defaults:
 
 jobs:
   post-release:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       # trigger post-release in dependency repo, this indirection allows the
       # dependency repo to be updated often without affecting this repo. At

.github/workflows/release.yml

@@ -11,7 +11,7 @@ defaults:
 
 jobs:
   release:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     # need to manually check for a couple things
     # - tests passed?
@@ -20,7 +20,7 @@ jobs:
       github.event.workflow_run.head_sha == github.sha}}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
         with:
           ref: ${{github.event.workflow_run.head_sha}}
           # need workflow access since we push branches
@@ -30,29 +30,26 @@ jobs:
           fetch-depth: 0
 
       # try to get results from tests
-      - uses: actions/download-artifact@v4
+      - uses: dawidd6/action-download-artifact@v2
         continue-on-error: true
         with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          run-id: ${{github.event.workflow_run.id}}
-          pattern: '{sizes,sizes-*}'
-          merge-multiple: true
+          workflow: ${{github.event.workflow_run.name}}
+          run_id: ${{github.event.workflow_run.id}}
+          name: sizes
           path: sizes
-      - uses: actions/download-artifact@v4
+      - uses: dawidd6/action-download-artifact@v2
         continue-on-error: true
         with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          run-id: ${{github.event.workflow_run.id}}
-          pattern: '{cov,cov-*}'
-          merge-multiple: true
+          workflow: ${{github.event.workflow_run.name}}
+          run_id: ${{github.event.workflow_run.id}}
+          name: cov
           path: cov
-      - uses: actions/download-artifact@v4
+      - uses: dawidd6/action-download-artifact@v2
         continue-on-error: true
         with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          run-id: ${{github.event.workflow_run.id}}
-          pattern: '{bench,bench-*}'
-          merge-multiple: true
+          workflow: ${{github.event.workflow_run.name}}
+          run_id: ${{github.event.workflow_run.id}}
+          name: bench
           path: bench
 
       - name: find-version
@@ -84,9 +81,7 @@ jobs:
       - name: find-prev-version
         continue-on-error: true
         run: |
-          LFS_PREV_VERSION="$( \
-            git describe --tags --abbrev=0 --match 'v*' \
-            || true)"
+          LFS_PREV_VERSION="$(git describe --tags --abbrev=0 --match 'v*')"
           echo "LFS_PREV_VERSION=$LFS_PREV_VERSION"
           echo "LFS_PREV_VERSION=$LFS_PREV_VERSION" >> $GITHUB_ENV
 
@@ -107,7 +102,7 @@ jobs:
           # sizes table
           i=0
           j=0
-          for c in "" readonly threadsafe multiversion migrate error-asserts
+          for c in "" readonly threadsafe migrate error-asserts
           do
             # per-config results
             c_or_default=${c:-default}
@@ -115,7 +110,7 @@ jobs:
             table[$i,$j]=$c_camel
             ((j+=1))
 
-            for s in code stack structs
+            for s in code stack struct
             do
               f=sizes/thumb${c:+-$c}.$s.csv
               [ -e $f ] && table[$i,$j]=$( \
@@ -245,7 +240,6 @@ jobs:
         run: |
           # create release and patch version tag (vN.N.N)
           # only draft if not a patch release
-          touch release.txt
           [ -e table.txt ] && cat table.txt >> release.txt
           echo >> release.txt
           [ -e changes.txt ] && cat changes.txt >> release.txt

.github/workflows/status.yml

@@ -11,15 +11,14 @@ defaults:
 jobs:
   # forward custom statuses
   status:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: dawidd6/action-download-artifact@v2
         continue-on-error: true
         with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          run-id: ${{github.event.workflow_run.id}}
-          pattern: '{status,status-*}'
-          merge-multiple: true
+          workflow: ${{github.event.workflow_run.name}}
+          run_id: ${{github.event.workflow_run.id}}
+          name: status
           path: status
       - name: update-status
         continue-on-error: true
@@ -61,20 +60,19 @@ jobs:
 
   # forward custom pr-comments
   comment:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     # only run on success (we don't want garbage comments!)
     if: ${{github.event.workflow_run.conclusion == 'success'}}
 
     steps:
       # generated comment?
-      - uses: actions/download-artifact@v4
+      - uses: dawidd6/action-download-artifact@v2
         continue-on-error: true
         with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          run-id: ${{github.event.workflow_run.id}}
-          pattern: '{comment,comment-*}'
-          merge-multiple: true
+          workflow: ${{github.event.workflow_run.name}}
+          run_id: ${{github.event.workflow_run.id}}
+          name: comment
           path: comment
       - name: update-comment
         continue-on-error: true

.github/workflows/test.yml

@@ -14,14 +14,14 @@ env:
 jobs:
   # run tests
   test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
         arch: [x86_64, thumb, mips, powerpc]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -170,27 +170,6 @@ jobs:
           cp lfs.data.csv sizes/${{matrix.arch}}-threadsafe.data.csv
           cp lfs.stack.csv sizes/${{matrix.arch}}-threadsafe.stack.csv
           cp lfs.structs.csv sizes/${{matrix.arch}}-threadsafe.structs.csv
-      - name: sizes-multiversion
-        run: |
-          make clean
-          CFLAGS="$CFLAGS \
-            -DLFS_NO_ASSERT \
-            -DLFS_NO_DEBUG \
-            -DLFS_NO_WARN \
-            -DLFS_NO_ERROR \
-            -DLFS_MULTIVERSION" \
-            make lfs.code.csv lfs.data.csv lfs.stack.csv lfs.structs.csv
-          ./scripts/structs.py -u lfs.structs.csv
-          ./scripts/summary.py lfs.code.csv lfs.data.csv lfs.stack.csv \
-            -bfunction \
-            -fcode=code_size \
-            -fdata=data_size \
-            -fstack=stack_limit --max=stack_limit
-          mkdir -p sizes
-          cp lfs.code.csv sizes/${{matrix.arch}}-multiversion.code.csv
-          cp lfs.data.csv sizes/${{matrix.arch}}-multiversion.data.csv
-          cp lfs.stack.csv sizes/${{matrix.arch}}-multiversion.stack.csv
-          cp lfs.structs.csv sizes/${{matrix.arch}}-multiversion.structs.csv
       - name: sizes-migrate
         run: |
           make clean
@@ -235,9 +214,9 @@ jobs:
 
       # create size statuses
       - name: upload-sizes
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
-          name: sizes-${{matrix.arch}}
+          name: sizes
           path: sizes
       - name: status-sizes
         run: |
@@ -273,16 +252,16 @@ jobs:
             }' | tee status/$(basename $f .csv).json
           done
       - name: upload-status-sizes
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
-          name: status-sizes-${{matrix.arch}}
+          name: status
           path: status
           retention-days: 1
 
       # create cov statuses
       - name: upload-cov
         if: ${{matrix.arch == 'x86_64'}}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
           name: cov
           path: cov
@@ -317,11 +296,11 @@ jobs:
               target_step: env.STEP,
             }' | tee status/$(basename $f .csv)-$s.json
           done
-      - name: upload-status-cov
+      - name: upload-status-sizes
         if: ${{matrix.arch == 'x86_64'}}
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
-          name: status-cov
+          name: status
           path: status
           retention-days: 1
 
@@ -329,14 +308,14 @@ jobs:
   #
   # this grows exponentially, so it doesn't turn out to be that many
   test-pls:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
         pls: [1, 2]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -359,9 +338,9 @@ jobs:
 
   # run with LFS_NO_INTRINSICS to make sure that works
   test-no-intrinsics:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -374,70 +353,11 @@ jobs:
         run: |
           CFLAGS="$CFLAGS -DLFS_NO_INTRINSICS" make test
 
-  # run with all trace options enabled to at least make sure these
-  # all compile
-  test-yes-trace:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: install
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      - name: test-yes-trace
-        run: |
-          CFLAGS="$CFLAGS \
-            -DLFS_YES_TRACE \
-            -DLFS_RAMBD_YES_TRACE \
-            -DLFS_FILEBD_YES_TRACE \
-            -DLFS_RAMBD_YES_TRACE" \
-            make test
-
-  # run LFS_MULTIVERSION tests
-  test-multiversion:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: install
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      - name: test-multiversion
-        run: |
-          CFLAGS="$CFLAGS -DLFS_MULTIVERSION" make test
-
-  # run tests on the older version lfs2.0
-  test-lfs2_0:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: install
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      - name: test-lfs2_0
-        run: |
-          CFLAGS="$CFLAGS -DLFS_MULTIVERSION" \
-          TESTFLAGS="$TESTFLAGS -DDISK_VERSION=0x00020000" \
-            make test
-
   # run under Valgrind to check for memory errors
   test-valgrind:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -451,15 +371,14 @@ jobs:
       # on one geometry
       - name: test-valgrind
         run: |
-          TESTFLAGS="$TESTFLAGS --valgrind --context=1024 -Gdefault -Pnone" \
-            make test
+          TESTFLAGS="$TESTFLAGS --valgrind -Gdefault -Pnone" make test
 
   # test that compilation is warning free under clang
   # run with Clang, mostly to check for Clang-specific warnings
   test-clang:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -480,9 +399,9 @@ jobs:
   #
   # note there's no real benefit to running these on multiple archs
   bench:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -514,7 +433,7 @@ jobs:
 
       # create bench statuses
       - name: upload-bench
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
           name: bench
           path: bench
@@ -548,54 +467,18 @@ jobs:
             }' | tee status/$(basename $f .csv)-$s.json
           done
       - name: upload-status-bench
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
-          name: status-bench
+          name: status
           path: status
           retention-days: 1
 
-  # run compatibility tests using the current master as the previous version
-  test-compat:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        if: ${{github.event_name == 'pull_request'}}
-      # checkout the current pr target into lfsp
-      - uses: actions/checkout@v4
-        if: ${{github.event_name == 'pull_request'}}
-        with:
-          ref: ${{github.event.pull_request.base.ref}}
-          path: lfsp
-      - name: install
-        if: ${{github.event_name == 'pull_request'}}
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      # adjust prefix of lfsp
-      - name: changeprefix
-        if: ${{github.event_name == 'pull_request'}}
-        run: |
-          ./scripts/changeprefix.py lfs lfsp lfsp/*.h lfsp/*.c
-      - name: test-compat
-        if: ${{github.event_name == 'pull_request'}}
-        run: |
-          TESTS=tests/test_compat.toml \
-            SRC="$(find . lfsp -name '*.c' -maxdepth 1 \
-                -and -not -name '*.t.*' \
-                -and -not -name '*.b.*')" \
-            CFLAGS="-DLFSP=lfsp/lfsp.h" \
-            make test
-
   # self-host with littlefs-fuse for a fuzz-like test
   fuse:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     if: ${{!endsWith(github.ref, '-prefix')}}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -605,7 +488,7 @@ jobs:
           gcc --version
           python3 --version
           fusermount -V
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
         with:
           repository: littlefs-project/littlefs-fuse
           ref: v2
@@ -642,10 +525,10 @@ jobs:
 
   # test migration using littlefs-fuse
   migrate:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     if: ${{!endsWith(github.ref, '-prefix')}}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: install
         run: |
           # need a few things
@@ -655,12 +538,12 @@ jobs:
           gcc --version
           python3 --version
           fusermount -V
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
         with:
           repository: littlefs-project/littlefs-fuse
           ref: v2
           path: v2
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
         with:
           repository: littlefs-project/littlefs-fuse
           ref: v1
@@ -714,10 +597,10 @@ jobs:
 
   # status related tasks that run after tests
   status:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [test, bench]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
         if: ${{github.event_name == 'pull_request'}}
       - name: install
         if: ${{github.event_name == 'pull_request'}}
@@ -727,26 +610,23 @@ jobs:
           pip3 install toml
           gcc --version
           python3 --version
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v2
         if: ${{github.event_name == 'pull_request'}}
         continue-on-error: true
         with:
-          pattern: '{sizes,sizes-*}'
-          merge-multiple: true
+          name: sizes
           path: sizes
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v2
         if: ${{github.event_name == 'pull_request'}}
         continue-on-error: true
         with:
-          pattern: '{cov,cov-*}'
-          merge-multiple: true
+          name: cov
           path: cov
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v2
         if: ${{github.event_name == 'pull_request'}}
         continue-on-error: true
         with:
-          pattern: '{bench,bench-*}'
-          merge-multiple: true
+          name: bench
           path: bench
 
       # try to find results from tests
@@ -768,7 +648,7 @@ jobs:
           # sizes table
           i=0
           j=0
-          for c in "" readonly threadsafe multiversion migrate error-asserts
+          for c in "" readonly threadsafe migrate error-asserts
           do
             # per-config results
             c_or_default=${c:-default}
@@ -888,7 +768,7 @@ jobs:
             body: $comment,
           }' | tee comment/comment.json
       - name: upload-comment
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         with:
           name: comment
           path: comment

DESIGN.md

@@ -59,7 +59,7 @@ This leaves us with three major requirements for an embedded filesystem.
    RAM to temporarily store filesystem metadata.
 
    For ROM, this means we need to keep our design simple and reuse code paths
-   where possible. For RAM we have a stronger requirement, all RAM usage is
+   were possible. For RAM we have a stronger requirement, all RAM usage is
    bounded. This means RAM usage does not grow as the filesystem changes in
    size or number of files. This creates a unique challenge as even presumably
    simple operations, such as traversing the filesystem, become surprisingly
@@ -626,7 +626,7 @@ log₂_n_ pointers that skip to different preceding elements of the
 skip-list.
 
 The name comes from heavy use of the [CTZ instruction][wikipedia-ctz], which
-lets us calculate the power-of-two factors efficiently. For a given block _n_,
+lets us calculate the power-of-two factors efficiently. For a give block _n_,
 that block contains ctz(_n_)+1 pointers.
 
 ```

Makefile

@@ -1,5 +1,15 @@
-# overrideable build dir, default is in-place
+ifdef BUILDDIR
+# bit of a hack, but we want to make sure BUILDDIR directory structure
+# is correct before any commands
+$(if $(findstring n,$(MAKEFLAGS)),, $(shell mkdir -p \
+	$(BUILDDIR)/ \
+	$(BUILDDIR)/bd \
+	$(BUILDDIR)/runners \
+	$(BUILDDIR)/tests \
+	$(BUILDDIR)/benches))
+endif
 BUILDDIR ?= .
+
 # overridable target/src/tools/flags/etc
 ifneq ($(wildcard test.c main.c),)
 TARGET ?= $(BUILDDIR)/lfs
@@ -63,7 +73,6 @@ CFLAGS += -fcallgraph-info=su
 CFLAGS += -g3
 CFLAGS += -I.
 CFLAGS += -std=c99 -Wall -Wextra -pedantic
-CFLAGS += -Wmissing-prototypes
 CFLAGS += -ftrack-macro-expansion=0
 ifdef DEBUG
 CFLAGS += -O0
@@ -154,18 +163,6 @@ TESTFLAGS  += --perf-path="$(PERF)"
 BENCHFLAGS += --perf-path="$(PERF)"
 endif
 
-# this is a bit of a hack, but we want to make sure the BUILDDIR
-# directory structure is correct before we run any commands
-ifneq ($(BUILDDIR),.)
-$(if $(findstring n,$(MAKEFLAGS)),, $(shell mkdir -p \
-	$(addprefix $(BUILDDIR)/,$(dir \
-		$(SRC) \
-		$(TESTS) \
-		$(TEST_SRC) \
-		$(BENCHES) \
-		$(BENCH_SRC)))))
-endif
-
 
 # commands
 
@@ -355,7 +352,6 @@ summary-diff sizes-diff: $(OBJ) $(CI)
 
 ## Build the test-runner
 .PHONY: test-runner build-test
-test-runner build-test: CFLAGS+=-Wno-missing-prototypes
 ifndef NO_COV
 test-runner build-test: CFLAGS+=--coverage
 endif
@@ -407,7 +403,6 @@ testmarks-diff: $(TEST_CSV)
 
 ## Build the bench-runner
 .PHONY: bench-runner build-bench
-bench-runner build-bench: CFLAGS+=-Wno-missing-prototypes
 ifdef YES_COV
 bench-runner build-bench: CFLAGS+=--coverage
 endif
@@ -519,9 +514,6 @@ $(BUILDDIR)/runners/bench_runner: $(BENCH_OBJ)
 $(BUILDDIR)/%.o $(BUILDDIR)/%.ci: %.c
 	$(CC) -c -MMD $(CFLAGS) $< -o $(BUILDDIR)/$*.o
 
-$(BUILDDIR)/%.o $(BUILDDIR)/%.ci: $(BUILDDIR)/%.c
-	$(CC) -c -MMD $(CFLAGS) $< -o $(BUILDDIR)/$*.o
-
 $(BUILDDIR)/%.s: %.c
 	$(CC) -S $(CFLAGS) $< -o $@
 

README.md

@@ -199,47 +199,6 @@ The tests assume a Linux environment and can be started with make:
 make test
 ```
 
-Tests are implemented in C in the .toml files found in the `tests` directory.
-When developing a feature or fixing a bug, it is frequently useful to run a
-single test case or suite of tests:
-
-``` bash
-./scripts/test.py -l runners/test_runner  # list available test suites
-./scripts/test.py -L runners/test_runner test_dirs  # list available test cases
-./scripts/test.py runners/test_runner test_dirs  # run a specific test suite
-```
-
-If an assert fails in a test, test.py will try to print information about the
-failure:
-
-``` bash
-tests/test_dirs.toml:1:failure: test_dirs_root:1g12gg2 (PROG_SIZE=16, ERASE_SIZE=512) failed
-tests/test_dirs.toml:5:assert: assert failed with 0, expected eq 42
-    lfs_mount(&lfs, cfg) => 42;
-```
-
-This includes the test id, which can be passed to test.py to run only that
-specific test permutation:
-
-``` bash
-./scripts/test.py runners/test_runner test_dirs_root:1g12gg2  # run a specific test permutation
-./scripts/test.py runners/test_runner test_dirs_root:1g12gg2 --gdb  # drop into gdb on failure
-```
-
-Some other flags that may be useful:
-
-```bash
-./scripts/test.py runners/test_runner -b -j  # run tests in parallel
-./scripts/test.py runners/test_runner -v -O-  # redirect stdout to stdout
-./scripts/test.py runners/test_runner -ddisk  # capture resulting disk image
-```
-
-See `-h/--help` for a full list of available flags:
-
-``` bash
-./scripts/test.py --help
-```
-
 ## License
 
 The littlefs is provided under the [BSD-3-Clause] license. See
@@ -267,36 +226,9 @@ License Identifiers that are here available: http://spdx.org/licenses/
   to create images of the filesystem on your PC. Check if littlefs will fit
   your needs, create images for a later download to the target memory or
   inspect the content of a binary image of the target memory.
-  
-- [littlefs2-rust] - A Rust wrapper for littlefs. This project allows you
-  to use littlefs in a Rust-friendly API, reaping the benefits of Rust's memory
-  safety and other guarantees.
 
-- [nim-littlefs] - A Nim wrapper and API for littlefs. Includes a fuse
-  implementation based on [littlefs-fuse]
-
-- [chamelon] - A pure-OCaml implementation of (most of) littlefs, designed for
-  use with the MirageOS library operating system project. It is interoperable
-  with the reference implementation, with some caveats.
-
-- [littlefs-disk-img-viewer] - A memory-efficient web application for viewing
-  littlefs disk images in your web browser.
-
-- [mklfs] - A command line tool for creating littlefs images. Used in the Lua
-  RTOS ecosystem.
-
-- [mklittlefs] - A command line tool for creating littlefs images. Used in the
-  ESP8266 and RP2040 ecosystem.
-
-- [pico-littlefs-usb] - An interface for littlefs that emulates a FAT12
-  filesystem over USB. Allows mounting littlefs on a host PC without additional
-  drivers.
-
-- [ramcrc32bd] - An example block device using littlefs's 32-bit CRC for
-  error-correction.
-
-- [ramrsbd] - An example block device using Reed-Solomon codes for
-  error-correction.
+- [mklfs] - A command line tool built by the [Lua RTOS] guys for making
+  littlefs images from a host PC. Supports Windows, Mac OS, and Linux.
 
 - [Mbed OS] - The easiest way to get started with littlefs is to jump into Mbed
   which already has block device drivers for most forms of embedded storage.
@@ -311,27 +243,16 @@ License Identifiers that are here available: http://spdx.org/licenses/
   MCUs. It offers static wear-leveling and power-resilience with only a fixed
   _O(|address|)_ pointer structure stored on each block and in RAM.
 
-- [ChaN's FatFs] - A lightweight reimplementation of the infamous FAT filesystem
-  for microcontroller-scale devices. Due to limitations of FAT it can't provide
-  power-loss resilience, but it does allow easy interop with PCs.
 
 [BSD-3-Clause]: https://spdx.org/licenses/BSD-3-Clause.html
 [littlefs-fuse]: https://github.com/geky/littlefs-fuse
 [FUSE]: https://github.com/libfuse/libfuse
 [littlefs-js]: https://github.com/geky/littlefs-js
 [littlefs-js-demo]:http://littlefs.geky.net/demo.html
-[littlefs-python]: https://pypi.org/project/littlefs-python/
-[littlefs2-rust]: https://crates.io/crates/littlefs2
-[nim-littlefs]: https://github.com/Graveflo/nim-littlefs
-[chamelon]: https://github.com/yomimono/chamelon
-[littlefs-disk-img-viewer]: https://github.com/tniessen/littlefs-disk-img-viewer
 [mklfs]: https://github.com/whitecatboard/Lua-RTOS-ESP32/tree/master/components/mklfs/src
-[mklittlefs]: https://github.com/earlephilhower/mklittlefs
-[pico-littlefs-usb]: https://github.com/oyama/pico-littlefs-usb
-[ramcrc32bd]: https://github.com/geky/ramcrc32bd
-[ramrsbd]: https://github.com/geky/ramrsbd
+[Lua RTOS]: https://github.com/whitecatboard/Lua-RTOS-ESP32
 [Mbed OS]: https://github.com/armmbed/mbed-os
 [LittleFileSystem]: https://os.mbed.com/docs/mbed-os/latest/apis/littlefilesystem.html
 [SPIFFS]: https://github.com/pellepl/spiffs
 [Dhara]: https://github.com/dlbeer/dhara
-[ChaN's FatFs]: http://elm-chan.org/fsw/ff/00index_e.html
+[littlefs-python]: https://pypi.org/project/littlefs-python/

SPEC.md

@@ -1,10 +1,10 @@
 ## littlefs technical specification
 
-This is the technical specification of the little filesystem with on-disk
-version lfs2.1. This document covers the technical details of how the littlefs
-is stored on disk for introspection and tooling. This document assumes you are
-familiar with the design of the littlefs, for more info on how littlefs works
-check out [DESIGN.md](DESIGN.md).
+This is the technical specification of the little filesystem. This document
+covers the technical details of how the littlefs is stored on disk for
+introspection and tooling. This document assumes you are familiar with the
+design of the littlefs, for more info on how littlefs works check
+out [DESIGN.md](DESIGN.md).
 
 ```
    | | |     .---._____
@@ -133,6 +133,12 @@ tags XORed together, starting with `0xffffffff`.
 '-------------------'                    '-------------------'
 ```
 
+One last thing to note before we get into the details around tag encoding. Each
+tag contains a valid bit used to indicate if the tag and containing commit is
+valid. This valid bit is the first bit found in the tag and the commit and can
+be used to tell if we've attempted to write to the remaining space in the
+block.
+
 Here's a more complete example of metadata block containing 4 entries:
 
 ```
@@ -185,53 +191,6 @@ Here's a more complete example of metadata block containing 4 entries:
                                              '---- most recent D
 ```
 
-Two things to note before we get into the details around tag encoding:
-
-1. Each tag contains a valid bit used to indicate if the tag and containing
-   commit is valid. After XORing, this bit should always be zero.
-
-   At the end of each commit, the valid bit of the previous tag is XORed
-   with the lowest bit in the type field of the CRC tag. This allows
-   the CRC tag to force the next commit to fail the valid bit test if it
-   has not yet been written to.
-
-2. The valid bit alone is not enough info to know if the next commit has been
-   erased. We don't know the order bits will be programmed in a program block,
-   so it's possible that the next commit had an attempted program that left the
-   valid bit unchanged.
-
-   To ensure we only ever program erased bytes, each commit can contain an
-   optional forward-CRC (FCRC). An FCRC contains a checksum of some amount of
-   bytes in the next commit at the time it was erased.
-
-   ```
-   .-------------------. \      \
-   |  revision count   | |      |
-   |-------------------| |      |
-   |     metadata      | |      |
-   |                   | +---.  +-- current commit
-   |                   | |   |  |
-   |-------------------| |   |  |
-   |       FCRC       ---|-. |  |
-   |-------------------| / | |  |
-   |        CRC       -----|-'  /
-   |-------------------|   |
-   |      padding      |   |        padding (does't need CRC)
-   |                   |   |
-   |-------------------| \ |    \
-   |      erased?      | +-'    |
-   |         |         | |      +-- next commit
-   |         v         | /      |
-   |                   |        /
-   |                   |
-   '-------------------'
-   ```
-
-   If the FCRC is missing or the checksum does not match, we must assume a
-   commit was attempted but failed due to power-loss.
-
-   Note that end-of-block commits do not need an FCRC.
-
 ## Metadata tags
 
 So in littlefs, 32-bit tags describe every type of metadata. And this means
@@ -441,10 +400,9 @@ Superblock fields:
 
 7. **Attr max (32-bits)** - Maximum size of file attributes in bytes.
 
-The superblock must always be the first entry (id 0) in the metadata pair, and
-the name tag must always be the first tag in the metadata pair. This makes it
-so that the magic string "littlefs" will always reside at offset=8 in a valid
-littlefs superblock.
+The superblock must always be the first entry (id 0) in a metadata pair as well
+as be the first entry written to the block. This means that the superblock
+entry can be read from a device using offsets alone.
 
 ---
 #### `0x2xx` LFS_TYPE_STRUCT
@@ -827,41 +785,3 @@ CRC fields:
    are made about the contents.
 
 ---
-#### `0x5ff` LFS_TYPE_FCRC
-
-Added in lfs2.1, the optional FCRC tag contains a checksum of some amount of
-bytes in the next commit at the time it was erased. This allows us to ensure
-that we only ever program erased bytes, even if a previous commit failed due
-to power-loss.
-
-When programming a commit, the FCRC size must be at least as large as the
-program block size. However, the program block is not saved on disk, and can
-change between mounts, so the FCRC size on disk may be different than the
-current program block size.
-
-If the FCRC is missing or the checksum does not match, we must assume a
-commit was attempted but failed due to power-loss.
-
-Layout of the FCRC tag:
-
-```
-        tag                          data
-[--      32      --][--      32      --|--      32      --]
-[1|- 11 -| 10 | 10 ][--      32      --|--      32      --]
- ^    ^     ^    ^            ^- fcrc size       ^- fcrc
- |    |     |    '- size (8)
- |    |     '------ id (0x3ff)
- |    '------------ type (0x5ff)
- '----------------- valid bit
-```
-
-FCRC fields:
-
-1. **FCRC size (32-bits)** - Number of bytes after this commit's CRC tag's
-   padding to include in the FCRC.
-
-2. **FCRC (32-bits)** - CRC of the bytes after this commit's CRC tag's padding
-   when erased. Like the CRC tag, this uses a CRC-32 with a polynomial of
-   `0x04c11db7` initialized with `0xffffffff`.
-
----

bd/lfs_emubd.c

@@ -48,7 +48,6 @@ 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) {
-    lfs_emubd_t *bd = cfg->context;
     lfs_emubd_block_t *block_ = *block;
     if (block_ && block_->rc == 1) {
         // rc == 1? can modify
@@ -57,13 +56,13 @@ static lfs_emubd_block_t *lfs_emubd_mutblock(
     } else if (block_) {
         // rc > 1? need to create a copy
         lfs_emubd_block_t *nblock = malloc(
-                sizeof(lfs_emubd_block_t) + bd->cfg->erase_size);
+                sizeof(lfs_emubd_block_t) + cfg->block_size);
         if (!nblock) {
             return NULL;
         }
 
         memcpy(nblock, block_,
-                sizeof(lfs_emubd_block_t) + bd->cfg->erase_size);
+                sizeof(lfs_emubd_block_t) + cfg->block_size);
         nblock->rc = 1;
 
         lfs_emubd_decblock(block_);
@@ -73,7 +72,7 @@ static lfs_emubd_block_t *lfs_emubd_mutblock(
     } else {
         // no block? need to allocate
         lfs_emubd_block_t *nblock = malloc(
-                sizeof(lfs_emubd_block_t) + bd->cfg->erase_size);
+                sizeof(lfs_emubd_block_t) + cfg->block_size);
         if (!nblock) {
             return NULL;
         }
@@ -82,9 +81,10 @@ static lfs_emubd_block_t *lfs_emubd_mutblock(
         nblock->wear = 0;
 
         // zero for consistency
+        lfs_emubd_t *bd = cfg->context;
         memset(nblock->data,
                 (bd->cfg->erase_value != -1) ? bd->cfg->erase_value : 0,
-                bd->cfg->erase_size);
+                cfg->block_size);
 
         *block = nblock;
         return nblock;
@@ -94,22 +94,22 @@ static lfs_emubd_block_t *lfs_emubd_mutblock(
 
 // emubd create/destroy
 
-int lfs_emubd_create(const struct lfs_config *cfg,
+int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path,
         const struct lfs_emubd_config *bdcfg) {
-    LFS_EMUBD_TRACE("lfs_emubd_create(%p {.context=%p, "
-                ".read=%p, .prog=%p, .erase=%p, .sync=%p}, "
-                "%p {.read_size=%"PRIu32", .prog_size=%"PRIu32", "
-                ".erase_size=%"PRIu32", .erase_count=%"PRIu32", "
-                ".erase_value=%"PRId32", .erase_cycles=%"PRIu32", "
+    LFS_EMUBD_TRACE("lfs_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"}, "
+                "\"%s\", "
+                "%p {.erase_value=%"PRId32", .erase_cycles=%"PRIu32", "
                 ".badblock_behavior=%"PRIu8", .power_cycles=%"PRIu32", "
                 ".powerloss_behavior=%"PRIu8", .powerloss_cb=%p, "
                 ".powerloss_data=%p, .track_branches=%d})",
             (void*)cfg, cfg->context,
             (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
             (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
-            (void*)bdcfg,
-            bdcfg->read_size, bdcfg->prog_size, bdcfg->erase_size,
-            bdcfg->erase_count, bdcfg->erase_value, bdcfg->erase_cycles,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path, (void*)bdcfg, bdcfg->erase_value, bdcfg->erase_cycles,
             bdcfg->badblock_behavior, bdcfg->power_cycles,
             bdcfg->powerloss_behavior, (void*)(uintptr_t)bdcfg->powerloss_cb,
             bdcfg->powerloss_data, bdcfg->track_branches);
@@ -117,26 +117,24 @@ int lfs_emubd_create(const struct lfs_config *cfg,
     bd->cfg = bdcfg;
 
     // allocate our block array, all blocks start as uninitialized
-    bd->blocks = malloc(bd->cfg->erase_count * sizeof(lfs_emubd_block_t*));
+    bd->blocks = malloc(cfg->block_count * sizeof(lfs_emubd_block_t*));
     if (!bd->blocks) {
-        LFS_EMUBD_TRACE("lfs_emubd_create -> %d", LFS_ERR_NOMEM);
+        LFS_EMUBD_TRACE("lfs_emubd_createcfg -> %d", LFS_ERR_NOMEM);
         return LFS_ERR_NOMEM;
     }
-    memset(bd->blocks, 0, bd->cfg->erase_count * sizeof(lfs_emubd_block_t*));
+    memset(bd->blocks, 0, cfg->block_count * sizeof(lfs_emubd_block_t*));
 
     // setup testing things
     bd->readed = 0;
     bd->proged = 0;
     bd->erased = 0;
     bd->power_cycles = bd->cfg->power_cycles;
-    bd->ooo_block = -1;
-    bd->ooo_data = NULL;
     bd->disk = NULL;
 
     if (bd->cfg->disk_path) {
         bd->disk = malloc(sizeof(lfs_emubd_disk_t));
         if (!bd->disk) {
-            LFS_EMUBD_TRACE("lfs_emubd_create -> %d", LFS_ERR_NOMEM);
+            LFS_EMUBD_TRACE("lfs_emubd_createcfg -> %d", LFS_ERR_NOMEM);
             return LFS_ERR_NOMEM;
         }
         bd->disk->rc = 1;
@@ -158,21 +156,21 @@ int lfs_emubd_create(const struct lfs_config *cfg,
         // if we're emulating erase values, we can keep a block around in
         // memory of just the erase state to speed up emulated erases
         if (bd->cfg->erase_value != -1) {
-            bd->disk->scratch = malloc(bd->cfg->erase_size);
+            bd->disk->scratch = malloc(cfg->block_size);
             if (!bd->disk->scratch) {
-                LFS_EMUBD_TRACE("lfs_emubd_create -> %d", LFS_ERR_NOMEM);
+                LFS_EMUBD_TRACE("lfs_emubd_createcfg -> %d", LFS_ERR_NOMEM);
                 return LFS_ERR_NOMEM;
             }
             memset(bd->disk->scratch,
                     bd->cfg->erase_value,
-                    bd->cfg->erase_size);
+                    cfg->block_size);
 
             // go ahead and erase all of the disk, otherwise the file will not
             // match our internal representation
-            for (size_t i = 0; i < bd->cfg->erase_count; i++) {
+            for (size_t i = 0; i < cfg->block_count; i++) {
                 ssize_t res = write(bd->disk->fd,
                         bd->disk->scratch,
-                        bd->cfg->erase_size);
+                        cfg->block_size);
                 if (res < 0) {
                     int err = -errno;
                     LFS_EMUBD_TRACE("lfs_emubd_create -> %d", err);
@@ -182,22 +180,38 @@ int lfs_emubd_create(const struct lfs_config *cfg,
         }
     }
 
-    LFS_EMUBD_TRACE("lfs_emubd_create -> %d", 0);
+    LFS_EMUBD_TRACE("lfs_emubd_createcfg -> %d", 0);
     return 0;
 }
 
+int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
+    LFS_EMUBD_TRACE("lfs_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"}, "
+                "\"%s\")",
+            (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,
+            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);
+    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;
 
     // decrement reference counts
-    for (lfs_block_t i = 0; i < bd->cfg->erase_count; i++) {
+    for (lfs_block_t i = 0; i < cfg->block_count; i++) {
         lfs_emubd_decblock(bd->blocks[i]);
     }
     free(bd->blocks);
 
     // clean up other resources 
-    lfs_emubd_decblock(bd->ooo_data);
     if (bd->disk) {
         bd->disk->rc -= 1;
         if (bd->disk->rc == 0) {
@@ -212,75 +226,6 @@ int lfs_emubd_destroy(const struct lfs_config *cfg) {
 }
 
 
-// powerloss hook
-static int lfs_emubd_powerloss(const struct lfs_config *cfg) {
-    lfs_emubd_t *bd = cfg->context;
-
-    // emulate out-of-order writes?
-    lfs_emubd_block_t *ooo_data = NULL;
-    if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO
-            && bd->ooo_block != -1) {
-        // since writes between syncs are allowed to be out-of-order, it
-        // shouldn't hurt to restore the first write on powerloss, right?
-        ooo_data = bd->blocks[bd->ooo_block];
-        bd->blocks[bd->ooo_block] = lfs_emubd_incblock(bd->ooo_data);
-
-        // mirror to disk file?
-        if (bd->disk
-                && (bd->blocks[bd->ooo_block]
-                    || bd->cfg->erase_value != -1)) {
-            off_t res1 = lseek(bd->disk->fd,
-                    (off_t)bd->ooo_block*bd->cfg->erase_size,
-                    SEEK_SET);
-            if (res1 < 0) {
-                return -errno;
-            }
-
-            ssize_t res2 = write(bd->disk->fd,
-                    (bd->blocks[bd->ooo_block])
-                        ? bd->blocks[bd->ooo_block]->data
-                        : bd->disk->scratch,
-                    bd->cfg->erase_size);
-            if (res2 < 0) {
-                return -errno;
-            }
-        }
-    }
-
-    // simulate power loss
-    bd->cfg->powerloss_cb(bd->cfg->powerloss_data);
-
-    // if we continue, undo out-of-order write emulation
-    if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO
-            && bd->ooo_block != -1) {
-        lfs_emubd_decblock(bd->blocks[bd->ooo_block]);
-        bd->blocks[bd->ooo_block] = ooo_data;
-
-        // mirror to disk file?
-        if (bd->disk
-                && (bd->blocks[bd->ooo_block]
-                    || bd->cfg->erase_value != -1)) {
-            off_t res1 = lseek(bd->disk->fd,
-                    (off_t)bd->ooo_block*bd->cfg->erase_size,
-                    SEEK_SET);
-            if (res1 < 0) {
-                return -errno;
-            }
-
-            ssize_t res2 = write(bd->disk->fd,
-                    (bd->blocks[bd->ooo_block])
-                        ? bd->blocks[bd->ooo_block]->data
-                        : bd->disk->scratch,
-                    bd->cfg->erase_size);
-            if (res2 < 0) {
-                return -errno;
-            }
-        }
-    }
-
-    return 0;
-}
-
 
 // block device API
 
@@ -292,10 +237,10 @@ int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block,
     lfs_emubd_t *bd = cfg->context;
 
     // check if read is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-    LFS_ASSERT(off  % bd->cfg->read_size == 0);
-    LFS_ASSERT(size % bd->cfg->read_size == 0);
-    LFS_ASSERT(off+size <= bd->cfg->erase_size);
+    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);
 
     // get the block
     const lfs_emubd_block_t *b = bd->blocks[block];
@@ -342,10 +287,10 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
     lfs_emubd_t *bd = cfg->context;
 
     // check if write is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-    LFS_ASSERT(off  % bd->cfg->prog_size == 0);
-    LFS_ASSERT(size % bd->cfg->prog_size == 0);
-    LFS_ASSERT(off+size <= bd->cfg->erase_size);
+    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);
 
     // get the block
     lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, &bd->blocks[block]);
@@ -382,7 +327,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
     // mirror to disk file?
     if (bd->disk) {
         off_t res1 = lseek(bd->disk->fd,
-                (off_t)block*bd->cfg->erase_size + (off_t)off,
+                (off_t)block*cfg->block_size + (off_t)off,
                 SEEK_SET);
         if (res1 < 0) {
             int err = -errno;
@@ -416,11 +361,8 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
     if (bd->power_cycles > 0) {
         bd->power_cycles -= 1;
         if (bd->power_cycles == 0) {
-            int err = lfs_emubd_powerloss(cfg);
-            if (err) {
-                LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", err);
-                return err;
-            }
+            // simulate power loss
+            bd->cfg->powerloss_cb(bd->cfg->powerloss_data);
         }
     }
 
@@ -430,23 +372,16 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
 
 int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
     LFS_EMUBD_TRACE("lfs_emubd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
-            (void*)cfg, block, ((lfs_emubd_t*)cfg->context)->cfg->erase_size);
+            (void*)cfg, block, cfg->block_size);
     lfs_emubd_t *bd = cfg->context;
 
     // check if erase is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-
-    // emulate out-of-order writes? save first write
-    if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO
-            && bd->ooo_block == -1) {
-        bd->ooo_block = block;
-        bd->ooo_data = lfs_emubd_incblock(bd->blocks[block]);
-    }
+    LFS_ASSERT(block < cfg->block_count);
 
     // get the block
     lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, &bd->blocks[block]);
     if (!b) {
-        LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", LFS_ERR_NOMEM);
+        LFS_EMUBD_TRACE("lfs_emubd_prog -> %d", LFS_ERR_NOMEM);
         return LFS_ERR_NOMEM;
     }
 
@@ -470,12 +405,12 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
 
     // emulate an erase value?
     if (bd->cfg->erase_value != -1) {
-        memset(b->data, bd->cfg->erase_value, bd->cfg->erase_size);
+        memset(b->data, bd->cfg->erase_value, cfg->block_size);
 
         // mirror to disk file?
         if (bd->disk) {
             off_t res1 = lseek(bd->disk->fd,
-                    (off_t)block*bd->cfg->erase_size,
+                    (off_t)block*cfg->block_size,
                     SEEK_SET);
             if (res1 < 0) {
                 int err = -errno;
@@ -485,7 +420,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
 
             ssize_t res2 = write(bd->disk->fd,
                     bd->disk->scratch,
-                    bd->cfg->erase_size);
+                    cfg->block_size);
             if (res2 < 0) {
                 int err = -errno;
                 LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err);
@@ -495,7 +430,7 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
     }
 
     // track erases
-    bd->erased += bd->cfg->erase_size;
+    bd->erased += cfg->block_size;
     if (bd->cfg->erase_sleep) {
         int err = nanosleep(&(struct timespec){
                 .tv_sec=bd->cfg->erase_sleep/1000000000,
@@ -512,11 +447,8 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
     if (bd->power_cycles > 0) {
         bd->power_cycles -= 1;
         if (bd->power_cycles == 0) {
-            int err = lfs_emubd_powerloss(cfg);
-            if (err) {
-                LFS_EMUBD_TRACE("lfs_emubd_erase -> %d", err);
-                return err;
-            }
+            // simulate power loss
+            bd->cfg->powerloss_cb(bd->cfg->powerloss_data);
         }
     }
 
@@ -526,24 +458,17 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
 
 int lfs_emubd_sync(const struct lfs_config *cfg) {
     LFS_EMUBD_TRACE("lfs_emubd_sync(%p)", (void*)cfg);
-    lfs_emubd_t *bd = cfg->context;
 
-    // emulate out-of-order writes? reset first write, writes
-    // cannot be out-of-order across sync
-    if (bd->cfg->powerloss_behavior == LFS_EMUBD_POWERLOSS_OOO) {
-        lfs_emubd_decblock(bd->ooo_data);
-        bd->ooo_block = -1;
-        bd->ooo_data = NULL;
-    }
+    // do nothing
+    (void)cfg;
 
     LFS_EMUBD_TRACE("lfs_emubd_sync -> %d", 0);
     return 0;
 }
 
-
 /// Additional extended API for driving test features ///
 
-static int lfs_emubd_crc_(const struct lfs_config *cfg,
+static int lfs_emubd_rawcrc(const struct lfs_config *cfg,
         lfs_block_t block, uint32_t *crc) {
     lfs_emubd_t *bd = cfg->context;
 
@@ -572,7 +497,7 @@ int lfs_emubd_crc(const struct lfs_config *cfg,
         lfs_block_t block, uint32_t *crc) {
     LFS_EMUBD_TRACE("lfs_emubd_crc(%p, %"PRIu32", %p)",
             (void*)cfg, block, crc);
-    int err = lfs_emubd_crc_(cfg, block, crc);
+    int err = lfs_emubd_rawcrc(cfg, block, crc);
     LFS_EMUBD_TRACE("lfs_emubd_crc -> %d", err);
     return err;
 }
@@ -583,7 +508,7 @@ int lfs_emubd_bdcrc(const struct lfs_config *cfg, uint32_t *crc) {
     uint32_t crc_ = 0xffffffff;
     for (lfs_block_t i = 0; i < cfg->block_count; i++) {
         uint32_t i_crc;
-        int err = lfs_emubd_crc_(cfg, i, &i_crc);
+        int err = lfs_emubd_rawcrc(cfg, i, &i_crc);
         if (err) {
             LFS_EMUBD_TRACE("lfs_emubd_bdcrc -> %d", err);
             return err;
@@ -648,7 +573,7 @@ lfs_emubd_swear_t lfs_emubd_wear(const struct lfs_config *cfg,
     lfs_emubd_t *bd = cfg->context;
 
     // check if block is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
+    LFS_ASSERT(block < cfg->block_count);
 
     // get the wear
     lfs_emubd_wear_t wear;
@@ -670,7 +595,7 @@ int lfs_emubd_setwear(const struct lfs_config *cfg,
     lfs_emubd_t *bd = cfg->context;
 
     // check if block is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
+    LFS_ASSERT(block < cfg->block_count);
 
     // set the wear
     lfs_emubd_block_t *b = lfs_emubd_mutblock(cfg, &bd->blocks[block]);
@@ -710,13 +635,13 @@ int lfs_emubd_copy(const struct lfs_config *cfg, lfs_emubd_t *copy) {
     lfs_emubd_t *bd = cfg->context;
 
     // lazily copy over our block array
-    copy->blocks = malloc(bd->cfg->erase_count * sizeof(lfs_emubd_block_t*));
+    copy->blocks = malloc(cfg->block_count * sizeof(lfs_emubd_block_t*));
     if (!copy->blocks) {
         LFS_EMUBD_TRACE("lfs_emubd_copy -> %d", LFS_ERR_NOMEM);
         return LFS_ERR_NOMEM;
     }
 
-    for (size_t i = 0; i < bd->cfg->erase_count; i++) {
+    for (size_t i = 0; i < cfg->block_count; i++) {
         copy->blocks[i] = lfs_emubd_incblock(bd->blocks[i]);
     }
 
@@ -725,8 +650,6 @@ int lfs_emubd_copy(const struct lfs_config *cfg, lfs_emubd_t *copy) {
     copy->proged = bd->proged;
     copy->erased = bd->erased;
     copy->power_cycles = bd->power_cycles;
-    copy->ooo_block = bd->ooo_block;
-    copy->ooo_data = lfs_emubd_incblock(bd->ooo_data);
     copy->disk = bd->disk;
     if (copy->disk) {
         copy->disk->rc += 1;

bd/lfs_emubd.h

@@ -36,18 +36,17 @@ extern "C"
 // Not that read-noop is not allowed. Read _must_ return a consistent (but
 // may be arbitrary) value on every read.
 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_PROGERROR,
+    LFS_EMUBD_BADBLOCK_ERASEERROR,
+    LFS_EMUBD_BADBLOCK_READERROR,
+    LFS_EMUBD_BADBLOCK_PROGNOOP,
+    LFS_EMUBD_BADBLOCK_ERASENOOP,
 } lfs_emubd_badblock_behavior_t;
 
 // Mode determining how power-loss behaves during testing. For now this
 // only supports a noop behavior, leaving the data on-disk untouched.
 typedef enum lfs_emubd_powerloss_behavior {
-    LFS_EMUBD_POWERLOSS_NOOP = 0, // Progs are atomic
-    LFS_EMUBD_POWERLOSS_OOO  = 1, // Blocks are written out-of-order
+    LFS_EMUBD_POWERLOSS_NOOP,
 } lfs_emubd_powerloss_behavior_t;
 
 // Type for measuring read/program/erase operations
@@ -68,18 +67,6 @@ typedef int64_t lfs_emubd_ssleep_t;
 
 // emubd config, this is required for testing
 struct lfs_emubd_config {
-    // Minimum size of a read operation in bytes.
-    lfs_size_t read_size;
-
-    // Minimum size of a program operation in bytes.
-    lfs_size_t prog_size;
-
-    // Size of an erase operation in bytes.
-    lfs_size_t erase_size;
-
-    // Number of erase blocks on the device.
-    lfs_size_t erase_count;
-
     // 8-bit erase value to use for simulating erases. -1 does not simulate
     // erases, which can speed up testing by avoiding the extra block-device
     // operations to store the erase value.
@@ -153,8 +140,6 @@ typedef struct lfs_emubd {
     lfs_emubd_io_t proged;
     lfs_emubd_io_t erased;
     lfs_emubd_powercycles_t power_cycles;
-    lfs_ssize_t ooo_block;
-    lfs_emubd_block_t *ooo_data;
     lfs_emubd_disk_t *disk;
 
     const struct lfs_emubd_config *cfg;
@@ -164,7 +149,11 @@ typedef struct lfs_emubd {
 /// Block device API ///
 
 // Create an emulating block device using the geometry in lfs_config
-int lfs_emubd_create(const struct lfs_config *cfg,
+//
+// 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

bd/lfs_filebd.c

@@ -15,22 +15,18 @@
 #include <windows.h>
 #endif
 
-int lfs_filebd_create(const struct lfs_config *cfg, const char *path,
-        const struct lfs_filebd_config *bdcfg) {
+int lfs_filebd_create(const struct lfs_config *cfg, const char *path) {
     LFS_FILEBD_TRACE("lfs_filebd_create(%p {.context=%p, "
-                ".read=%p, .prog=%p, .erase=%p, .sync=%p}, "
-                "\"%s\", "
-                "%p {.read_size=%"PRIu32", .prog_size=%"PRIu32", "
-                ".erase_size=%"PRIu32", .erase_count=%"PRIu32"})",
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
+                "\"%s\")",
             (void*)cfg, cfg->context,
             (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
             (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
-            path,
-            (void*)bdcfg,
-            bdcfg->read_size, bdcfg->prog_size, bdcfg->erase_size,
-            bdcfg->erase_count);
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path, (void*)bdcfg, bdcfg->erase_value);
     lfs_filebd_t *bd = cfg->context;
-    bd->cfg = bdcfg;
 
     // open file
     #ifdef _WIN32
@@ -70,17 +66,17 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
     lfs_filebd_t *bd = cfg->context;
 
     // check if read is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-    LFS_ASSERT(off  % bd->cfg->read_size == 0);
-    LFS_ASSERT(size % bd->cfg->read_size == 0);
-    LFS_ASSERT(off+size <= bd->cfg->erase_size);
+    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);
 
     // zero for reproducibility (in case file is truncated)
     memset(buffer, 0, size);
 
     // read
     off_t res1 = lseek(bd->fd,
-            (off_t)block*bd->cfg->erase_size + (off_t)off, SEEK_SET);
+            (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);
@@ -106,14 +102,14 @@ int lfs_filebd_prog(const struct lfs_config *cfg, lfs_block_t block,
     lfs_filebd_t *bd = cfg->context;
 
     // check if write is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-    LFS_ASSERT(off  % bd->cfg->prog_size == 0);
-    LFS_ASSERT(size % bd->cfg->prog_size == 0);
-    LFS_ASSERT(off+size <= bd->cfg->erase_size);
+    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
     off_t res1 = lseek(bd->fd,
-            (off_t)block*bd->cfg->erase_size + (off_t)off, SEEK_SET);
+            (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);
@@ -133,11 +129,10 @@ int lfs_filebd_prog(const struct lfs_config *cfg, lfs_block_t block,
 
 int lfs_filebd_erase(const struct lfs_config *cfg, lfs_block_t block) {
     LFS_FILEBD_TRACE("lfs_filebd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
-            (void*)cfg, block, ((lfs_filebd_t*)cfg->context)->cfg->erase_size);
-    lfs_filebd_t *bd = cfg->context;
+            (void*)cfg, block, cfg->block_size);
 
     // check if erase is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
+    LFS_ASSERT(block < cfg->block_count);
 
     // erase is a noop
     (void)block;

bd/lfs_filebd.h

@@ -26,31 +26,14 @@ extern "C"
 #endif
 #endif
 
-// filebd config
-struct lfs_filebd_config {
-    // Minimum size of a read operation in bytes.
-    lfs_size_t read_size;
-
-    // Minimum size of a program operation in bytes.
-    lfs_size_t prog_size;
-
-    // Size of an erase operation in bytes.
-    lfs_size_t erase_size;
-
-    // Number of erase blocks on the device.
-    lfs_size_t erase_count;
-};
-
 // filebd state
 typedef struct lfs_filebd {
     int fd;
-    const struct lfs_filebd_config *cfg;
 } lfs_filebd_t;
 
 
-// Create a file block device
-int lfs_filebd_create(const struct lfs_config *cfg, const char *path,
-        const struct lfs_filebd_config *bdcfg);
+// 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);

bd/lfs_rambd.c

@@ -7,19 +7,18 @@
  */
 #include "bd/lfs_rambd.h"
 
-int lfs_rambd_create(const struct lfs_config *cfg,
+int lfs_rambd_createcfg(const struct lfs_config *cfg,
         const struct lfs_rambd_config *bdcfg) {
-    LFS_RAMBD_TRACE("lfs_rambd_create(%p {.context=%p, "
-                ".read=%p, .prog=%p, .erase=%p, .sync=%p}, "
-                "%p {.read_size=%"PRIu32", .prog_size=%"PRIu32", "
-                ".erase_size=%"PRIu32", .erase_count=%"PRIu32", "
-                ".buffer=%p})",
+    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,
-            (void*)bdcfg,
-            bdcfg->read_size, bdcfg->prog_size, bdcfg->erase_size,
-            bdcfg->erase_count, bdcfg->buffer);
+            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;
 
@@ -27,20 +26,35 @@ int lfs_rambd_create(const struct lfs_config *cfg,
     if (bd->cfg->buffer) {
         bd->buffer = bd->cfg->buffer;
     } else {
-        bd->buffer = lfs_malloc(bd->cfg->erase_size * bd->cfg->erase_count);
+        bd->buffer = lfs_malloc(cfg->block_size * cfg->block_count);
         if (!bd->buffer) {
-            LFS_RAMBD_TRACE("lfs_rambd_create -> %d", LFS_ERR_NOMEM);
+            LFS_RAMBD_TRACE("lfs_rambd_createcfg -> %d", LFS_ERR_NOMEM);
             return LFS_ERR_NOMEM;
         }
     }
 
     // zero for reproducibility
-    memset(bd->buffer, 0, bd->cfg->erase_size * bd->cfg->erase_count);
+    memset(bd->buffer, 0, cfg->block_size * cfg->block_count);
 
-    LFS_RAMBD_TRACE("lfs_rambd_create -> %d", 0);
+    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
@@ -60,13 +74,13 @@ int lfs_rambd_read(const struct lfs_config *cfg, lfs_block_t block,
     lfs_rambd_t *bd = cfg->context;
 
     // check if read is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-    LFS_ASSERT(off  % bd->cfg->read_size == 0);
-    LFS_ASSERT(size % bd->cfg->read_size == 0);
-    LFS_ASSERT(off+size <= bd->cfg->erase_size);
+    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*bd->cfg->erase_size + off], size);
+    memcpy(buffer, &bd->buffer[block*cfg->block_size + off], size);
 
     LFS_RAMBD_TRACE("lfs_rambd_read -> %d", 0);
     return 0;
@@ -80,13 +94,13 @@ int lfs_rambd_prog(const struct lfs_config *cfg, lfs_block_t block,
     lfs_rambd_t *bd = cfg->context;
 
     // check if write is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
-    LFS_ASSERT(off  % bd->cfg->prog_size == 0);
-    LFS_ASSERT(size % bd->cfg->prog_size == 0);
-    LFS_ASSERT(off+size <= bd->cfg->erase_size);
+    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*bd->cfg->erase_size + off], buffer, size);
+    memcpy(&bd->buffer[block*cfg->block_size + off], buffer, size);
 
     LFS_RAMBD_TRACE("lfs_rambd_prog -> %d", 0);
     return 0;
@@ -94,11 +108,10 @@ int lfs_rambd_prog(const struct lfs_config *cfg, lfs_block_t block,
 
 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, ((lfs_rambd_t*)cfg->context)->cfg->erase_size);
-    lfs_rambd_t *bd = cfg->context;
+            (void*)cfg, block, cfg->block_size);
 
     // check if erase is valid
-    LFS_ASSERT(block < bd->cfg->erase_count);
+    LFS_ASSERT(block < cfg->block_count);
 
     // erase is a noop
     (void)block;

bd/lfs_rambd.h

@@ -26,20 +26,8 @@ extern "C"
 #endif
 #endif
 
-// rambd config
+// rambd config (optional)
 struct lfs_rambd_config {
-    // Minimum size of a read operation in bytes.
-    lfs_size_t read_size;
-
-    // Minimum size of a program operation in bytes.
-    lfs_size_t prog_size;
-
-    // Size of an erase operation in bytes.
-    lfs_size_t erase_size;
-
-    // Number of erase blocks on the device.
-    lfs_size_t erase_count;
-
     // Optional statically allocated buffer for the block device.
     void *buffer;
 };
@@ -51,8 +39,9 @@ typedef struct lfs_rambd {
 } lfs_rambd_t;
 
 
-// Create a RAM block device
-int lfs_rambd_create(const struct lfs_config *cfg,
+// 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

lfs.h

@@ -21,14 +21,14 @@ extern "C"
 // Software library version
 // Major (top-nibble), incremented on backwards incompatible changes
 // Minor (bottom-nibble), incremented on feature additions
-#define LFS_VERSION 0x0002000a
+#define LFS_VERSION 0x00020005
 #define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16))
 #define LFS_VERSION_MINOR (0xffff & (LFS_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 0x00020001
+#define LFS_DISK_VERSION 0x00020000
 #define LFS_DISK_VERSION_MAJOR (0xffff & (LFS_DISK_VERSION >> 16))
 #define LFS_DISK_VERSION_MINOR (0xffff & (LFS_DISK_VERSION >>  0))
 
@@ -52,15 +52,16 @@ typedef uint32_t lfs_block_t;
 #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.
+// drivers. Limited on disk to <= 4294967296. However, above 2147483647 the
+// functions lfs_file_seek, lfs_file_size, and lfs_file_tell will return
+// incorrect values due to using signed integers. Stored in superblock and
+// must be respected by other littlefs drivers.
 #ifndef LFS_FILE_MAX
 #define LFS_FILE_MAX 2147483647
 #endif
 
 // Maximum size of custom attributes in bytes, may be redefined, but there is
-// no real benefit to using a smaller LFS_ATTR_MAX. Limited to <= 1022. Stored
-// in superblock and must be respected by other littlefs drivers.
+// no real benefit to using a smaller LFS_ATTR_MAX. Limited to <= 1022.
 #ifndef LFS_ATTR_MAX
 #define LFS_ATTR_MAX 1022
 #endif
@@ -204,8 +205,7 @@ struct lfs_config {
     // program sizes.
     lfs_size_t block_size;
 
-    // Number of erasable blocks on the device. Defaults to block_count stored
-    // on disk when zero.
+    // Number of erasable blocks on the device.
     lfs_size_t block_count;
 
     // Number of erase cycles before littlefs evicts metadata logs and moves
@@ -226,20 +226,9 @@ struct lfs_config {
     // 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.
+    // can track 8 blocks. Must be a multiple of 8.
     lfs_size_t lookahead_size;
 
-    // Threshold for metadata compaction during lfs_fs_gc in bytes. Metadata
-    // pairs that exceed this threshold will be compacted during lfs_fs_gc.
-    // Defaults to ~88% block_size when zero, though the default may change
-    // in the future.
-    //
-    // Note this only affects lfs_fs_gc. Normal compactions still only occur
-    // when full.
-    //
-    // Set to -1 to disable metadata compaction during lfs_fs_gc.
-    lfs_size_t compact_thresh;
-
     // Optional statically allocated read buffer. Must be cache_size.
     // By default lfs_malloc is used to allocate this buffer.
     void *read_buffer;
@@ -248,24 +237,25 @@ struct lfs_config {
     // By default lfs_malloc is used to allocate this buffer.
     void *prog_buffer;
 
-    // Optional statically allocated lookahead buffer. Must be lookahead_size.
-    // By default lfs_malloc is used to allocate this buffer.
+    // Optional statically allocated lookahead buffer. Must be lookahead_size
+    // and aligned to a 32-bit boundary. By default lfs_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 or name_max stored on
-    // disk when zero.
+    // the LFS_NAME_MAX define. Defaults to LFS_NAME_MAX when zero. Stored in
+    // superblock and must be respected by other littlefs drivers.
     lfs_size_t name_max;
 
     // Optional upper limit on files in bytes. No downside for larger files
-    // but must be <= LFS_FILE_MAX. Defaults to LFS_FILE_MAX or file_max stored
-    // on disk when zero.
+    // but must be <= LFS_FILE_MAX. Defaults to LFS_FILE_MAX when zero. Stored
+    // in superblock and must be respected by other littlefs drivers.
     lfs_size_t file_max;
 
     // Optional upper limit on custom attributes in bytes. No downside for
     // larger attributes size but must be <= LFS_ATTR_MAX. Defaults to
-    // LFS_ATTR_MAX or attr_max stored on disk when zero.
+    // LFS_ATTR_MAX when zero.
     lfs_size_t attr_max;
 
     // Optional upper limit on total space given to metadata pairs in bytes. On
@@ -273,23 +263,6 @@ struct lfs_config {
     // can help bound the metadata compaction time. Must be <= block_size.
     // Defaults to block_size when zero.
     lfs_size_t metadata_max;
-
-    // Optional upper limit on inlined files in bytes. Inlined files live in
-    // metadata and decrease storage requirements, but may be limited to
-    // improve metadata-related performance. Must be <= cache_size, <=
-    // attr_max, and <= block_size/8. Defaults to the largest possible
-    // inline_max when zero.
-    //
-    // Set to -1 to disable inlined files.
-    lfs_size_t inline_max;
-
-#ifdef LFS_MULTIVERSION
-    // On-disk version to use when writing in the form of 16-bit major version
-    // + 16-bit minor version. This limiting metadata to what is supported by
-    // older minor versions. Note that some features will be lost. Defaults to 
-    // to the most recent minor version when zero.
-    uint32_t disk_version;
-#endif
 };
 
 // File info structure
@@ -307,27 +280,6 @@ struct lfs_info {
     char name[LFS_NAME_MAX+1];
 };
 
-// Filesystem info structure
-struct lfs_fsinfo {
-    // On-disk version.
-    uint32_t disk_version;
-
-    // Size of a logical block in bytes.
-    lfs_size_t block_size;
-
-    // Number of logical blocks in filesystem.
-    lfs_size_t block_count;
-
-    // Upper limit on the length of file names in bytes.
-    lfs_size_t name_max;
-
-    // Upper limit on the size of files in bytes.
-    lfs_size_t file_max;
-
-    // Upper limit on the size of custom attributes in bytes.
-    lfs_size_t attr_max;
-};
-
 // Custom attribute structure, used to describe custom attributes
 // committed atomically during file writes.
 struct lfs_attr {
@@ -449,20 +401,18 @@ typedef struct lfs {
     lfs_gstate_t gdisk;
     lfs_gstate_t gdelta;
 
-    struct lfs_lookahead {
-        lfs_block_t start;
+    struct lfs_free {
+        lfs_block_t off;
         lfs_block_t size;
-        lfs_block_t next;
-        lfs_block_t ckpoint;
-        uint8_t *buffer;
-    } lookahead;
+        lfs_block_t i;
+        lfs_block_t ack;
+        uint32_t *buffer;
+    } free;
 
     const struct lfs_config *cfg;
-    lfs_size_t block_count;
     lfs_size_t name_max;
     lfs_size_t file_max;
     lfs_size_t attr_max;
-    lfs_size_t inline_max;
 
 #ifdef LFS_MIGRATE
     struct lfs1 *lfs1;
@@ -709,12 +659,6 @@ int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
 
 /// Filesystem-level filesystem operations
 
-// Find on-disk info about the filesystem
-//
-// Fills out the fsinfo structure based on the filesystem found on-disk.
-// Returns a negative error code on failure.
-int lfs_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo);
-
 // Finds the current size of the filesystem
 //
 // Note: Result is best effort. If files share COW structures, the returned
@@ -732,46 +676,6 @@ lfs_ssize_t lfs_fs_size(lfs_t *lfs);
 // Returns a negative error code on failure.
 int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
 
-#ifndef LFS_READONLY
-// Attempt to make the filesystem consistent and ready for writing
-//
-// Calling this function is not required, consistency will be implicitly
-// enforced on the first operation that writes to the filesystem, but this
-// function allows the work to be performed earlier and without other
-// filesystem changes.
-//
-// Returns a negative error code on failure.
-int lfs_fs_mkconsistent(lfs_t *lfs);
-#endif
-
-#ifndef LFS_READONLY
-// Attempt any janitorial work
-//
-// This currently:
-// 1. Calls mkconsistent if not already consistent
-// 2. Compacts metadata > compact_thresh
-// 3. Populates the block allocator
-//
-// Though additional janitorial work may be added in the future.
-//
-// Calling this function is not required, but may allow the offloading of
-// expensive janitorial work to a less time-critical code path.
-//
-// Returns a negative error code on failure. Accomplishing nothing is not
-// an error.
-int lfs_fs_gc(lfs_t *lfs);
-#endif
-
-#ifndef LFS_READONLY
-// Grows the filesystem to a new size, updating the superblock with the new
-// block count.
-//
-// Note: This is irreversible.
-//
-// Returns a negative error code on failure.
-int lfs_fs_grow(lfs_t *lfs, lfs_size_t block_count);
-#endif
-
 #ifndef LFS_READONLY
 #ifdef LFS_MIGRATE
 // Attempts to migrate a previous version of littlefs

lfs_util.c

@@ -11,8 +11,6 @@
 #ifndef LFS_CONFIG
 
 
-// If user provides their own CRC impl we don't need this
-#ifndef LFS_CRC
 // Software CRC implementation with small lookup table
 uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
     static const uint32_t rtable[16] = {
@@ -31,7 +29,6 @@ uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
 
     return crc;
 }
-#endif
 
 
 #endif

lfs_util.h

@@ -8,9 +8,6 @@
 #ifndef LFS_UTIL_H
 #define LFS_UTIL_H
 
-#define LFS_STRINGIZE(x) LFS_STRINGIZE2(x)
-#define LFS_STRINGIZE2(x) #x
-
 // 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).
 //
@@ -18,29 +15,15 @@
 // provided by the config file. To start, I would suggest copying lfs_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)
 #else
 
-// Alternatively, users can provide a header file which defines
-// macros and other things consumed by littlefs.
-//
-// For example, provide my_defines.h, which contains
-// something like:
-//
-// #include <stddef.h>
-// extern void *my_malloc(size_t sz);
-// #define LFS_MALLOC(sz) my_malloc(sz)
-//
-// And build littlefs with the header by defining LFS_DEFINES.
-// (-DLFS_DEFINES=my_defines.h)
-
-#ifdef LFS_DEFINES
-#include LFS_STRINGIZE(LFS_DEFINES)
-#endif
-
 // System includes
 #include <stdint.h>
 #include <stdbool.h>
+#include <sys/types.h>
 #include <string.h>
 #include <inttypes.h>
 
@@ -230,22 +213,12 @@ static inline uint32_t lfs_tobe32(uint32_t a) {
 }
 
 // Calculate CRC-32 with polynomial = 0x04c11db7
-#ifdef LFS_CRC
-uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
-    return LFS_CRC(crc, buffer, size)
-}
-#else
 uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size);
-#endif
 
 // Allocate memory, only used if buffers are not provided to littlefs
-//
-// littlefs current has no alignment requirements, as it only allocates
-// byte-level buffers.
+// Note, memory must be 64-bit aligned
 static inline void *lfs_malloc(size_t size) {
-#if defined(LFS_MALLOC)
-    return LFS_MALLOC(size);
-#elif !defined(LFS_NO_MALLOC)
+#ifndef LFS_NO_MALLOC
     return malloc(size);
 #else
     (void)size;
@@ -255,9 +228,7 @@ static inline void *lfs_malloc(size_t size) {
 
 // Deallocate memory, only used if buffers are not provided to littlefs
 static inline void lfs_free(void *p) {
-#if defined(LFS_FREE)
-    LFS_FREE(p);
-#elif !defined(LFS_NO_MALLOC)
+#ifndef LFS_NO_MALLOC
     free(p);
 #else
     (void)p;

runners/bench_runner.c

@@ -1271,9 +1271,9 @@ static void list_geometries(void) {
                 builtin_geometries[g].name,
                 READ_SIZE,
                 PROG_SIZE,
-                ERASE_SIZE,
-                ERASE_COUNT,
-                ERASE_SIZE*ERASE_COUNT);
+                BLOCK_SIZE,
+                BLOCK_COUNT,
+                BLOCK_SIZE*BLOCK_COUNT);
     }
 }
 
@@ -1321,16 +1321,9 @@ void perm_run(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-        .compact_thresh     = COMPACT_THRESH,
-        .metadata_max       = METADATA_MAX,
-        .inline_max         = INLINE_MAX,
     };
 
     struct lfs_emubd_config bdcfg = {
-        .read_size          = READ_SIZE,
-        .prog_size          = PROG_SIZE,
-        .erase_size         = ERASE_SIZE,
-        .erase_count        = ERASE_COUNT,
         .erase_value        = ERASE_VALUE,
         .erase_cycles       = ERASE_CYCLES,
         .badblock_behavior  = BADBLOCK_BEHAVIOR,
@@ -1340,7 +1333,7 @@ void perm_run(
         .erase_sleep        = bench_erase_sleep,
     };
 
-    int err = lfs_emubd_create(&cfg, &bdcfg);
+    int err = lfs_emubd_createcfg(&cfg, bench_disk_path, &bdcfg);
     if (err) {
         fprintf(stderr, "error: could not create block device: %d\n", err);
         exit(-1);
@@ -1768,19 +1761,19 @@ invalid_define:
                                     = BENCH_LIT(sizes[0]);
                             geometry->defines[PROG_SIZE_i]
                                     = BENCH_LIT(sizes[1]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = BENCH_LIT(sizes[2]);
                         } else if (count >= 2) {
                             geometry->defines[PROG_SIZE_i]
                                     = BENCH_LIT(sizes[0]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = BENCH_LIT(sizes[1]);
                         } else {
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = BENCH_LIT(sizes[0]);
                         }
                         if (count >= 4) {
-                            geometry->defines[ERASE_COUNT_i]
+                            geometry->defines[BLOCK_COUNT_i]
                                     = BENCH_LIT(sizes[3]);
                         }
                         optarg = s;
@@ -1812,19 +1805,19 @@ invalid_define:
                                     = BENCH_LIT(sizes[0]);
                             geometry->defines[PROG_SIZE_i]
                                     = BENCH_LIT(sizes[1]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = BENCH_LIT(sizes[2]);
                         } else if (count >= 2) {
                             geometry->defines[PROG_SIZE_i]
                                     = BENCH_LIT(sizes[0]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = BENCH_LIT(sizes[1]);
                         } else {
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = BENCH_LIT(sizes[0]);
                         }
                         if (count >= 4) {
-                            geometry->defines[ERASE_COUNT_i]
+                            geometry->defines[BLOCK_COUNT_i]
                                     = BENCH_LIT(sizes[3]);
                         }
                         optarg = s;

runners/bench_runner.h

@@ -89,32 +89,22 @@ intmax_t bench_define(size_t define);
  
 #define READ_SIZE_i          0
 #define PROG_SIZE_i          1
-#define ERASE_SIZE_i         2
-#define ERASE_COUNT_i        3
-#define BLOCK_SIZE_i         4
-#define BLOCK_COUNT_i        5
-#define CACHE_SIZE_i         6
-#define LOOKAHEAD_SIZE_i     7
-#define COMPACT_THRESH_i     8
-#define METADATA_MAX_i       9
-#define INLINE_MAX_i         10
-#define BLOCK_CYCLES_i       11
-#define ERASE_VALUE_i        12
-#define ERASE_CYCLES_i       13
-#define BADBLOCK_BEHAVIOR_i  14
-#define POWERLOSS_BEHAVIOR_i 15
+#define BLOCK_SIZE_i         2
+#define BLOCK_COUNT_i        3
+#define CACHE_SIZE_i         4
+#define LOOKAHEAD_SIZE_i     5
+#define BLOCK_CYCLES_i       6
+#define ERASE_VALUE_i        7
+#define ERASE_CYCLES_i       8
+#define BADBLOCK_BEHAVIOR_i  9
+#define POWERLOSS_BEHAVIOR_i 10
 
 #define READ_SIZE           bench_define(READ_SIZE_i)
 #define PROG_SIZE           bench_define(PROG_SIZE_i)
-#define ERASE_SIZE          bench_define(ERASE_SIZE_i)
-#define ERASE_COUNT         bench_define(ERASE_COUNT_i)
 #define BLOCK_SIZE          bench_define(BLOCK_SIZE_i)
 #define BLOCK_COUNT         bench_define(BLOCK_COUNT_i)
 #define CACHE_SIZE          bench_define(CACHE_SIZE_i)
 #define LOOKAHEAD_SIZE      bench_define(LOOKAHEAD_SIZE_i)
-#define COMPACT_THRESH      bench_define(COMPACT_THRESH_i)
-#define METADATA_MAX        bench_define(METADATA_MAX_i)
-#define INLINE_MAX          bench_define(INLINE_MAX_i)
 #define BLOCK_CYCLES        bench_define(BLOCK_CYCLES_i)
 #define ERASE_VALUE         bench_define(ERASE_VALUE_i)
 #define ERASE_CYCLES        bench_define(ERASE_CYCLES_i)
@@ -123,16 +113,11 @@ intmax_t bench_define(size_t define);
 
 #define BENCH_IMPLICIT_DEFINES \
     BENCH_DEF(READ_SIZE,          PROG_SIZE) \
-    BENCH_DEF(PROG_SIZE,          ERASE_SIZE) \
-    BENCH_DEF(ERASE_SIZE,         0) \
-    BENCH_DEF(ERASE_COUNT,        (1024*1024)/BLOCK_SIZE) \
-    BENCH_DEF(BLOCK_SIZE,         ERASE_SIZE) \
-    BENCH_DEF(BLOCK_COUNT,        ERASE_COUNT/lfs_max(BLOCK_SIZE/ERASE_SIZE,1))\
+    BENCH_DEF(PROG_SIZE,          BLOCK_SIZE) \
+    BENCH_DEF(BLOCK_SIZE,         0) \
+    BENCH_DEF(BLOCK_COUNT,        (1024*1024)/BLOCK_SIZE) \
     BENCH_DEF(CACHE_SIZE,         lfs_max(64,lfs_max(READ_SIZE,PROG_SIZE))) \
     BENCH_DEF(LOOKAHEAD_SIZE,     16) \
-    BENCH_DEF(COMPACT_THRESH,     0) \
-    BENCH_DEF(METADATA_MAX,       0) \
-    BENCH_DEF(INLINE_MAX,         0) \
     BENCH_DEF(BLOCK_CYCLES,       -1) \
     BENCH_DEF(ERASE_VALUE,        0xff) \
     BENCH_DEF(ERASE_CYCLES,       0) \
@@ -140,7 +125,7 @@ intmax_t bench_define(size_t define);
     BENCH_DEF(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_NOOP)
 
 #define BENCH_GEOMETRY_DEFINE_COUNT 4
-#define BENCH_IMPLICIT_DEFINE_COUNT 16
+#define BENCH_IMPLICIT_DEFINE_COUNT 11
 
 
 #endif

runners/test_runner.c

@@ -1312,9 +1312,9 @@ static void list_geometries(void) {
                 builtin_geometries[g].name,
                 READ_SIZE,
                 PROG_SIZE,
-                ERASE_SIZE,
-                ERASE_COUNT,
-                ERASE_SIZE*ERASE_COUNT);
+                BLOCK_SIZE,
+                BLOCK_COUNT,
+                BLOCK_SIZE*BLOCK_COUNT);
     }
 }
 
@@ -1346,19 +1346,9 @@ static void run_powerloss_none(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-        .compact_thresh     = COMPACT_THRESH,
-        .metadata_max       = METADATA_MAX,
-        .inline_max         = INLINE_MAX,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
-        .read_size          = READ_SIZE,
-        .prog_size          = PROG_SIZE,
-        .erase_size         = ERASE_SIZE,
-        .erase_count        = ERASE_COUNT,
         .erase_value        = ERASE_VALUE,
         .erase_cycles       = ERASE_CYCLES,
         .badblock_behavior  = BADBLOCK_BEHAVIOR,
@@ -1368,7 +1358,7 @@ static void run_powerloss_none(
         .erase_sleep        = test_erase_sleep,
     };
 
-    int err = lfs_emubd_create(&cfg, &bdcfg);
+    int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg);
     if (err) {
         fprintf(stderr, "error: could not create block device: %d\n", err);
         exit(-1);
@@ -1425,19 +1415,9 @@ static void run_powerloss_linear(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-        .compact_thresh     = COMPACT_THRESH,
-        .metadata_max       = METADATA_MAX,
-        .inline_max         = INLINE_MAX,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
-        .read_size          = READ_SIZE,
-        .prog_size          = PROG_SIZE,
-        .erase_size         = ERASE_SIZE,
-        .erase_count        = ERASE_COUNT,
         .erase_value        = ERASE_VALUE,
         .erase_cycles       = ERASE_CYCLES,
         .badblock_behavior  = BADBLOCK_BEHAVIOR,
@@ -1451,7 +1431,7 @@ static void run_powerloss_linear(
         .powerloss_data     = &powerloss_jmp,
     };
 
-    int err = lfs_emubd_create(&cfg, &bdcfg);
+    int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg);
     if (err) {
         fprintf(stderr, "error: could not create block device: %d\n", err);
         exit(-1);
@@ -1521,19 +1501,9 @@ static void run_powerloss_log(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-        .compact_thresh     = COMPACT_THRESH,
-        .metadata_max       = METADATA_MAX,
-        .inline_max         = INLINE_MAX,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
-        .read_size          = READ_SIZE,
-        .prog_size          = PROG_SIZE,
-        .erase_size         = ERASE_SIZE,
-        .erase_count        = ERASE_COUNT,
         .erase_value        = ERASE_VALUE,
         .erase_cycles       = ERASE_CYCLES,
         .badblock_behavior  = BADBLOCK_BEHAVIOR,
@@ -1547,7 +1517,7 @@ static void run_powerloss_log(
         .powerloss_data     = &powerloss_jmp,
     };
 
-    int err = lfs_emubd_create(&cfg, &bdcfg);
+    int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg);
     if (err) {
         fprintf(stderr, "error: could not create block device: %d\n", err);
         exit(-1);
@@ -1615,19 +1585,9 @@ static void run_powerloss_cycles(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-        .compact_thresh     = COMPACT_THRESH,
-        .metadata_max       = METADATA_MAX,
-        .inline_max         = INLINE_MAX,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
-        .read_size          = READ_SIZE,
-        .prog_size          = PROG_SIZE,
-        .erase_size         = ERASE_SIZE,
-        .erase_count        = ERASE_COUNT,
         .erase_value        = ERASE_VALUE,
         .erase_cycles       = ERASE_CYCLES,
         .badblock_behavior  = BADBLOCK_BEHAVIOR,
@@ -1641,7 +1601,7 @@ static void run_powerloss_cycles(
         .powerloss_data     = &powerloss_jmp,
     };
 
-    int err = lfs_emubd_create(&cfg, &bdcfg);
+    int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg);
     if (err) {
         fprintf(stderr, "error: could not create block device: %d\n", err);
         exit(-1);
@@ -1807,19 +1767,9 @@ static void run_powerloss_exhaustive(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-        .compact_thresh     = COMPACT_THRESH,
-        .metadata_max       = METADATA_MAX,
-        .inline_max         = INLINE_MAX,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
-        .read_size          = READ_SIZE,
-        .prog_size          = PROG_SIZE,
-        .erase_size         = ERASE_SIZE,
-        .erase_count        = ERASE_COUNT,
         .erase_value        = ERASE_VALUE,
         .erase_cycles       = ERASE_CYCLES,
         .badblock_behavior  = BADBLOCK_BEHAVIOR,
@@ -1832,7 +1782,7 @@ static void run_powerloss_exhaustive(
         .powerloss_data     = NULL,
     };
 
-    int err = lfs_emubd_create(&cfg, &bdcfg);
+    int err = lfs_emubd_createcfg(&cfg, test_disk_path, &bdcfg);
     if (err) {
         fprintf(stderr, "error: could not create block device: %d\n", err);
         exit(-1);
@@ -2349,19 +2299,19 @@ invalid_define:
                                     = TEST_LIT(sizes[0]);
                             geometry->defines[PROG_SIZE_i]
                                     = TEST_LIT(sizes[1]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = TEST_LIT(sizes[2]);
                         } else if (count >= 2) {
                             geometry->defines[PROG_SIZE_i]
                                     = TEST_LIT(sizes[0]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = TEST_LIT(sizes[1]);
                         } else {
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = TEST_LIT(sizes[0]);
                         }
                         if (count >= 4) {
-                            geometry->defines[ERASE_COUNT_i]
+                            geometry->defines[BLOCK_COUNT_i]
                                     = TEST_LIT(sizes[3]);
                         }
                         optarg = s;
@@ -2393,19 +2343,19 @@ invalid_define:
                                     = TEST_LIT(sizes[0]);
                             geometry->defines[PROG_SIZE_i]
                                     = TEST_LIT(sizes[1]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = TEST_LIT(sizes[2]);
                         } else if (count >= 2) {
                             geometry->defines[PROG_SIZE_i]
                                     = TEST_LIT(sizes[0]);
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = TEST_LIT(sizes[1]);
                         } else {
-                            geometry->defines[ERASE_SIZE_i]
+                            geometry->defines[BLOCK_SIZE_i]
                                     = TEST_LIT(sizes[0]);
                         }
                         if (count >= 4) {
-                            geometry->defines[ERASE_COUNT_i]
+                            geometry->defines[BLOCK_COUNT_i]
                                     = TEST_LIT(sizes[3]);
                         }
                         optarg = s;

runners/test_runner.h

@@ -82,61 +82,43 @@ intmax_t test_define(size_t define);
  
 #define READ_SIZE_i          0
 #define PROG_SIZE_i          1
-#define ERASE_SIZE_i         2
-#define ERASE_COUNT_i        3
-#define BLOCK_SIZE_i         4
-#define BLOCK_COUNT_i        5
-#define CACHE_SIZE_i         6
-#define LOOKAHEAD_SIZE_i     7
-#define COMPACT_THRESH_i     8
-#define METADATA_MAX_i       9
-#define INLINE_MAX_i         10
-#define BLOCK_CYCLES_i       11
-#define ERASE_VALUE_i        12
-#define ERASE_CYCLES_i       13
-#define BADBLOCK_BEHAVIOR_i  14
-#define POWERLOSS_BEHAVIOR_i 15
-#define DISK_VERSION_i       16
+#define BLOCK_SIZE_i         2
+#define BLOCK_COUNT_i        3
+#define CACHE_SIZE_i         4
+#define LOOKAHEAD_SIZE_i     5
+#define BLOCK_CYCLES_i       6
+#define ERASE_VALUE_i        7
+#define ERASE_CYCLES_i       8
+#define BADBLOCK_BEHAVIOR_i  9
+#define POWERLOSS_BEHAVIOR_i 10
 
 #define READ_SIZE           TEST_DEFINE(READ_SIZE_i)
 #define PROG_SIZE           TEST_DEFINE(PROG_SIZE_i)
-#define ERASE_SIZE          TEST_DEFINE(ERASE_SIZE_i)
-#define ERASE_COUNT         TEST_DEFINE(ERASE_COUNT_i)
 #define BLOCK_SIZE          TEST_DEFINE(BLOCK_SIZE_i)
 #define BLOCK_COUNT         TEST_DEFINE(BLOCK_COUNT_i)
 #define CACHE_SIZE          TEST_DEFINE(CACHE_SIZE_i)
 #define LOOKAHEAD_SIZE      TEST_DEFINE(LOOKAHEAD_SIZE_i)
-#define COMPACT_THRESH      TEST_DEFINE(COMPACT_THRESH_i)
-#define METADATA_MAX        TEST_DEFINE(METADATA_MAX_i)
-#define INLINE_MAX          TEST_DEFINE(INLINE_MAX_i)
 #define BLOCK_CYCLES        TEST_DEFINE(BLOCK_CYCLES_i)
 #define ERASE_VALUE         TEST_DEFINE(ERASE_VALUE_i)
 #define ERASE_CYCLES        TEST_DEFINE(ERASE_CYCLES_i)
 #define BADBLOCK_BEHAVIOR   TEST_DEFINE(BADBLOCK_BEHAVIOR_i)
 #define POWERLOSS_BEHAVIOR  TEST_DEFINE(POWERLOSS_BEHAVIOR_i)
-#define DISK_VERSION        TEST_DEFINE(DISK_VERSION_i)
 
 #define TEST_IMPLICIT_DEFINES \
     TEST_DEF(READ_SIZE,          PROG_SIZE) \
-    TEST_DEF(PROG_SIZE,          ERASE_SIZE) \
-    TEST_DEF(ERASE_SIZE,         0) \
-    TEST_DEF(ERASE_COUNT,        (1024*1024)/ERASE_SIZE) \
-    TEST_DEF(BLOCK_SIZE,         ERASE_SIZE) \
-    TEST_DEF(BLOCK_COUNT,        ERASE_COUNT/lfs_max(BLOCK_SIZE/ERASE_SIZE,1)) \
+    TEST_DEF(PROG_SIZE,          BLOCK_SIZE) \
+    TEST_DEF(BLOCK_SIZE,         0) \
+    TEST_DEF(BLOCK_COUNT,        (1024*1024)/BLOCK_SIZE) \
     TEST_DEF(CACHE_SIZE,         lfs_max(64,lfs_max(READ_SIZE,PROG_SIZE))) \
     TEST_DEF(LOOKAHEAD_SIZE,     16) \
-    TEST_DEF(COMPACT_THRESH,     0) \
-    TEST_DEF(METADATA_MAX,       0) \
-    TEST_DEF(INLINE_MAX,         0) \
     TEST_DEF(BLOCK_CYCLES,       -1) \
     TEST_DEF(ERASE_VALUE,        0xff) \
     TEST_DEF(ERASE_CYCLES,       0) \
     TEST_DEF(BADBLOCK_BEHAVIOR,  LFS_EMUBD_BADBLOCK_PROGERROR) \
-    TEST_DEF(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_NOOP) \
-    TEST_DEF(DISK_VERSION,       0)
+    TEST_DEF(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_NOOP)
 
+#define TEST_IMPLICIT_DEFINE_COUNT 11
 #define TEST_GEOMETRY_DEFINE_COUNT 4
-#define TEST_IMPLICIT_DEFINE_COUNT 17
 
 
 #endif

scripts/changeprefix.py

@@ -107,10 +107,7 @@ def main(from_prefix, to_prefix, paths=[], *,
         elif no_renames:
             to_path = from_path
         else:
-            to_path = os.path.join(
-                os.path.dirname(from_path),
-                changeprefix(from_prefix, to_prefix,
-                    os.path.basename(from_path))[0])
+            to_path, _ = changeprefix(from_prefix, to_prefix, from_path)
 
         # rename contents
         changefile(from_prefix, to_prefix, from_path, to_path,

scripts/prettyasserts.py

@@ -35,10 +35,10 @@ LEXEMES = {
     'assert':   ['assert'],
     'arrow':    ['=>'],
     'string':   [r'"(?:\\.|[^"])*"', r"'(?:\\.|[^'])\'"],
-    'paren':    [r'\(', r'\)'],
+    'paren':    ['\(', '\)'],
     'cmp':      CMP.keys(),
-    'logic':    [r'\&\&', r'\|\|'],
-    'sep':      [':', ';', r'\{', r'\}', ','],
+    'logic':    ['\&\&', '\|\|'],
+    'sep':      [':', ';', '\{', '\}', ','],
     'op':       ['->'], # specifically ops that conflict with cmp
 }
 
@@ -86,13 +86,6 @@ def write_header(f, limit=LIMIT):
     f.writeln("}")
     f.writeln()
     f.writeln("__attribute__((unused))")
-    f.writeln("static void __pretty_assert_print_ptr(")
-    f.writeln("        const void *v, size_t size) {")
-    f.writeln("    (void)size;")
-    f.writeln("    printf(\"%p\", v);")
-    f.writeln("}")
-    f.writeln()
-    f.writeln("__attribute__((unused))")
     f.writeln("static void __pretty_assert_print_mem(")
     f.writeln("        const void *v, size_t size) {")
     f.writeln("    const uint8_t *v_ = v;")
@@ -190,23 +183,6 @@ def write_header(f, limit=LIMIT):
         f.writeln("                _rh, strlen(_rh)); \\")
         f.writeln("    } \\")
         f.writeln("} while (0)")
-    for op, cmp in sorted(CMP.items()):
-        # Only EQ and NE are supported when compared to NULL.
-        if cmp not in ['eq', 'ne']:
-            continue
-        f.writeln("#define __PRETTY_ASSERT_PTR_%s(lh, rh) do { \\"
-            % cmp.upper())
-        f.writeln("    const void *_lh = (const void*)(uintptr_t)lh; \\")
-        f.writeln("    const void *_rh = (const void*)(uintptr_t)rh; \\")
-        f.writeln("    if (!(_lh %s _rh)) { \\" % op)
-        f.writeln("        __pretty_assert_fail( \\")
-        f.writeln("                __FILE__, __LINE__, \\")
-        f.writeln("                __pretty_assert_print_ptr, \"%s\", \\"
-            % cmp)
-        f.writeln("                (const void*){_lh}, 0, \\")
-        f.writeln("                (const void*){_rh}, 0); \\")
-        f.writeln("    } \\")
-        f.writeln("} while (0)")
     f.writeln()
     f.writeln()
 
@@ -325,8 +301,6 @@ def p_assert(p):
         cmp = p.expect('cmp') ; p.accept('ws')
         rh = p_expr(p) ; p.accept('ws')
         p.expect(')')
-        if rh == 'NULL' or lh == 'NULL':
-            return mkassert('ptr', CMP[cmp], lh, rh)
         return mkassert('int', CMP[cmp], lh, rh)
     except ParseFailure:
         p.pop(state)

scripts/test.py

@@ -102,9 +102,9 @@ class TestCase:
                 # the runner itself.
                 for v_ in csplit(v):
                     m = re.search(r'\brange\b\s*\('
-                        r'(?P<start>[^,\s]*)'
-                        r'\s*(?:,\s*(?P<stop>[^,\s]*)'
-                        r'\s*(?:,\s*(?P<step>[^,\s]*)\s*)?)?\)',
+                        '(?P<start>[^,\s]*)'
+                        '\s*(?:,\s*(?P<stop>[^,\s]*)'
+                        '\s*(?:,\s*(?P<step>[^,\s]*)\s*)?)?\)',
                         v_)
                     if m:
                         start = (int(m.group('start'), 0)
@@ -163,8 +163,8 @@ class TestSuite:
             code_linenos = []
             for i, line in enumerate(f):
                 match = re.match(
-                    r'(?P<case>\[\s*cases\s*\.\s*(?P<name>\w+)\s*\])'
-                        r'|' r'(?P<code>code\s*=)',
+                    '(?P<case>\[\s*cases\s*\.\s*(?P<name>\w+)\s*\])'
+                        '|' '(?P<code>code\s*=)',
                     line)
                 if match and match.group('case'):
                     case_linenos.append((i+1, match.group('name')))
@@ -602,9 +602,9 @@ def find_perms(runner_, ids=[], **args):
         errors='replace',
         close_fds=False)
     pattern = re.compile(
-        r'^(?P<case>[^\s]+)'
-            r'\s+(?P<flags>[^\s]+)'
-            r'\s+(?P<filtered>\d+)/(?P<perms>\d+)')
+        '^(?P<case>[^\s]+)'
+            '\s+(?P<flags>[^\s]+)'
+            '\s+(?P<filtered>\d+)/(?P<perms>\d+)')
     # skip the first line
     for line in it.islice(proc.stdout, 1, None):
         m = pattern.match(line)
@@ -632,8 +632,8 @@ def find_perms(runner_, ids=[], **args):
         errors='replace',
         close_fds=False)
     pattern = re.compile(
-        r'^(?P<case>[^\s]+)'
-            r'\s+(?P<path>[^:]+):(?P<lineno>\d+)')
+        '^(?P<case>[^\s]+)'
+            '\s+(?P<path>[^:]+):(?P<lineno>\d+)')
     # skip the first line
     for line in it.islice(proc.stdout, 1, None):
         m = pattern.match(line)
@@ -676,8 +676,8 @@ def find_path(runner_, id, **args):
         errors='replace',
         close_fds=False)
     pattern = re.compile(
-        r'^(?P<case>[^\s]+)'
-            r'\s+(?P<path>[^:]+):(?P<lineno>\d+)')
+        '^(?P<case>[^\s]+)'
+            '\s+(?P<path>[^:]+):(?P<lineno>\d+)')
     # skip the first line
     for line in it.islice(proc.stdout, 1, None):
         m = pattern.match(line)
@@ -706,7 +706,7 @@ def find_defines(runner_, id, **args):
         errors='replace',
         close_fds=False)
     defines = co.OrderedDict()
-    pattern = re.compile(r'^(?P<define>\w+)=(?P<value>.+)')
+    pattern = re.compile('^(?P<define>\w+)=(?P<value>.+)')
     for line in proc.stdout:
         m = pattern.match(line)
         if m:
@@ -781,12 +781,12 @@ def run_stage(name, runner_, ids, stdout_, trace_, output_, **args):
     failures = []
     killed = False
 
-    pattern = re.compile(r'^(?:'
-            r'(?P<op>running|finished|skipped|powerloss) '
-                r'(?P<id>(?P<case>[^:]+)[^\s]*)'
-            r'|' r'(?P<path>[^:]+):(?P<lineno>\d+):(?P<op_>assert):'
-                r' *(?P<message>.*)'
-        r')$')
+    pattern = re.compile('^(?:'
+            '(?P<op>running|finished|skipped|powerloss) '
+                '(?P<id>(?P<case>[^:]+)[^\s]*)'
+            '|' '(?P<path>[^:]+):(?P<lineno>\d+):(?P<op_>assert):'
+                ' *(?P<message>.*)'
+        ')$')
     locals = th.local()
     children = set()
 

tests/test_alloc.toml

@@ -6,24 +6,17 @@ if = 'BLOCK_CYCLES == -1'
 [cases.test_alloc_parallel]
 defines.FILES = 3
 defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
-defines.GC = [false, true]
-defines.COMPACT_THRESH = ['-1', '0', 'BLOCK_SIZE/2']
-defines.INFER_BC = [false, true]
 code = '''
     const char *names[] = {"bacon", "eggs", "pancakes"};
     lfs_file_t files[FILES];
 
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     lfs_mkdir(&lfs, "breakfast") => 0;
     lfs_unmount(&lfs) => 0;
 
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     for (int n = 0; n < FILES; n++) {
         char path[1024];
         sprintf(path, "breakfast/%s", names[n]);
@@ -31,9 +24,6 @@ code = '''
                 LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
     }
     for (int n = 0; n < FILES; n++) {
-        if (GC) {
-            lfs_fs_gc(&lfs) => 0;
-        }
         size_t size = strlen(names[n]);
         for (lfs_size_t i = 0; i < SIZE; i += size) {
             lfs_file_write(&lfs, &files[n], names[n], size) => size;
@@ -44,7 +34,7 @@ code = '''
     }
     lfs_unmount(&lfs) => 0;
 
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     for (int n = 0; n < FILES; n++) {
         char path[1024];
         sprintf(path, "breakfast/%s", names[n]);
@@ -65,24 +55,17 @@ code = '''
 [cases.test_alloc_serial]
 defines.FILES = 3
 defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
-defines.GC = [false, true]
-defines.COMPACT_THRESH = ['-1', '0', 'BLOCK_SIZE/2']
-defines.INFER_BC = [false, true]
 code = '''
     const char *names[] = {"bacon", "eggs", "pancakes"};
 
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     lfs_mkdir(&lfs, "breakfast") => 0;
     lfs_unmount(&lfs) => 0;
 
     for (int n = 0; n < FILES; n++) {
-        lfs_mount(&lfs, &cfg_) => 0;
+        lfs_mount(&lfs, cfg) => 0;
         char path[1024];
         sprintf(path, "breakfast/%s", names[n]);
         lfs_file_t file;
@@ -92,16 +75,13 @@ code = '''
         uint8_t buffer[1024];
         memcpy(buffer, names[n], size);
         for (int i = 0; i < SIZE; i += size) {
-            if (GC) {
-                lfs_fs_gc(&lfs) => 0;
-            }
             lfs_file_write(&lfs, &file, buffer, size) => size;
         }
         lfs_file_close(&lfs, &file) => 0;
         lfs_unmount(&lfs) => 0;
     }
 
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     for (int n = 0; n < FILES; n++) {
         char path[1024];
         sprintf(path, "breakfast/%s", names[n]);
@@ -123,24 +103,19 @@ code = '''
 defines.FILES = 3
 defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
 defines.CYCLES = [1, 10]
-defines.INFER_BC = [false, true]
 code = '''
     const char *names[] = {"bacon", "eggs", "pancakes"};
     lfs_file_t files[FILES];
 
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
 
     for (int c = 0; c < CYCLES; c++) {
-        lfs_mount(&lfs, &cfg_) => 0;
+        lfs_mount(&lfs, cfg) => 0;
         lfs_mkdir(&lfs, "breakfast") => 0;
         lfs_unmount(&lfs) => 0;
 
-        lfs_mount(&lfs, &cfg_) => 0;
+        lfs_mount(&lfs, cfg) => 0;
         for (int n = 0; n < FILES; n++) {
             char path[1024];
             sprintf(path, "breakfast/%s", names[n]);
@@ -158,7 +133,7 @@ code = '''
         }
         lfs_unmount(&lfs) => 0;
 
-        lfs_mount(&lfs, &cfg_) => 0;
+        lfs_mount(&lfs, cfg) => 0;
         for (int n = 0; n < FILES; n++) {
             char path[1024];
             sprintf(path, "breakfast/%s", names[n]);
@@ -174,7 +149,7 @@ code = '''
         }
         lfs_unmount(&lfs) => 0;
 
-        lfs_mount(&lfs, &cfg_) => 0;
+        lfs_mount(&lfs, cfg) => 0;
         for (int n = 0; n < FILES; n++) {
             char path[1024];
             sprintf(path, "breakfast/%s", names[n]);
@@ -190,24 +165,19 @@ code = '''
 defines.FILES = 3
 defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
 defines.CYCLES = [1, 10]
-defines.INFER_BC = [false, true]
 code = '''
     const char *names[] = {"bacon", "eggs", "pancakes"};
 
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
 
     for (int c = 0; c < CYCLES; c++) {
-        lfs_mount(&lfs, &cfg_) => 0;
+        lfs_mount(&lfs, cfg) => 0;
         lfs_mkdir(&lfs, "breakfast") => 0;
         lfs_unmount(&lfs) => 0;
 
         for (int n = 0; n < FILES; n++) {
-            lfs_mount(&lfs, &cfg_) => 0;
+            lfs_mount(&lfs, cfg) => 0;
             char path[1024];
             sprintf(path, "breakfast/%s", names[n]);
             lfs_file_t file;
@@ -252,15 +222,10 @@ code = '''
 
 # exhaustion test
 [cases.test_alloc_exhaustion]
-defines.INFER_BC = [false, true]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     lfs_file_t file;
     lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     size_t size = strlen("exhaustion");
@@ -282,13 +247,10 @@ code = '''
     }
     res => LFS_ERR_NOSPC;
 
-    // note that lfs_fs_gc should not error here
-    lfs_fs_gc(&lfs) => 0;
-
     lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
     size = strlen("exhaustion");
     lfs_file_size(&lfs, &file) => size;
@@ -301,15 +263,10 @@ code = '''
 # exhaustion wraparound test
 [cases.test_alloc_exhaustion_wraparound]
 defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-4)) / 3)'
-defines.INFER_BC = [false, true]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
 
     lfs_file_t file;
     lfs_file_open(&lfs, &file, "padding", LFS_O_WRONLY | LFS_O_CREAT);
@@ -341,13 +298,10 @@ code = '''
     }
     res => LFS_ERR_NOSPC;
 
-    // note that lfs_fs_gc should not error here
-    lfs_fs_gc(&lfs) => 0;
-
     lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
     lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
     size = strlen("exhaustion");
     lfs_file_size(&lfs, &file) => size;
@@ -360,15 +314,10 @@ code = '''
 
 # dir exhaustion test
 [cases.test_alloc_dir_exhaustion]
-defines.INFER_BC = [false, true]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
-    struct lfs_config cfg_ = *cfg;
-    if (INFER_BC) {
-        cfg_.block_count = 0;
-    }
-    lfs_mount(&lfs, &cfg_) => 0;
+    lfs_mount(&lfs, cfg) => 0;
 
     // find out max file size
     lfs_mkdir(&lfs, "exhaustiondir") => 0;
@@ -388,8 +337,6 @@ code = '''
         count += 1;
     }
     err => LFS_ERR_NOSPC;
-    // note that lfs_fs_gc should not error here
-    lfs_fs_gc(&lfs) => 0;
     lfs_file_close(&lfs, &file) => 0;
 
     lfs_remove(&lfs, "exhaustion") => 0;
@@ -488,8 +435,6 @@ code = '''
             break;
         }
     }
-    // note that lfs_fs_gc should not error here
-    lfs_fs_gc(&lfs) => 0;
     lfs_file_close(&lfs, &file) => 0;
 
     lfs_unmount(&lfs) => 0;
@@ -515,8 +460,8 @@ code = '''
 
 # chained dir exhaustion test
 [cases.test_alloc_chained_dir_exhaustion]
-if = 'ERASE_SIZE == 512'
-defines.ERASE_COUNT = 1024
+if = 'BLOCK_SIZE == 512'
+defines.BLOCK_COUNT = 1024
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -593,8 +538,8 @@ code = '''
 
 # split dir test
 [cases.test_alloc_split_dir]
-if = 'ERASE_SIZE == 512'
-defines.ERASE_COUNT = 1024
+if = 'BLOCK_SIZE == 512'
+defines.BLOCK_COUNT = 1024
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -642,8 +587,8 @@ code = '''
 
 # outdated lookahead test
 [cases.test_alloc_outdated_lookahead]
-if = 'ERASE_SIZE == 512'
-defines.ERASE_COUNT = 1024
+if = 'BLOCK_SIZE == 512'
+defines.BLOCK_COUNT = 1024
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -710,8 +655,8 @@ code = '''
 
 # outdated lookahead and split dir test
 [cases.test_alloc_outdated_lookahead_split_dir]
-if = 'ERASE_SIZE == 512'
-defines.ERASE_COUNT = 1024
+if = 'BLOCK_SIZE == 512'
+defines.BLOCK_COUNT = 1024
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;

tests/test_badblocks.toml

@@ -2,7 +2,7 @@
 if = '(int32_t)BLOCK_CYCLES == -1'
 
 [cases.test_badblocks_single]
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.ERASE_CYCLES = 0xffffffff
 defines.ERASE_VALUE = [0x00, 0xff, -1]
 defines.BADBLOCK_BEHAVIOR = [
@@ -82,7 +82,7 @@ code = '''
 '''
 
 [cases.test_badblocks_region_corruption] # (causes cascading failures)
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.ERASE_CYCLES = 0xffffffff
 defines.ERASE_VALUE = [0x00, 0xff, -1]
 defines.BADBLOCK_BEHAVIOR = [
@@ -161,7 +161,7 @@ code = '''
 '''
 
 [cases.test_badblocks_alternating_corruption] # (causes cascading failures)
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.ERASE_CYCLES = 0xffffffff
 defines.ERASE_VALUE = [0x00, 0xff, -1]
 defines.BADBLOCK_BEHAVIOR = [

tests/test_dirs.toml

@@ -181,10 +181,6 @@ code = '''
 defines.N = [5, 11]
 if = 'BLOCK_COUNT >= 4*N'
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -443,10 +439,6 @@ code = '''
 defines.N = [5, 25]
 if = 'N < BLOCK_COUNT/2'
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -725,82 +717,6 @@ code = '''
     lfs_unmount(&lfs) => 0;
 '''
 
-[cases.test_dirs_remove_read]
-defines.N = 10
-if = 'N < BLOCK_COUNT/2'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_mkdir(&lfs, "prickly-pear") => 0;
-    for (int i = 0; i < N; i++) {
-        char path[1024];
-        sprintf(path, "prickly-pear/cactus%03d", i);
-        lfs_mkdir(&lfs, path) => 0;
-    }
-    lfs_dir_t dir;
-    lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
-    struct lfs_info info;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_DIR);
-    assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_DIR);
-    assert(strcmp(info.name, "..") == 0);
-    for (int i = 0; i < N; i++) {
-        char path[1024];
-        sprintf(path, "cactus%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        assert(info.type == LFS_TYPE_DIR);
-        assert(strcmp(info.name, path) == 0);
-    }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs);
-
-    for (lfs_size_t k = 0; k < N; k++) {
-        for (lfs_size_t j = 0; j < N; j++) {
-            lfs_mount(&lfs, cfg) => 0;
-            lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
-            lfs_dir_read(&lfs, &dir, &info) => 1;
-            assert(info.type == LFS_TYPE_DIR);
-            assert(strcmp(info.name, ".") == 0);
-            lfs_dir_read(&lfs, &dir, &info) => 1;
-            assert(info.type == LFS_TYPE_DIR);
-            assert(strcmp(info.name, "..") == 0);
-            // iterate over dirs < j
-            for (unsigned i = 0; i < j; i++) {
-                char path[1024];
-                sprintf(path, "cactus%03d", i);
-                lfs_dir_read(&lfs, &dir, &info) => 1;
-                assert(info.type == LFS_TYPE_DIR);
-                assert(strcmp(info.name, path) == 0);
-            }
-
-            // remove k while iterating
-            char path[1024];
-            sprintf(path, "prickly-pear/cactus%03d", k);
-            lfs_remove(&lfs, path) => 0;
-
-            // iterate over dirs >= j
-            for (unsigned i = j; i < ((k >= j) ? N-1 : N); i++) {
-                char path[1024];
-                sprintf(path, "cactus%03d", (k >= j && i >= k) ? i+1 : i);
-                lfs_dir_read(&lfs, &dir, &info) => 1;
-                assert(info.type == LFS_TYPE_DIR);
-                assert(strcmp(info.name, path) == 0);
-            }
-            lfs_dir_read(&lfs, &dir, &info) => 0;
-            lfs_dir_close(&lfs, &dir) => 0;
-
-            // recreate k
-            sprintf(path, "prickly-pear/cactus%03d", k);
-            lfs_mkdir(&lfs, path) => 0;
-            lfs_unmount(&lfs) => 0;
-        }
-    }
-'''
-
 [cases.test_dirs_other_errors]
 code = '''
     lfs_t lfs;
@@ -831,11 +747,6 @@ code = '''
     lfs_file_open(&lfs, &file, "potato",
             LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR;
 
-    lfs_file_open(&lfs, &file, "tacoto", LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_rename(&lfs, "tacoto", "potato") => LFS_ERR_ISDIR;
-    lfs_rename(&lfs, "potato", "tacoto") => LFS_ERR_NOTDIR;
-
     lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST;
     lfs_file_open(&lfs, &file, "/",
             LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST;
@@ -859,10 +770,6 @@ code = '''
     lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "potato") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_REG);
-    assert(strcmp(info.name, "tacoto") == 0);
-    assert(info.size == 0);
     lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
@@ -883,10 +790,6 @@ code = '''
     lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "potato") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_REG);
-    assert(strcmp(info.name, "tacoto") == 0);
-    assert(info.size == 0);
     lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
@@ -907,8 +810,7 @@ code = '''
     }
     lfs_unmount(&lfs) => 0;
 
-    // try seeking to each dir entry
-    for (int j = 0; j < COUNT; j++) {
+    for (int j = 2; j < COUNT; j++) {
         lfs_mount(&lfs, cfg) => 0;
         lfs_dir_t dir;
         lfs_dir_open(&lfs, &dir, "hello") => 0;
@@ -920,15 +822,16 @@ code = '''
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
 
+        lfs_soff_t pos;
         for (int i = 0; i < j; i++) {
             char path[1024];
             sprintf(path, "kitty%03d", i);
             lfs_dir_read(&lfs, &dir, &info) => 1;
             assert(strcmp(info.name, path) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            pos = lfs_dir_tell(&lfs, &dir);
+            assert(pos >= 0);
         }
-        lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-        assert(pos >= 0);
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         char path[1024];
@@ -958,52 +861,6 @@ code = '''
         lfs_dir_close(&lfs, &dir) => 0;
         lfs_unmount(&lfs) => 0;
     }
-
-    // try seeking to end of dir
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_dir_t dir;
-    lfs_dir_open(&lfs, &dir, "hello") => 0;
-    struct lfs_info info;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    for (int i = 0; i < COUNT; i++) {
-        char path[1024];
-        sprintf(path, "kitty%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        assert(strcmp(info.name, path) == 0);
-        assert(info.type == LFS_TYPE_DIR);
-    }
-    lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-    assert(pos >= 0);
-
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_rewind(&lfs, &dir) => 0;
-    char path[1024];
-    sprintf(path, "kitty%03d", 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, path) == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs) => 0;
 '''
 
 [cases.test_dirs_toot_seek]
@@ -1020,7 +877,7 @@ code = '''
     }
     lfs_unmount(&lfs) => 0;
 
-    for (int j = 0; j < COUNT; j++) {
+    for (int j = 2; j < COUNT; j++) {
         lfs_mount(&lfs, cfg) => 0;
         lfs_dir_t dir;
         lfs_dir_open(&lfs, &dir, "/") => 0;
@@ -1032,15 +889,16 @@ code = '''
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
 
+        lfs_soff_t pos;
         for (int i = 0; i < j; i++) {
             char path[1024];
             sprintf(path, "hi%03d", i);
             lfs_dir_read(&lfs, &dir, &info) => 1;
             assert(strcmp(info.name, path) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            pos = lfs_dir_tell(&lfs, &dir);
+            assert(pos >= 0);
         }
-        lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-        assert(pos >= 0);
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         char path[1024];
@@ -1070,51 +928,5 @@ code = '''
         lfs_dir_close(&lfs, &dir) => 0;
         lfs_unmount(&lfs) => 0;
     }
-
-    // try seeking to end of dir
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_dir_t dir;
-    lfs_dir_open(&lfs, &dir, "/") => 0;
-    struct lfs_info info;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    for (int i = 0; i < COUNT; i++) {
-        char path[1024];
-        sprintf(path, "hi%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        assert(strcmp(info.name, path) == 0);
-        assert(info.type == LFS_TYPE_DIR);
-    }
-    lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-    assert(pos >= 0);
-
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_rewind(&lfs, &dir) => 0;
-    char path[1024];
-    sprintf(path, "hi%03d", 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, path) == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs) => 0;
 '''
 

tests/test_exhaustion.toml

@@ -1,7 +1,7 @@
 # test running a filesystem to exhaustion
 [cases.test_exhaustion_normal]
 defines.ERASE_CYCLES = 10
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.BLOCK_CYCLES = 'ERASE_CYCLES / 2'
 defines.BADBLOCK_BEHAVIOR = [
     'LFS_EMUBD_BADBLOCK_PROGERROR',
@@ -94,7 +94,7 @@ exhausted:
 # which also requires expanding superblocks
 [cases.test_exhaustion_superblocks]
 defines.ERASE_CYCLES = 10
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.BLOCK_CYCLES = 'ERASE_CYCLES / 2'
 defines.BADBLOCK_BEHAVIOR = [
     'LFS_EMUBD_BADBLOCK_PROGERROR',
@@ -188,7 +188,7 @@ exhausted:
 # wear-level test running a filesystem to exhaustion
 [cases.test_exhuastion_wear_leveling]
 defines.ERASE_CYCLES = 20
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.BLOCK_CYCLES = 'ERASE_CYCLES / 2'
 defines.FILES = 10
 code = '''
@@ -288,7 +288,7 @@ exhausted:
 # wear-level test + expanding superblock
 [cases.test_exhaustion_wear_leveling_superblocks]
 defines.ERASE_CYCLES = 20
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.BLOCK_CYCLES = 'ERASE_CYCLES / 2'
 defines.FILES = 10
 code = '''
@@ -385,7 +385,7 @@ exhausted:
 # test that we wear blocks roughly evenly
 [cases.test_exhaustion_wear_distribution]
 defines.ERASE_CYCLES = 0xffffffff
-defines.ERASE_COUNT = 256 # small bd so test runs faster
+defines.BLOCK_COUNT = 256 # small bd so test runs faster
 defines.BLOCK_CYCLES = [5, 4, 3, 2, 1]
 defines.CYCLES = 100
 defines.FILES = 10

tests/test_files.toml

@@ -1,6 +1,5 @@
 
 [cases.test_files_simple]
-defines.INLINE_MAX = [0, -1, 8]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -26,7 +25,6 @@ code = '''
 [cases.test_files_large]
 defines.SIZE = [32, 8192, 262144, 0, 7, 8193]
 defines.CHUNKSIZE = [31, 16, 33, 1, 1023]
-defines.INLINE_MAX = [0, -1, 8]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -69,7 +67,6 @@ code = '''
 defines.SIZE1 = [32, 8192, 131072, 0, 7, 8193]
 defines.SIZE2 = [32, 8192, 131072, 0, 7, 8193]
 defines.CHUNKSIZE = [31, 16, 1]
-defines.INLINE_MAX = [0, -1, 8]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -155,7 +152,6 @@ code = '''
 defines.SIZE1 = [32, 8192, 131072, 0, 7, 8193]
 defines.SIZE2 = [32, 8192, 131072, 0, 7, 8193]
 defines.CHUNKSIZE = [31, 16, 1]
-defines.INLINE_MAX = [0, -1, 8]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -236,7 +232,6 @@ code = '''
 defines.SIZE1 = [32, 8192, 131072, 0, 7, 8193]
 defines.SIZE2 = [32, 8192, 131072, 0, 7, 8193]
 defines.CHUNKSIZE = [31, 16, 1]
-defines.INLINE_MAX = [0, -1, 8]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -308,12 +303,7 @@ code = '''
 [cases.test_files_reentrant_write]
 defines.SIZE = [32, 0, 7, 2049]
 defines.CHUNKSIZE = [31, 16, 65]
-defines.INLINE_MAX = [0, -1, 8]
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -364,20 +354,11 @@ code = '''
 [cases.test_files_reentrant_write_sync]
 defines = [
     # append (O(n))
-    {MODE='LFS_O_APPEND',
-        SIZE=[32, 0, 7, 2049],
-        CHUNKSIZE=[31, 16, 65],
-        INLINE_MAX=[0, -1, 8]},
+    {MODE='LFS_O_APPEND',   SIZE=[32, 0, 7, 2049],  CHUNKSIZE=[31, 16, 65]},
     # truncate (O(n^2))
-    {MODE='LFS_O_TRUNC',
-        SIZE=[32, 0, 7, 200],
-        CHUNKSIZE=[31, 16, 65],
-        INLINE_MAX=[0, -1, 8]},
+    {MODE='LFS_O_TRUNC',    SIZE=[32, 0, 7, 200],   CHUNKSIZE=[31, 16, 65]},
     # rewrite (O(n^2))
-    {MODE=0,
-        SIZE=[32, 0, 7, 200],
-        CHUNKSIZE=[31, 16, 65],
-        INLINE_MAX=[0, -1, 8]},
+    {MODE=0,                SIZE=[32, 0, 7, 200],   CHUNKSIZE=[31, 16, 65]},
 ]
 reentrant = true
 code = '''
@@ -504,10 +485,6 @@ code = '''
 [cases.test_files_many_power_loss]
 defines.N = 300
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);

tests/test_interspersed.toml

@@ -195,10 +195,6 @@ code = '''
 defines.SIZE = [10, 100]
 defines.FILES = [4, 10, 26] 
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     lfs_file_t files[FILES];

tests/test_move.toml

@@ -357,10 +357,6 @@ code = '''
 
 [cases.test_move_reentrant_file]
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -843,10 +839,6 @@ code = '''
 
 [cases.test_reentrant_dir]
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);

tests/test_orphans.toml

@@ -59,150 +59,6 @@ code = '''
     lfs_unmount(&lfs) => 0;
 '''
 
-# test that we only run deorphan once per power-cycle
-[cases.test_orphans_no_orphans]
-in = 'lfs.c'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    // mark the filesystem as having orphans
-    lfs_fs_preporphans(&lfs, +1) => 0;
-    lfs_mdir_t mdir;
-    lfs_dir_fetch(&lfs, &mdir, (lfs_block_t[2]){0, 1}) => 0;
-    lfs_dir_commit(&lfs, &mdir, NULL, 0) => 0;
-
-    // we should have orphans at this state
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    lfs_unmount(&lfs) => 0;
-
-    // mount
-    lfs_mount(&lfs, cfg) => 0;
-    // we should detect orphans
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    // force consistency
-    lfs_fs_forceconsistency(&lfs) => 0;
-    // we should no longer have orphans
-    assert(!lfs_gstate_hasorphans(&lfs.gstate));
-
-    lfs_unmount(&lfs) => 0;
-'''
-
-[cases.test_orphans_one_orphan]
-in = 'lfs.c'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    // create an orphan
-    lfs_mdir_t orphan;
-    lfs_alloc_ckpoint(&lfs);
-    lfs_dir_alloc(&lfs, &orphan) => 0;
-    lfs_dir_commit(&lfs, &orphan, NULL, 0) => 0;
-
-    // append our orphan and mark the filesystem as having orphans
-    lfs_fs_preporphans(&lfs, +1) => 0;
-    lfs_mdir_t mdir;
-    lfs_dir_fetch(&lfs, &mdir, (lfs_block_t[2]){0, 1}) => 0;
-    lfs_pair_tole32(orphan.pair);
-    lfs_dir_commit(&lfs, &mdir, LFS_MKATTRS(
-            {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), orphan.pair})) => 0;
-
-    // we should have orphans at this state
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    lfs_unmount(&lfs) => 0;
-
-    // mount
-    lfs_mount(&lfs, cfg) => 0;
-    // we should detect orphans
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    // force consistency
-    lfs_fs_forceconsistency(&lfs) => 0;
-    // we should no longer have orphans
-    assert(!lfs_gstate_hasorphans(&lfs.gstate));
-
-    lfs_unmount(&lfs) => 0;
-'''
-
-# test that we can persist gstate with lfs_fs_mkconsistent
-[cases.test_orphans_mkconsistent_no_orphans]
-in = 'lfs.c'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    // mark the filesystem as having orphans
-    lfs_fs_preporphans(&lfs, +1) => 0;
-    lfs_mdir_t mdir;
-    lfs_dir_fetch(&lfs, &mdir, (lfs_block_t[2]){0, 1}) => 0;
-    lfs_dir_commit(&lfs, &mdir, NULL, 0) => 0;
-
-    // we should have orphans at this state
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    lfs_unmount(&lfs) => 0;
-
-    // mount
-    lfs_mount(&lfs, cfg) => 0;
-    // we should detect orphans
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    // force consistency
-    lfs_fs_mkconsistent(&lfs) => 0;
-    // we should no longer have orphans
-    assert(!lfs_gstate_hasorphans(&lfs.gstate));
-
-    // remount
-    lfs_unmount(&lfs) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    // we should still have no orphans
-    assert(!lfs_gstate_hasorphans(&lfs.gstate));
-    lfs_unmount(&lfs) => 0;
-'''
-
-[cases.test_orphans_mkconsistent_one_orphan]
-in = 'lfs.c'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    // create an orphan
-    lfs_mdir_t orphan;
-    lfs_alloc_ckpoint(&lfs);
-    lfs_dir_alloc(&lfs, &orphan) => 0;
-    lfs_dir_commit(&lfs, &orphan, NULL, 0) => 0;
-
-    // append our orphan and mark the filesystem as having orphans
-    lfs_fs_preporphans(&lfs, +1) => 0;
-    lfs_mdir_t mdir;
-    lfs_dir_fetch(&lfs, &mdir, (lfs_block_t[2]){0, 1}) => 0;
-    lfs_pair_tole32(orphan.pair);
-    lfs_dir_commit(&lfs, &mdir, LFS_MKATTRS(
-            {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), orphan.pair})) => 0;
-
-    // we should have orphans at this state
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    lfs_unmount(&lfs) => 0;
-
-    // mount
-    lfs_mount(&lfs, cfg) => 0;
-    // we should detect orphans
-    assert(lfs_gstate_hasorphans(&lfs.gstate));
-    // force consistency
-    lfs_fs_mkconsistent(&lfs) => 0;
-    // we should no longer have orphans
-    assert(!lfs_gstate_hasorphans(&lfs.gstate));
-
-    // remount
-    lfs_unmount(&lfs) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    // we should still have no orphans
-    assert(!lfs_gstate_hasorphans(&lfs.gstate));
-    lfs_unmount(&lfs) => 0;
-'''
-
 # reentrant testing for orphans, basically just spam mkdir/remove
 [cases.test_orphans_reentrant]
 reentrant = true

tests/test_powerloss.toml

@@ -90,10 +90,7 @@ code = '''
 
 # partial prog, may not be byte in order!
 [cases.test_powerloss_partial_prog]
-if = '''
-    PROG_SIZE < BLOCK_SIZE
-        && (DISK_VERSION == 0 || DISK_VERSION >= 0x00020001)
-'''
+if = "PROG_SIZE < BLOCK_SIZE"
 defines.BYTE_OFF = ["0", "PROG_SIZE-1", "PROG_SIZE/2"]
 defines.BYTE_VALUE = [0x33, 0xcc]
 in = "lfs.c"

tests/test_seek.toml

@@ -137,130 +137,6 @@ code = '''
     lfs_unmount(&lfs) => 0;
 '''
 
-# boundary seek and reads
-[cases.test_seek_boundary_read]
-defines.COUNT = 132
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "kitty",
-            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    size_t size = strlen("kittycatcat");
-    uint8_t buffer[1024];
-    memcpy(buffer, "kittycatcat", size);
-    for (int j = 0; j < COUNT; j++) {
-        lfs_file_write(&lfs, &file, buffer, size);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_file_open(&lfs, &file, "kitty", LFS_O_RDONLY) => 0;
-
-    size = strlen("kittycatcat");
-    const lfs_soff_t offsets[] = {
-        512,
-        1024-4,
-        512+1,
-        1024-4+1,
-        512-1,
-        1024-4-1,
-
-        512-strlen("kittycatcat"),
-        1024-4-strlen("kittycatcat"),
-        512-strlen("kittycatcat")+1,
-        1024-4-strlen("kittycatcat")+1,
-        512-strlen("kittycatcat")-1,
-        1024-4-strlen("kittycatcat")-1,
-
-        strlen("kittycatcat")*(COUNT-2)-1,
-    };
-
-    for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
-        lfs_soff_t off = offsets[i];
-        // read @ offset
-        lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[off % strlen("kittycatcat")],
-                size) => 0;
-        // read after
-        lfs_file_seek(&lfs, &file, off+strlen("kittycatcat")+1, LFS_SEEK_SET)
-                => off+strlen("kittycatcat")+1;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[(off+1) % strlen("kittycatcat")],
-                size) => 0;
-        // read before
-        lfs_file_seek(&lfs, &file, off-strlen("kittycatcat")-1, LFS_SEEK_SET)
-                => off-strlen("kittycatcat")-1;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[(off-1) % strlen("kittycatcat")],
-                size) => 0;
-
-        // read @ 0
-        lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer, "kittycatcat", size) => 0;
-
-        // read @ offset
-        lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[off % strlen("kittycatcat")],
-                size) => 0;
-        // read after
-        lfs_file_seek(&lfs, &file, off+strlen("kittycatcat")+1, LFS_SEEK_SET)
-                => off+strlen("kittycatcat")+1;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[(off+1) % strlen("kittycatcat")],
-                size) => 0;
-        // read before
-        lfs_file_seek(&lfs, &file, off-strlen("kittycatcat")-1, LFS_SEEK_SET)
-                => off-strlen("kittycatcat")-1;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[(off-1) % strlen("kittycatcat")],
-                size) => 0;
-
-        // sync
-        lfs_file_sync(&lfs, &file) => 0;
-
-        // read @ 0
-        lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer, "kittycatcat", size) => 0;
-
-        // read @ offset
-        lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[off % strlen("kittycatcat")],
-                size) => 0;
-        // read after
-        lfs_file_seek(&lfs, &file, off+strlen("kittycatcat")+1, LFS_SEEK_SET)
-                => off+strlen("kittycatcat")+1;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[(off+1) % strlen("kittycatcat")],
-                size) => 0;
-        // read before
-        lfs_file_seek(&lfs, &file, off-strlen("kittycatcat")-1, LFS_SEEK_SET)
-                => off-strlen("kittycatcat")-1;
-        lfs_file_read(&lfs, &file, buffer, size) => size;
-        memcmp(buffer,
-                &"kittycatcatkittycatcat"[(off-1) % strlen("kittycatcat")],
-                size) => 0;
-    }
-
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-'''
-
 # boundary seek and writes
 [cases.test_seek_boundary_write]
 defines.COUNT = 132
@@ -284,54 +160,31 @@ code = '''
     lfs_file_open(&lfs, &file, "kitty", LFS_O_RDWR) => 0;
 
     size = strlen("hedgehoghog");
-    const lfs_soff_t offsets[] = {
-        512,
-        1024-4,
-        512+1,
-        1024-4+1,
-        512-1,
-        1024-4-1,
-
-        512-strlen("kittycatcat"),
-        1024-4-strlen("kittycatcat"),
-        512-strlen("kittycatcat")+1,
-        1024-4-strlen("kittycatcat")+1,
-        512-strlen("kittycatcat")-1,
-        1024-4-strlen("kittycatcat")-1,
-
-        strlen("kittycatcat")*(COUNT-2)-1,
-    };
+    const lfs_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019, 1441};
 
     for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
         lfs_soff_t off = offsets[i];
-        // write @ offset
         memcpy(buffer, "hedgehoghog", size);
         lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
         lfs_file_write(&lfs, &file, buffer, size) => size;
-
-        // read @ offset
         lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
         lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hedgehoghog", size) => 0;
 
-        // read @ 0
         lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
         lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "kittycatcat", size) => 0;
 
-        // read @ offset
         lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
         lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hedgehoghog", size) => 0;
 
         lfs_file_sync(&lfs, &file) => 0;
 
-        // read @ 0
         lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
         lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "kittycatcat", size) => 0;
 
-        // read @ offset
         lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
         lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hedgehoghog", size) => 0;
@@ -476,10 +329,6 @@ code = '''
 # must be power-of-2 for quadratic probing to be exhaustive
 defines.COUNT = [4, 64, 128]
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -552,111 +401,3 @@ code = '''
     lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 '''
-
-
-# test possible overflow/underflow conditions
-#
-# note these need -fsanitize=undefined to consistently detect
-# overflow/underflow conditions
-
-[cases.test_seek_filemax]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "kitty",
-            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    uint8_t buffer[1024];
-    strcpy((char*)buffer, "kittycatcat");
-    size_t size = strlen((char*)buffer);
-    lfs_file_write(&lfs, &file, buffer, size) => size;
-
-    // seek with LFS_SEEK_SET
-    lfs_file_seek(&lfs, &file, LFS_FILE_MAX, LFS_SEEK_SET) => LFS_FILE_MAX;
-
-    // seek with LFS_SEEK_CUR
-    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => LFS_FILE_MAX;
-
-    // the file hasn't changed size, so seek end takes us back to the offset=0
-    lfs_file_seek(&lfs, &file, +10, LFS_SEEK_END) => size+10;
-
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-'''
-
-[cases.test_seek_underflow]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "kitty",
-            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    uint8_t buffer[1024];
-    strcpy((char*)buffer, "kittycatcat");
-    size_t size = strlen((char*)buffer);
-    lfs_file_write(&lfs, &file, buffer, size) => size;
-
-    // underflow with LFS_SEEK_CUR, should error
-    lfs_file_seek(&lfs, &file, -(size+10), LFS_SEEK_CUR) => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file, -LFS_FILE_MAX, LFS_SEEK_CUR) => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file, -(size+LFS_FILE_MAX), LFS_SEEK_CUR)
-            => LFS_ERR_INVAL;
-
-    // underflow with LFS_SEEK_END, should error
-    lfs_file_seek(&lfs, &file, -(size+10), LFS_SEEK_END) => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file, -LFS_FILE_MAX, LFS_SEEK_END) => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file, -(size+LFS_FILE_MAX), LFS_SEEK_END)
-            => LFS_ERR_INVAL;
-
-    // file pointer should not have changed
-    lfs_file_tell(&lfs, &file) => size;
-
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-'''
-
-[cases.test_seek_overflow]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "kitty",
-            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    uint8_t buffer[1024];
-    strcpy((char*)buffer, "kittycatcat");
-    size_t size = strlen((char*)buffer);
-    lfs_file_write(&lfs, &file, buffer, size) => size;
-
-    // seek to LFS_FILE_MAX
-    lfs_file_seek(&lfs, &file, LFS_FILE_MAX, LFS_SEEK_SET) => LFS_FILE_MAX;
-
-    // overflow with LFS_SEEK_CUR, should error
-    lfs_file_seek(&lfs, &file, +10, LFS_SEEK_CUR) => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file, +LFS_FILE_MAX, LFS_SEEK_CUR) => LFS_ERR_INVAL;
-
-    // LFS_SEEK_SET/END don't care about the current file position, but we can
-    // still overflow with a large offset
-
-    // overflow with LFS_SEEK_SET, should error
-    lfs_file_seek(&lfs, &file,
-            +((uint32_t)LFS_FILE_MAX+10),
-            LFS_SEEK_SET) => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file,
-            +((uint32_t)LFS_FILE_MAX+(uint32_t)LFS_FILE_MAX),
-            LFS_SEEK_SET) => LFS_ERR_INVAL;
-
-    // overflow with LFS_SEEK_END, should error
-    lfs_file_seek(&lfs, &file, +(LFS_FILE_MAX-size+10), LFS_SEEK_END)
-            => LFS_ERR_INVAL;
-    lfs_file_seek(&lfs, &file, +(LFS_FILE_MAX-size+LFS_FILE_MAX), LFS_SEEK_END)
-            => LFS_ERR_INVAL;
-
-    // file pointer should not have changed
-    lfs_file_tell(&lfs, &file) => LFS_FILE_MAX;
-
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-'''

tests/test_superblocks.toml

@@ -14,45 +14,9 @@ code = '''
     lfs_unmount(&lfs) => 0;
 '''
 
-# make sure the magic string "littlefs" is always at offset=8
-[cases.test_superblocks_magic]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, 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;
-    assert(memcmp(&magic[8], "littlefs", 8) == 0);
-    cfg->read(cfg, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
-    assert(memcmp(&magic[8], "littlefs", 8) == 0);
-'''
-
-# mount/unmount from interpretting a previous superblock block_count
-[cases.test_superblocks_mount_unknown_block_count]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    memset(&lfs, 0, sizeof(lfs));
-    struct lfs_config tweaked_cfg = *cfg;
-    tweaked_cfg.block_count = 0;
-    lfs_mount(&lfs, &tweaked_cfg) => 0;
-    assert(lfs.block_count == cfg->block_count);
-    lfs_unmount(&lfs) => 0;
-'''
-
 # reentrant format
 [cases.test_superblocks_reentrant_format]
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -70,54 +34,6 @@ code = '''
     lfs_mount(&lfs, cfg) => LFS_ERR_CORRUPT;
 '''
 
-# test we can read superblock info through lfs_fs_stat
-[cases.test_superblocks_stat]
-if = 'DISK_VERSION == 0'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    // test we can mount and read fsinfo
-    lfs_mount(&lfs, cfg) => 0;
-
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.disk_version == LFS_DISK_VERSION);
-    assert(fsinfo.name_max == LFS_NAME_MAX);
-    assert(fsinfo.file_max == LFS_FILE_MAX);
-    assert(fsinfo.attr_max == LFS_ATTR_MAX);
-
-    lfs_unmount(&lfs) => 0;
-'''
-
-[cases.test_superblocks_stat_tweaked]
-if = 'DISK_VERSION == 0'
-defines.TWEAKED_NAME_MAX = 63
-defines.TWEAKED_FILE_MAX = '(1 << 16)-1'
-defines.TWEAKED_ATTR_MAX = 512
-code = '''
-    // create filesystem with tweaked params
-    struct lfs_config tweaked_cfg = *cfg;
-    tweaked_cfg.name_max = TWEAKED_NAME_MAX;
-    tweaked_cfg.file_max = TWEAKED_FILE_MAX;
-    tweaked_cfg.attr_max = TWEAKED_ATTR_MAX;
-
-    lfs_t lfs;
-    lfs_format(&lfs, &tweaked_cfg) => 0;
-
-    // test we can mount and read these params with the original config
-    lfs_mount(&lfs, cfg) => 0;
-
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.disk_version == LFS_DISK_VERSION);
-    assert(fsinfo.name_max == TWEAKED_NAME_MAX);
-    assert(fsinfo.file_max == TWEAKED_FILE_MAX);
-    assert(fsinfo.attr_max == TWEAKED_ATTR_MAX);
-
-    lfs_unmount(&lfs) => 0;
-'''
-
 # expanding superblock
 [cases.test_superblocks_expand]
 defines.BLOCK_CYCLES = [32, 33, 1]
@@ -152,39 +68,6 @@ code = '''
     lfs_unmount(&lfs) => 0;
 '''
 
-# make sure the magic string "littlefs" is always at offset=8
-[cases.test_superblocks_magic_expand]
-defines.BLOCK_CYCLES = [32, 33, 1]
-defines.N = [10, 100, 1000]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    for (int i = 0; i < N; i++) {
-        lfs_file_t file;
-        lfs_file_open(&lfs, &file, "dummy",
-                LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
-        lfs_file_close(&lfs, &file) => 0;
-        struct lfs_info info;
-        lfs_stat(&lfs, "dummy", &info) => 0;
-        assert(strcmp(info.name, "dummy") == 0);
-        assert(info.type == LFS_TYPE_REG);
-        lfs_remove(&lfs, "dummy") => 0;
-    }
-    lfs_unmount(&lfs) => 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;
-    assert(memcmp(&magic[8], "littlefs", 8) == 0);
-    cfg->read(cfg, 1, 0, magic, lfs_max(16, READ_SIZE)) => 0;
-    assert(memcmp(&magic[8], "littlefs", 8) == 0);
-'''
-
 # expanding superblock with power cycle
 [cases.test_superblocks_expand_power_cycle]
 defines.BLOCK_CYCLES = [32, 33, 1]
@@ -228,10 +111,6 @@ code = '''
 defines.BLOCK_CYCLES = [2, 1]
 defines.N = 24
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -270,283 +149,3 @@ code = '''
     assert(info.type == LFS_TYPE_REG);
     lfs_unmount(&lfs) => 0;
 '''
-
-
-# mount with unknown block_count
-[cases.test_superblocks_unknown_blocks]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    // known block_size/block_count
-    cfg->block_size = BLOCK_SIZE;
-    cfg->block_count = BLOCK_COUNT;
-    lfs_mount(&lfs, cfg) => 0;
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    // unknown block_count
-    cfg->block_size = BLOCK_SIZE;
-    cfg->block_count = 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    // do some work
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "test",
-            LFS_O_CREAT | LFS_O_EXCL | LFS_O_WRONLY) => 0;
-    lfs_file_write(&lfs, &file, "hello!", 6) => 6;
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_file_open(&lfs, &file, "test", LFS_O_RDONLY) => 0;
-    uint8_t buffer[256];
-    lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => 6;
-    lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer, "hello!", 6) == 0);
-    lfs_unmount(&lfs) => 0;
-'''
-
-# mount with blocks fewer than the erase_count
-[cases.test_superblocks_fewer_blocks]
-defines.BLOCK_COUNT = ['ERASE_COUNT/2', 'ERASE_COUNT/4', '2']
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    // known block_size/block_count
-    cfg->block_size = BLOCK_SIZE;
-    cfg->block_count = BLOCK_COUNT;
-    lfs_mount(&lfs, cfg) => 0;
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    // incorrect block_count
-    cfg->block_size = BLOCK_SIZE;
-    cfg->block_count = ERASE_COUNT;
-    lfs_mount(&lfs, cfg) => LFS_ERR_INVAL;
-
-    // unknown block_count
-    cfg->block_size = BLOCK_SIZE;
-    cfg->block_count = 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    // do some work
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "test",
-            LFS_O_CREAT | LFS_O_EXCL | LFS_O_WRONLY) => 0;
-    lfs_file_write(&lfs, &file, "hello!", 6) => 6;
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_file_open(&lfs, &file, "test", LFS_O_RDONLY) => 0;
-    uint8_t buffer[256];
-    lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => 6;
-    lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer, "hello!", 6) == 0);
-    lfs_unmount(&lfs) => 0;
-'''
-
-# mount with more blocks than the erase_count
-[cases.test_superblocks_more_blocks]
-defines.FORMAT_BLOCK_COUNT = '2*ERASE_COUNT'
-in = 'lfs.c'
-code = '''
-    lfs_t lfs;
-    lfs_init(&lfs, cfg) => 0;
-    lfs.block_count = BLOCK_COUNT;
-
-    lfs_mdir_t root = {
-        .pair = {0, 0}, // make sure this goes into block 0
-        .rev = 0,
-        .off = sizeof(uint32_t),
-        .etag = 0xffffffff,
-        .count = 0,
-        .tail = {LFS_BLOCK_NULL, LFS_BLOCK_NULL},
-        .erased = false,
-        .split = false,
-    };
-
-    lfs_superblock_t superblock = {
-        .version     = LFS_DISK_VERSION,
-        .block_size  = BLOCK_SIZE,
-        .block_count = FORMAT_BLOCK_COUNT,
-        .name_max    = LFS_NAME_MAX,
-        .file_max    = LFS_FILE_MAX,
-        .attr_max    = LFS_ATTR_MAX,
-    };
-
-    lfs_superblock_tole32(&superblock);
-    lfs_dir_commit(&lfs, &root, LFS_MKATTRS(
-            {LFS_MKTAG(LFS_TYPE_CREATE, 0, 0), NULL},
-            {LFS_MKTAG(LFS_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
-            {LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
-                &superblock})) => 0;
-    lfs_deinit(&lfs) => 0;
-
-    // known block_size/block_count
-    cfg->block_size = BLOCK_SIZE;
-    cfg->block_count = BLOCK_COUNT;
-    lfs_mount(&lfs, cfg) => LFS_ERR_INVAL;
-'''
-
-# mount and grow the filesystem
-[cases.test_superblocks_grow]
-defines.BLOCK_COUNT = ['ERASE_COUNT/2', 'ERASE_COUNT/4', '2']
-defines.BLOCK_COUNT_2 = 'ERASE_COUNT'
-defines.KNOWN_BLOCK_COUNT = [true, false]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    if (KNOWN_BLOCK_COUNT) {
-        cfg->block_count = BLOCK_COUNT;
-    } else {
-        cfg->block_count = 0;
-    }
-
-    // mount with block_size < erase_size
-    lfs_mount(&lfs, cfg) => 0;
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    // same size is a noop
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_grow(&lfs, BLOCK_COUNT) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT);
-    lfs_unmount(&lfs) => 0;
-
-    // grow to new size
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_grow(&lfs, BLOCK_COUNT_2) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT_2);
-    lfs_unmount(&lfs) => 0;
-
-    if (KNOWN_BLOCK_COUNT) {
-        cfg->block_count = BLOCK_COUNT_2;
-    } else {
-        cfg->block_count = 0;
-    }
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT_2);
-    lfs_unmount(&lfs) => 0;
-
-    // mounting with the previous size should fail
-    cfg->block_count = BLOCK_COUNT;
-    lfs_mount(&lfs, cfg) => LFS_ERR_INVAL;
-
-    if (KNOWN_BLOCK_COUNT) {
-        cfg->block_count = BLOCK_COUNT_2;
-    } else {
-        cfg->block_count = 0;
-    }
-
-    // same size is a noop
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_grow(&lfs, BLOCK_COUNT_2) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT_2);
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT_2);
-    lfs_unmount(&lfs) => 0;
-
-    // do some work
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT_2);
-    lfs_file_t file;
-    lfs_file_open(&lfs, &file, "test",
-            LFS_O_CREAT | LFS_O_EXCL | LFS_O_WRONLY) => 0;
-    lfs_file_write(&lfs, &file, "hello!", 6) => 6;
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.block_size == BLOCK_SIZE);
-    assert(fsinfo.block_count == BLOCK_COUNT_2);
-    lfs_file_open(&lfs, &file, "test", LFS_O_RDONLY) => 0;
-    uint8_t buffer[256];
-    lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => 6;
-    lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer, "hello!", 6) == 0);
-    lfs_unmount(&lfs) => 0;
-'''
-
-# test that metadata_max does not cause problems for superblock compaction
-[cases.test_superblocks_metadata_max]
-defines.METADATA_MAX = [
-    'lfs_max(512, PROG_SIZE)',
-    'lfs_max(BLOCK_SIZE/2, PROG_SIZE)',
-    'BLOCK_SIZE'
-]
-defines.N = [10, 100, 1000]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    for (int i = 0; i < N; i++) {
-        lfs_file_t file;
-        char name[256];
-        sprintf(name, "hello%03x", i);
-        lfs_file_open(&lfs, &file, name,
-                LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
-        lfs_file_close(&lfs, &file) => 0;
-        struct lfs_info info;
-        lfs_stat(&lfs, name, &info) => 0;
-        assert(strcmp(info.name, name) == 0);
-        assert(info.type == LFS_TYPE_REG);
-    }
-    lfs_unmount(&lfs) => 0;
-'''

tests/test_truncate.toml

@@ -1,8 +1,7 @@
 # simple truncate
 [cases.test_truncate_simple]
-defines.MEDIUMSIZE = [31, 32, 33, 511, 512, 513, 2047, 2048, 2049]
-defines.LARGESIZE = [32, 33, 512, 513, 2048, 2049, 8192, 8193]
-if = 'MEDIUMSIZE < LARGESIZE'
+defines.MEDIUMSIZE = [32, 2048]
+defines.LARGESIZE = 8192
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -15,8 +14,7 @@ code = '''
     strcpy((char*)buffer, "hair");
     size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, LARGESIZE-j))
-                => lfs_min(size, LARGESIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => LARGESIZE;
 
@@ -39,9 +37,8 @@ code = '''
 
     size = strlen("hair");
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
-        memcmp(buffer, "hair", lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
+        memcmp(buffer, "hair", size) => 0;
     }
     lfs_file_read(&lfs, &file, buffer, size) => 0;
 
@@ -51,9 +48,8 @@ code = '''
 
 # truncate and read
 [cases.test_truncate_read]
-defines.MEDIUMSIZE = [31, 32, 33, 511, 512, 513, 2047, 2048, 2049]
-defines.LARGESIZE = [32, 33, 512, 513, 2048, 2049, 8192, 8193]
-if = 'MEDIUMSIZE < LARGESIZE'
+defines.MEDIUMSIZE = [32, 2048]
+defines.LARGESIZE = 8192
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -66,8 +62,7 @@ code = '''
     strcpy((char*)buffer, "hair");
     size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, LARGESIZE-j))
-                => lfs_min(size, LARGESIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => LARGESIZE;
 
@@ -83,9 +78,8 @@ code = '''
 
     size = strlen("hair");
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
-        memcmp(buffer, "hair", lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
+        memcmp(buffer, "hair", size) => 0;
     }
     lfs_file_read(&lfs, &file, buffer, size) => 0;
 
@@ -98,9 +92,8 @@ code = '''
 
     size = strlen("hair");
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
-        memcmp(buffer, "hair", lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
+        memcmp(buffer, "hair", size) => 0;
     }
     lfs_file_read(&lfs, &file, buffer, size) => 0;
 
@@ -155,7 +148,7 @@ code = '''
     lfs_file_truncate(&lfs, &file, trunc) => 0;
     lfs_file_tell(&lfs, &file) => qsize;
     lfs_file_size(&lfs, &file) => trunc;
-
+    
     /* Read should produce second quarter */
     lfs_file_read(&lfs, &file, rb, size) => trunc - qsize;
     memcmp(rb, wb + qsize, trunc - qsize) => 0;
@@ -166,9 +159,8 @@ code = '''
 
 # truncate and write
 [cases.test_truncate_write]
-defines.MEDIUMSIZE = [31, 32, 33, 511, 512, 513, 2047, 2048, 2049]
-defines.LARGESIZE = [32, 33, 512, 513, 2048, 2049, 8192, 8193]
-if = 'MEDIUMSIZE < LARGESIZE'
+defines.MEDIUMSIZE = [32, 2048]
+defines.LARGESIZE = 8192
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -181,8 +173,7 @@ code = '''
     strcpy((char*)buffer, "hair");
     size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, LARGESIZE-j))
-                => lfs_min(size, LARGESIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => LARGESIZE;
 
@@ -193,16 +184,13 @@ code = '''
     lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDWR) => 0;
     lfs_file_size(&lfs, &file) => LARGESIZE;
 
-    /* truncate */
     lfs_file_truncate(&lfs, &file, MEDIUMSIZE) => 0;
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
 
-    /* and write */
     strcpy((char*)buffer, "bald");
     size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
 
@@ -215,9 +203,8 @@ code = '''
 
     size = strlen("bald");
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
-        memcmp(buffer, "bald", lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
+        memcmp(buffer, "bald", size) => 0;
     }
     lfs_file_read(&lfs, &file, buffer, size) => 0;
 
@@ -228,13 +215,9 @@ code = '''
 # truncate write under powerloss
 [cases.test_truncate_reentrant_write]
 defines.SMALLSIZE = [4, 512]
-defines.MEDIUMSIZE = [0, 3, 4, 5, 31, 32, 33, 511, 512, 513, 1023, 1024, 1025]
+defines.MEDIUMSIZE = [32, 1024]
 defines.LARGESIZE = 2048
 reentrant = true
-defines.POWERLOSS_BEHAVIOR = [
-    'LFS_EMUBD_POWERLOSS_NOOP',
-    'LFS_EMUBD_POWERLOSS_OOO',
-]
 code = '''
     lfs_t lfs;
     int err = lfs_mount(&lfs, cfg);
@@ -253,11 +236,10 @@ code = '''
                 size == (size_t)SMALLSIZE);
         for (lfs_off_t j = 0; j < size; j += 4) {
             uint8_t buffer[1024];
-            lfs_file_read(&lfs, &file, buffer, lfs_min(4, size-j))
-                    => lfs_min(4, size-j);
-            assert(memcmp(buffer, "hair", lfs_min(4, size-j)) == 0 ||
-                   memcmp(buffer, "bald", lfs_min(4, size-j)) == 0 ||
-                   memcmp(buffer, "comb", lfs_min(4, size-j)) == 0);
+            lfs_file_read(&lfs, &file, buffer, 4) => 4;
+            assert(memcmp(buffer, "hair", 4) == 0 ||
+                   memcmp(buffer, "bald", 4) == 0 ||
+                   memcmp(buffer, "comb", 4) == 0);
         }
         lfs_file_close(&lfs, &file) => 0;
     }
@@ -269,23 +251,19 @@ code = '''
     strcpy((char*)buffer, "hair");
     size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, LARGESIZE-j))
-                => lfs_min(size, LARGESIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => LARGESIZE;
     lfs_file_close(&lfs, &file) => 0;
 
     lfs_file_open(&lfs, &file, "baldy", LFS_O_RDWR) => 0;
     lfs_file_size(&lfs, &file) => LARGESIZE;
-    /* truncate */
     lfs_file_truncate(&lfs, &file, MEDIUMSIZE) => 0;
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
-    /* and write */
     strcpy((char*)buffer, "bald");
     size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
     lfs_file_close(&lfs, &file) => 0;
@@ -297,8 +275,7 @@ code = '''
     strcpy((char*)buffer, "comb");
     size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < SMALLSIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, SMALLSIZE-j))
-                => lfs_min(size, SMALLSIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
     lfs_file_size(&lfs, &file) => SMALLSIZE;
     lfs_file_close(&lfs, &file) => 0;
@@ -452,7 +429,7 @@ code = '''
 
 # noop truncate
 [cases.test_truncate_nop]
-defines.MEDIUMSIZE = [32, 33, 512, 513, 2048, 2049, 8192, 8193]
+defines.MEDIUMSIZE = [32, 2048]
 code = '''
     lfs_t lfs;
     lfs_format(&lfs, cfg) => 0;
@@ -465,11 +442,10 @@ code = '''
     strcpy((char*)buffer, "hair");
     size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_write(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
 
         // this truncate should do nothing
-        lfs_file_truncate(&lfs, &file, j+lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_truncate(&lfs, &file, j+size) => 0;
     }
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
 
@@ -479,9 +455,8 @@ code = '''
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
 
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
-        memcmp(buffer, "hair", lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
+        memcmp(buffer, "hair", size) => 0;
     }
     lfs_file_read(&lfs, &file, buffer, size) => 0;
 
@@ -493,9 +468,8 @@ code = '''
     lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDWR) => 0;
     lfs_file_size(&lfs, &file) => MEDIUMSIZE;
     for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file, buffer, lfs_min(size, MEDIUMSIZE-j))
-                => lfs_min(size, MEDIUMSIZE-j);
-        memcmp(buffer, "hair", lfs_min(size, MEDIUMSIZE-j)) => 0;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
+        memcmp(buffer, "hair", size) => 0;
     }
     lfs_file_read(&lfs, &file, buffer, size) => 0;
     lfs_file_close(&lfs, &file) => 0;