Fixed name ordering when names only differ in length

Wild this hasn't been caught until now. Because the exact ordering of the comparison in lfs_bd_cmp is a bit ambiguous, lfs_dir_find_match returned the wrong result when filenames were equal, and only differed in length. For example: - cmp("a", "aa") should be LFS_CMP_LT - cmp("aaa", "aa") should be LFS_CMP_GT We're quite lucky that none of the littlefs internals currently depend on the sorted order, otherwise we'd probably be stuck with this weird ordering for backwards compatibility reasons... Fixed, and added some test cases over directory ordering to prevent regression in the future. Found by andriyndev
2025-11-16 12:34:34 +00:00 · 2024-01-17 14:38:04 -06:00
34 changed files with 817 additions and 9323 deletions
--- a/.github/workflows/post-release.yml
+++ b/.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
--- a/.github/workflows/release.yml
+++ b/.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
--- a/.github/workflows/status.yml
+++ b/.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
--- a/.github/workflows/test.yml
+++ b/.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
@@ -235,9 +235,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 +273,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 +317,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 +329,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 +359,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,50 +374,11 @@ jobs:
        run: |
          CFLAGS="$CFLAGS -DLFS_NO_INTRINSICS" make test

-  test-shrink:
-    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-no-intrinsics
-        run: |
-          CFLAGS="$CFLAGS -DLFS_SHRINKNONRELOCATING" 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
+    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: install
        run: |
          # need a few things
@@ -432,9 +393,9 @@ jobs:

  # run tests on the older version lfs2.0
  test-lfs2_0:
-    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,9 +412,9 @@ jobs:

  # 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
@@ -470,11 +431,12 @@ jobs:
          TESTFLAGS="$TESTFLAGS --valgrind --context=1024 -Gdefault -Pnone" \
            make test

-  # compile/run with Clang, mostly to check for Clang-specific warnings
+  # 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
@@ -484,16 +446,20 @@ jobs:
          python3 --version
      - name: test-clang
        run: |
-          CC=clang \
-            make test
+          # override CFLAGS since Clang does not support -fcallgraph-info
+          # and -ftrack-macro-expansions
+          make \
+            CC=clang \
+            CFLAGS="$CFLAGS -MMD -g3 -I. -std=c99 -Wall -Wextra -pedantic" \
+            test

  # run benchmarks
  #
  # 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
@@ -525,7 +491,7 @@ jobs:

      # create bench statuses
      - name: upload-bench
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: bench
          path: bench
@@ -559,20 +525,20 @@ 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
+    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
        if: ${{github.event_name == 'pull_request'}}
      # checkout the current pr target into lfsp
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
        if: ${{github.event_name == 'pull_request'}}
        with:
          ref: ${{github.event.pull_request.base.ref}}
@@ -603,10 +569,10 @@ jobs:

  # 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
@@ -616,7 +582,7 @@ jobs:
          gcc --version
          python3 --version
          fusermount -V
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
        with:
          repository: littlefs-project/littlefs-fuse
          ref: v2
@@ -653,10 +619,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
@@ -666,12 +632,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
@@ -725,10 +691,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'}}
@@ -738,26 +704,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
@@ -899,7 +862,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
--- a/12
+++ b/12
@@ -18,12 +18,6 @@ VALGRIND ?= valgrind
 GDB		 ?= gdb
 PERF	 ?= perf

-# guess clang or gcc (clang sometimes masquerades as gcc because of
-# course it does)
-ifneq ($(shell $(CC) --version | grep clang),)
-NO_GCC = 1
-endif
-
 SRC  ?= $(filter-out $(wildcard *.t.* *.b.*),$(wildcard *.c))
 OBJ  := $(SRC:%.c=$(BUILDDIR)/%.o)
 DEP  := $(SRC:%.c=$(BUILDDIR)/%.d)
@@ -65,15 +59,12 @@ BENCH_PERF  := $(BENCH_RUNNER:%=%.perf)
 BENCH_TRACE := $(BENCH_RUNNER:%=%.trace)
 BENCH_CSV   := $(BENCH_RUNNER:%=%.csv)

+CFLAGS += -fcallgraph-info=su
 CFLAGS += -g3
 CFLAGS += -I.
 CFLAGS += -std=c99 -Wall -Wextra -pedantic
 CFLAGS += -Wmissing-prototypes
-ifndef NO_GCC
-CFLAGS += -fcallgraph-info=su
 CFLAGS += -ftrack-macro-expansion=0
-endif
-
 ifdef DEBUG
 CFLAGS += -O0
 else
@@ -475,7 +466,6 @@ benchmarks-diff: $(BENCH_CSV)
 # rules
 -include $(DEP)
 -include $(TEST_DEP)
-include $(BENCH_DEP)
 .SUFFIXES:
 .SECONDARY:

--- a/README.md
+++ b/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,40 +226,16 @@ 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.
-
- [littlefs-toy] - A command-line tool for creating and working with littlefs
-  images. Uses syntax similar to tar command for ease of use. Supports working
-  on littlefs images embedded inside another file (firmware image, etc).
-
+  
 - [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.
@@ -319,24 +254,23 @@ License Identifiers that are here available: http://spdx.org/licenses/
  for microcontroller-scale devices. Due to limitations of FAT it can't provide
  power-loss resilience, but it does allow easy interop with PCs.

+- [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.
+
 [BSD-3-Clause]: https://spdx.org/licenses/BSD-3-Clause.html
+[littlefs-disk-img-viewer]: https://github.com/tniessen/littlefs-disk-img-viewer
 [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/
-[littlefs-toy]: https://github.com/tjko/littlefs-toy
-[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/
+[littlefs2-rust]: https://crates.io/crates/littlefs2
+[chamelon]: https://github.com/yomimono/chamelon
--- a/SPEC.md
+++ b/SPEC.md
@@ -441,10 +441,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
--- a/bd/lfs_emubd.c
+++ b/bd/lfs_emubd.c
@@ -129,8 +129,6 @@ int lfs_emubd_create(const struct lfs_config *cfg,
    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) {
@@ -197,7 +195,6 @@ int lfs_emubd_destroy(const struct lfs_config *cfg) {
    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 +209,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

@@ -416,11 +344,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);
        }
    }

@@ -436,17 +361,10 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
    // 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]);
-    }
-
    // 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;
    }

@@ -512,11 +430,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 +441,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 +480,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 +491,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;
@@ -725,8 +633,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;
--- a/bd/lfs_emubd.h
+++ b/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
@@ -153,8 +152,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;
--- a/bd/lfs_filebd.c
+++ b/bd/lfs_filebd.c
@@ -133,7 +133,7 @@ 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);
+            (void*)cfg, block, ((lfs_file_t*)cfg->context)->cfg->erase_size);
    lfs_filebd_t *bd = cfg->context;

    // check if erase is valid
--- a/lfs.c
+++ b/lfs.c
--- a/lfs.h
+++ b/lfs.h
@@ -21,7 +21,7 @@ extern "C"
 // Software library version
 // Major (top-nibble), incremented on backwards incompatible changes
 // Minor (bottom-nibble), incremented on feature additions
-#define LFS_VERSION 0x0002000b
+#define LFS_VERSION 0x00020008
 #define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16))
 #define LFS_VERSION_MINOR (0xffff & (LFS_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
@@ -274,15 +264,6 @@ struct lfs_config {
    // 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
@@ -449,20 +430,19 @@ 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;
@@ -732,6 +712,18 @@ 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);

+// Attempt to proactively find free blocks
+//
+// Calling this function is not required, but may allowing the offloading of
+// the expensive block allocation scan to a less time-critical code path.
+//
+// Note: littlefs currently does not persist any found free blocks to disk.
+// This may change in the future.
+//
+// Returns a negative error code on failure. Finding no free blocks is
+// not an error.
+int lfs_fs_gc(lfs_t *lfs);
+
 #ifndef LFS_READONLY
 // Attempt to make the filesystem consistent and ready for writing
 //
@@ -744,33 +736,11 @@ int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
 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.
 //
-// If LFS_SHRINKNONRELOCATING is defined, this function will also accept
-// block_counts smaller than the current configuration, after checking
-// that none of the blocks that are being removed are in use.
-// Note that littlefs's pseudorandom block allocation means that
-// this is very unlikely to work in the general case.
+// Note: This is irreversible.
 //
 // Returns a negative error code on failure.
 int lfs_fs_grow(lfs_t *lfs, lfs_size_t block_count);
--- a/lfs_util.c
+++ b/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
--- a/lfs_util.h
+++ b/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,26 +15,11 @@
 // 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>
@@ -195,10 +177,10 @@ static inline uint32_t lfs_fromle32(uint32_t a) {
    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
    return __builtin_bswap32(a);
 #else
-    return ((uint32_t)((uint8_t*)&a)[0] <<  0) |
-           ((uint32_t)((uint8_t*)&a)[1] <<  8) |
-           ((uint32_t)((uint8_t*)&a)[2] << 16) |
-           ((uint32_t)((uint8_t*)&a)[3] << 24);
+    return (((uint8_t*)&a)[0] <<  0) |
+           (((uint8_t*)&a)[1] <<  8) |
+           (((uint8_t*)&a)[2] << 16) |
+           (((uint8_t*)&a)[3] << 24);
 #endif
 }

@@ -218,10 +200,10 @@ static inline uint32_t lfs_frombe32(uint32_t a) {
    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
    return a;
 #else
-    return ((uint32_t)((uint8_t*)&a)[0] << 24) |
-           ((uint32_t)((uint8_t*)&a)[1] << 16) |
-           ((uint32_t)((uint8_t*)&a)[2] <<  8) |
-           ((uint32_t)((uint8_t*)&a)[3] <<  0);
+    return (((uint8_t*)&a)[0] << 24) |
+           (((uint8_t*)&a)[1] << 16) |
+           (((uint8_t*)&a)[2] <<  8) |
+           (((uint8_t*)&a)[3] <<  0);
 #endif
 }

@@ -230,22 +212,12 @@ static inline uint32_t lfs_tobe32(uint32_t a) {
 }

 // Calculate CRC-32 with polynomial = 0x04c11db7
-#ifdef LFS_CRC
-static inline 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 +227,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;
--- a/runners/bench_runner.c
+++ b/runners/bench_runner.c
@@ -123,13 +123,8 @@ typedef struct bench_id {


 // bench suites are linked into a custom ld section
-#if defined(__APPLE__)
-extern struct bench_suite __start__bench_suites __asm("section$start$__DATA$_bench_suites");
-extern struct bench_suite __stop__bench_suites __asm("section$end$__DATA$_bench_suites");
-#else
 extern struct bench_suite __start__bench_suites;
 extern struct bench_suite __stop__bench_suites;
-#endif

 const struct bench_suite *bench_suites = &__start__bench_suites;
 #define BENCH_SUITE_COUNT \
@@ -1326,9 +1321,6 @@ 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 = {
--- a/runners/bench_runner.h
+++ b/runners/bench_runner.h
@@ -95,14 +95,11 @@ intmax_t bench_define(size_t define);
 #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_CYCLES_i       8
+#define ERASE_VALUE_i        9
+#define ERASE_CYCLES_i       10
+#define BADBLOCK_BEHAVIOR_i  11
+#define POWERLOSS_BEHAVIOR_i 12

 #define READ_SIZE           bench_define(READ_SIZE_i)
 #define PROG_SIZE           bench_define(PROG_SIZE_i)
@@ -112,9 +109,6 @@ intmax_t bench_define(size_t define);
 #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)
@@ -130,9 +124,6 @@ intmax_t bench_define(size_t define);
    BENCH_DEF(BLOCK_COUNT,        ERASE_COUNT/lfs_max(BLOCK_SIZE/ERASE_SIZE,1))\
    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 +131,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 13


 #endif
--- a/runners/test_runner.c
+++ b/runners/test_runner.c
@@ -136,13 +136,8 @@ typedef struct test_id {


 // test suites are linked into a custom ld section
-#if defined(__APPLE__)
-extern struct test_suite __start__test_suites __asm("section$start$__DATA$_test_suites");
-extern struct test_suite __stop__test_suites __asm("section$end$__DATA$_test_suites");
-#else
 extern struct test_suite __start__test_suites;
 extern struct test_suite __stop__test_suites;
-#endif

 const struct test_suite *test_suites = &__start__test_suites;
 #define TEST_SUITE_COUNT \
@@ -1351,9 +1346,6 @@ 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
@@ -1430,9 +1422,6 @@ 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
@@ -1526,9 +1515,6 @@ 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
@@ -1620,9 +1606,6 @@ 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
@@ -1812,9 +1795,6 @@ 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
--- a/runners/test_runner.h
+++ b/runners/test_runner.h
@@ -88,15 +88,12 @@ intmax_t test_define(size_t define);
 #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_CYCLES_i       8
+#define ERASE_VALUE_i        9
+#define ERASE_CYCLES_i       10
+#define BADBLOCK_BEHAVIOR_i  11
+#define POWERLOSS_BEHAVIOR_i 12
+#define DISK_VERSION_i       13

 #define READ_SIZE           TEST_DEFINE(READ_SIZE_i)
 #define PROG_SIZE           TEST_DEFINE(PROG_SIZE_i)
@@ -106,9 +103,6 @@ intmax_t test_define(size_t define);
 #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)
@@ -125,9 +119,6 @@ intmax_t test_define(size_t define);
    TEST_DEF(BLOCK_COUNT,        ERASE_COUNT/lfs_max(BLOCK_SIZE/ERASE_SIZE,1)) \
    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) \
@@ -136,7 +127,7 @@ intmax_t test_define(size_t define);
    TEST_DEF(DISK_VERSION,       0)

 #define TEST_GEOMETRY_DEFINE_COUNT 4
-#define TEST_IMPLICIT_DEFINE_COUNT 17
+#define TEST_IMPLICIT_DEFINE_COUNT 14


 #endif
--- a/scripts/bench.py
+++ b/scripts/bench.py
@@ -404,15 +404,12 @@ def compile(bench_paths, **args):
                        f.writeln()

                # create suite struct
-                f.writeln('#if defined(__APPLE__)')
-                f.writeln('__attribute__((section("__DATA,_bench_suites")))')
-                f.writeln('#else')
+                #
                # note we place this in the custom bench_suites section with
                # minimum alignment, otherwise GCC ups the alignment to
                # 32-bytes for some reason
                f.writeln('__attribute__((section("_bench_suites"), '
                    'aligned(1)))')
-                f.writeln('#endif')
                f.writeln('const struct bench_suite __bench__%s__suite = {'
                    % suite.name)
                f.writeln(4*' '+'.name = "%s",' % suite.name)
--- a/scripts/changeprefix.py
+++ b/scripts/changeprefix.py
@@ -73,7 +73,7 @@ def changefile(from_prefix, to_prefix, from_path, to_path, *,
        shutil.copystat(from_path, to_path)

    if to_path_temp:
-        shutil.move(to_path, from_path)
+        os.rename(to_path, from_path)
    elif from_path != '-':
        os.remove(from_path)

--- a/scripts/prettyasserts.py
+++ b/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)
--- a/scripts/test.py
+++ b/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')))
@@ -412,15 +412,12 @@ def compile(test_paths, **args):
                        f.writeln()

                # create suite struct
-                f.writeln('#if defined(__APPLE__)')
-                f.writeln('__attribute__((section("__DATA,_test_suites")))')
-                f.writeln('#else')
+                #
                # note we place this in the custom test_suites section with
                # minimum alignment, otherwise GCC ups the alignment to
                # 32-bytes for some reason
                f.writeln('__attribute__((section("_test_suites"), '
                    'aligned(1)))')
-                f.writeln('#endif')
                f.writeln('const struct test_suite __test__%s__suite = {'
                    % suite.name)
                f.writeln(4*' '+'.name = "%s",' % suite.name)
@@ -605,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)
@@ -635,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)
@@ -679,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)
@@ -709,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:
@@ -784,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()

--- a/tests/test_alloc.toml
+++ b/tests/test_alloc.toml
@@ -7,23 +7,17 @@ if = 'BLOCK_CYCLES == -1'
 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]);
@@ -44,7 +38,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]);
@@ -66,23 +60,17 @@ code = '''
 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;
@@ -101,7 +89,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]);
@@ -123,24 +111,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 +141,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 +157,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 +173,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 +230,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");
@@ -288,7 +261,7 @@ code = '''
    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 +274,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);
@@ -347,7 +315,7 @@ code = '''
    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 +328,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;
--- a/tests/test_dirs.toml
+++ b/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,21 +717,34 @@ code = '''
    lfs_unmount(&lfs) => 0;
 '''

-[cases.test_dirs_remove_read]
-defines.N = 10
-if = 'N < BLOCK_COUNT/2'
+# littlefs should keep directories in lexicographic order
+[cases.test_dirs_ordering]
+# ORDER=0 => inorder
+# ORDER=1 => reversed
+# ORDER=2 => random
+defines.ORDER = [0, 1, 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;
+    if (ORDER == 0) {
+        lfs_mkdir(&lfs, "a") => 0;
+        lfs_mkdir(&lfs, "b") => 0;
+        lfs_mkdir(&lfs, "c") => 0;
+    } else if (ORDER == 1) {
+        lfs_mkdir(&lfs, "c") => 0;
+        lfs_mkdir(&lfs, "b") => 0;
+        lfs_mkdir(&lfs, "a") => 0;
+    } else if (ORDER == 2) {
+        // "random"
+        lfs_mkdir(&lfs, "a") => 0;
+        lfs_mkdir(&lfs, "c") => 0;
+        lfs_mkdir(&lfs, "b") => 0;
    }
+
+    // check the order
    lfs_dir_t dir;
-    lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
    struct lfs_info info;
    lfs_dir_read(&lfs, &dir, &info) => 1;
    assert(info.type == LFS_TYPE_DIR);
@@ -747,58 +752,68 @@ code = '''
    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) => 1;
+    assert(info.type == LFS_TYPE_DIR);
+    assert(strcmp(info.name, "a") == 0);
+    lfs_dir_read(&lfs, &dir, &info) => 1;
+    assert(info.type == LFS_TYPE_DIR);
+    assert(strcmp(info.name, "b") == 0);
+    lfs_dir_read(&lfs, &dir, &info) => 1;
+    assert(info.type == LFS_TYPE_DIR);
+    assert(strcmp(info.name, "c") == 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);
-            }
+    lfs_unmount(&lfs) => 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_ordering_length]
+# ORDER=0 => inorder
+# ORDER=1 => reversed
+# ORDER=2 => random
+defines.ORDER = [0, 1, 2]
+code = '''
+    lfs_t lfs;
+    lfs_format(&lfs, cfg) => 0;
+    lfs_mount(&lfs, cfg) => 0;
+    if (ORDER == 0) {
+        lfs_mkdir(&lfs, "a") => 0;
+        lfs_mkdir(&lfs, "aa") => 0;
+        lfs_mkdir(&lfs, "aaa") => 0;
+    } else if (ORDER == 1) {
+        lfs_mkdir(&lfs, "aaa") => 0;
+        lfs_mkdir(&lfs, "aa") => 0;
+        lfs_mkdir(&lfs, "a") => 0;
+    } else if (ORDER == 2) {
+        // "random"
+        lfs_mkdir(&lfs, "a") => 0;
+        lfs_mkdir(&lfs, "aaa") => 0;
+        lfs_mkdir(&lfs, "aa") => 0;
    }
+
+    // check the order
+    lfs_dir_t dir;
+    lfs_dir_open(&lfs, &dir, "/") => 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);
+    lfs_dir_read(&lfs, &dir, &info) => 1;
+    assert(info.type == LFS_TYPE_DIR);
+    assert(strcmp(info.name, "a") == 0);
+    lfs_dir_read(&lfs, &dir, &info) => 1;
+    assert(info.type == LFS_TYPE_DIR);
+    assert(strcmp(info.name, "aa") == 0);
+    lfs_dir_read(&lfs, &dir, &info) => 1;
+    assert(info.type == LFS_TYPE_DIR);
+    assert(strcmp(info.name, "aaa") == 0);
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
+
+    lfs_unmount(&lfs) => 0;
 '''

 [cases.test_dirs_other_errors]
@@ -831,11 +846,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 +869,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 +889,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;
--- a/tests/test_files.toml
+++ b/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);
--- a/tests/test_interspersed.toml
+++ b/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];
--- a/tests/test_move.toml
+++ b/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);
--- a/tests/test_orphans.toml
+++ b/tests/test_orphans.toml
@@ -98,7 +98,7 @@ code = '''
    lfs_mount(&lfs, cfg) => 0;
    // create an orphan
    lfs_mdir_t orphan;
-    lfs_alloc_ckpoint(&lfs);
+    lfs_alloc_ack(&lfs);
    lfs_dir_alloc(&lfs, &orphan) => 0;
    lfs_dir_commit(&lfs, &orphan, NULL, 0) => 0;

@@ -170,7 +170,7 @@ code = '''
    lfs_mount(&lfs, cfg) => 0;
    // create an orphan
    lfs_mdir_t orphan;
-    lfs_alloc_ckpoint(&lfs);
+    lfs_alloc_ack(&lfs);
    lfs_dir_alloc(&lfs, &orphan) => 0;
    lfs_dir_commit(&lfs, &orphan, NULL, 0) => 0;

@@ -207,8 +207,7 @@ code = '''
 [cases.test_orphans_reentrant]
 reentrant = true
 # TODO fix this case, caused by non-DAG trees
-# NOTE the second condition is required
-if = '!(DEPTH == 3 && CACHE_SIZE != 64) && 2*FILES < BLOCK_COUNT'
+if = '!(DEPTH == 3 && CACHE_SIZE != 64)'
 defines = [
    {FILES=6,  DEPTH=1, CYCLES=20},
    {FILES=26, DEPTH=1, CYCLES=20},
@@ -272,69 +271,3 @@ code = '''
    lfs_unmount(&lfs) => 0;
 '''

-# non-reentrant testing for orphans, this is the same as reentrant
-# testing, but we test way more states than we could under powerloss
-[cases.test_orphans_nonreentrant]
-# TODO fix this case, caused by non-DAG trees
-# NOTE the second condition is required
-if = '!(DEPTH == 3 && CACHE_SIZE != 64) && 2*FILES < BLOCK_COUNT'
-defines = [
-    {FILES=6,   DEPTH=1, CYCLES=2000},
-    {FILES=26,  DEPTH=1, CYCLES=2000},
-    {FILES=3,   DEPTH=3, CYCLES=2000},
-]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-
-    uint32_t prng = 1;
-    const char alpha[] = "abcdefghijklmnopqrstuvwxyz";
-    for (unsigned i = 0; i < CYCLES; i++) {
-        // create random path
-        char full_path[256];
-        for (unsigned d = 0; d < DEPTH; d++) {
-            sprintf(&full_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
-        }
-
-        // if it does not exist, we create it, else we destroy
-        struct lfs_info info;
-        int res = lfs_stat(&lfs, full_path, &info);
-        if (res == LFS_ERR_NOENT) {
-            // create each directory in turn, ignore if dir already exists
-            for (unsigned d = 0; d < DEPTH; d++) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                int err = lfs_mkdir(&lfs, path);
-                assert(!err || err == LFS_ERR_EXIST);
-            }
-
-            for (unsigned d = 0; d < DEPTH; d++) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                lfs_stat(&lfs, path, &info) => 0;
-                assert(strcmp(info.name, &path[2*d+1]) == 0);
-                assert(info.type == LFS_TYPE_DIR);
-            }
-        } else {
-            // is valid dir?
-            assert(strcmp(info.name, &full_path[2*(DEPTH-1)+1]) == 0);
-            assert(info.type == LFS_TYPE_DIR);
-
-            // try to delete path in reverse order, ignore if dir is not empty
-            for (int d = DEPTH-1; d >= 0; d--) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                int err = lfs_remove(&lfs, path);
-                assert(!err || err == LFS_ERR_NOTEMPTY);
-            }
-
-            lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
-        }
-    }
-    lfs_unmount(&lfs) => 0;
-'''
-
--- a/tests/test_paths.toml
+++ b/tests/test_paths.toml
--- a/tests/test_relocations.toml
+++ b/tests/test_relocations.toml
@@ -341,171 +341,3 @@ code = '''
    }
    lfs_unmount(&lfs) => 0;
 '''
-
-# non-reentrant testing for orphans, this is the same as reentrant
-# testing, but we test way more states than we could under powerloss
-[cases.test_relocations_nonreentrant]
-# TODO fix this case, caused by non-DAG trees
-# NOTE the second condition is required
-if = '!(DEPTH == 3 && CACHE_SIZE != 64) && 2*FILES < BLOCK_COUNT'
-defines = [
-    {FILES=6,  DEPTH=1, CYCLES=2000, BLOCK_CYCLES=1},
-    {FILES=26, DEPTH=1, CYCLES=2000, BLOCK_CYCLES=1},
-    {FILES=3,  DEPTH=3, CYCLES=2000, BLOCK_CYCLES=1},
-]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-
-    uint32_t prng = 1;
-    const char alpha[] = "abcdefghijklmnopqrstuvwxyz";
-    for (unsigned i = 0; i < CYCLES; i++) {
-        // create random path
-        char full_path[256];
-        for (unsigned d = 0; d < DEPTH; d++) {
-            sprintf(&full_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
-        }
-
-        // if it does not exist, we create it, else we destroy
-        struct lfs_info info;
-        int res = lfs_stat(&lfs, full_path, &info);
-        if (res == LFS_ERR_NOENT) {
-            // create each directory in turn, ignore if dir already exists
-            for (unsigned d = 0; d < DEPTH; d++) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                int err = lfs_mkdir(&lfs, path);
-                assert(!err || err == LFS_ERR_EXIST);
-            }
-
-            for (unsigned d = 0; d < DEPTH; d++) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                lfs_stat(&lfs, path, &info) => 0;
-                assert(strcmp(info.name, &path[2*d+1]) == 0);
-                assert(info.type == LFS_TYPE_DIR);
-            }
-        } else {
-            // is valid dir?
-            assert(strcmp(info.name, &full_path[2*(DEPTH-1)+1]) == 0);
-            assert(info.type == LFS_TYPE_DIR);
-
-            // try to delete path in reverse order, ignore if dir is not empty
-            for (unsigned d = DEPTH-1; d+1 > 0; d--) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                int err = lfs_remove(&lfs, path);
-                assert(!err || err == LFS_ERR_NOTEMPTY);
-            }
-
-            lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
-        }
-    }
-    lfs_unmount(&lfs) => 0;
-'''
-
-# non-reentrant testing for relocations, but now with random renames!
-[cases.test_relocations_nonreentrant_renames]
-# TODO fix this case, caused by non-DAG trees
-# NOTE the second condition is required
-if = '!(DEPTH == 3 && CACHE_SIZE != 64) && 2*FILES < BLOCK_COUNT'
-defines = [
-    {FILES=6,  DEPTH=1, CYCLES=2000, BLOCK_CYCLES=1},
-    {FILES=26, DEPTH=1, CYCLES=2000, BLOCK_CYCLES=1},
-    {FILES=3,  DEPTH=3, CYCLES=2000, BLOCK_CYCLES=1},
-]
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-
-    uint32_t prng = 1;
-    const char alpha[] = "abcdefghijklmnopqrstuvwxyz";
-    for (unsigned i = 0; i < CYCLES; i++) {
-        // create random path
-        char full_path[256];
-        for (unsigned d = 0; d < DEPTH; d++) {
-            sprintf(&full_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
-        }
-
-        // if it does not exist, we create it, else we destroy
-        struct lfs_info info;
-        int res = lfs_stat(&lfs, full_path, &info);
-        assert(!res || res == LFS_ERR_NOENT);
-        if (res == LFS_ERR_NOENT) {
-            // create each directory in turn, ignore if dir already exists
-            for (unsigned d = 0; d < DEPTH; d++) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                int err = lfs_mkdir(&lfs, path);
-                assert(!err || err == LFS_ERR_EXIST);
-            }
-
-            for (unsigned d = 0; d < DEPTH; d++) {
-                char path[1024];
-                strcpy(path, full_path);
-                path[2*d+2] = '\0';
-                lfs_stat(&lfs, path, &info) => 0;
-                assert(strcmp(info.name, &path[2*d+1]) == 0);
-                assert(info.type == LFS_TYPE_DIR);
-            }
-        } else {
-            assert(strcmp(info.name, &full_path[2*(DEPTH-1)+1]) == 0);
-            assert(info.type == LFS_TYPE_DIR);
-
-            // create new random path
-            char new_path[256];
-            for (unsigned d = 0; d < DEPTH; d++) {
-                sprintf(&new_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
-            }
-
-            // if new path does not exist, rename, otherwise destroy
-            res = lfs_stat(&lfs, new_path, &info);
-            assert(!res || res == LFS_ERR_NOENT);
-            if (res == LFS_ERR_NOENT) {
-                // stop once some dir is renamed
-                for (unsigned d = 0; d < DEPTH; d++) {
-                    char path[1024];
-                    strcpy(&path[2*d], &full_path[2*d]);
-                    path[2*d+2] = '\0';
-                    strcpy(&path[128+2*d], &new_path[2*d]);
-                    path[128+2*d+2] = '\0';
-                    int err = lfs_rename(&lfs, path, path+128);
-                    assert(!err || err == LFS_ERR_NOTEMPTY);
-                    if (!err) {
-                        strcpy(path, path+128);
-                    }
-                }
-
-                for (unsigned d = 0; d < DEPTH; d++) {
-                    char path[1024];
-                    strcpy(path, new_path);
-                    path[2*d+2] = '\0';
-                    lfs_stat(&lfs, path, &info) => 0;
-                    assert(strcmp(info.name, &path[2*d+1]) == 0);
-                    assert(info.type == LFS_TYPE_DIR);
-                }
-
-                lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
-            } else {
-                // try to delete path in reverse order,
-                // ignore if dir is not empty
-                for (unsigned d = DEPTH-1; d+1 > 0; d--) {
-                    char path[1024];
-                    strcpy(path, full_path);
-                    path[2*d+2] = '\0';
-                    int err = lfs_remove(&lfs, path);
-                    assert(!err || err == LFS_ERR_NOTEMPTY);
-                }
-
-                lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
-            }
-        }
-    }
-    lfs_unmount(&lfs) => 0;
-'''
--- a/tests/test_seek.toml
+++ b/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;
-'''
--- a/tests/test_shrink.toml
+++ b/tests/test_shrink.toml
@@ -1,109 +0,0 @@
-# simple shrink
-[cases.test_shrink_simple]
-defines.BLOCK_COUNT = [10, 15, 20]
-defines.AFTER_BLOCK_COUNT = [5, 10, 15, 19]
-   
-if = "AFTER_BLOCK_COUNT <= BLOCK_COUNT"
-code = '''
-#ifdef LFS_SHRINKNONRELOCATING
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_fs_grow(&lfs, AFTER_BLOCK_COUNT) => 0;
-    lfs_unmount(&lfs);
-    if (BLOCK_COUNT != AFTER_BLOCK_COUNT) {
-        lfs_mount(&lfs, cfg) => LFS_ERR_INVAL;
-    }
-    lfs_t lfs2 = lfs;
-    struct lfs_config cfg2 = *cfg;
-    cfg2.block_count = AFTER_BLOCK_COUNT;
-    lfs2.cfg = &cfg2;
-    lfs_mount(&lfs2, &cfg2) => 0;
-    lfs_unmount(&lfs2) => 0;
-#endif
-'''
-
-# shrinking full
-[cases.test_shrink_full]
-defines.BLOCK_COUNT = [10, 15, 20]
-defines.AFTER_BLOCK_COUNT = [5, 7, 10, 12, 15, 17, 20]
-defines.FILES_COUNT = [7, 8, 9, 10]
-if = "AFTER_BLOCK_COUNT <= BLOCK_COUNT && FILES_COUNT + 2 < BLOCK_COUNT"
-code = '''
-#ifdef LFS_SHRINKNONRELOCATING
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-    // create FILES_COUNT files of BLOCK_SIZE - 50 bytes (to avoid inlining)
-    lfs_mount(&lfs, cfg) => 0;
-    for (int i = 0; i < FILES_COUNT + 1; i++) {
-        lfs_file_t file;
-        char path[1024];
-        sprintf(path, "file_%03d", i);
-        lfs_file_open(&lfs, &file, path,
-                LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
-        char wbuffer[BLOCK_SIZE];
-        memset(wbuffer, 'b', BLOCK_SIZE);
-        // Ensure one block is taken per file, but that files are not inlined.
-        lfs_size_t size = BLOCK_SIZE - 0x40;
-        sprintf(wbuffer, "Hi %03d", i);
-        lfs_file_write(&lfs, &file, wbuffer, size) => size;
-        lfs_file_close(&lfs, &file) => 0;
-    }
-
-    int err = lfs_fs_grow(&lfs, AFTER_BLOCK_COUNT);
-    if (err == 0) {
-        for (int i = 0; i < FILES_COUNT + 1; i++) {
-            lfs_file_t file;
-            char path[1024];
-            sprintf(path, "file_%03d", i);
-            lfs_file_open(&lfs, &file, path,
-                    LFS_O_RDONLY ) => 0;
-            lfs_size_t size = BLOCK_SIZE - 0x40;
-            char wbuffer[size];
-            char wbuffer_ref[size];
-            // Ensure one block is taken per file, but that files are not inlined.
-            memset(wbuffer_ref, 'b', size);
-            sprintf(wbuffer_ref, "Hi %03d", i);
-            lfs_file_read(&lfs, &file, wbuffer, BLOCK_SIZE) => size;
-            lfs_file_close(&lfs, &file) => 0;
-            for (lfs_size_t j = 0; j < size; j++) {
-                wbuffer[j] => wbuffer_ref[j];
-            }
-        }
-    } else {
-        assert(err == LFS_ERR_NOTEMPTY);
-    }
-
-    lfs_unmount(&lfs) => 0;
-    if (err == 0 ) {
-        if ( AFTER_BLOCK_COUNT != BLOCK_COUNT ) {
-            lfs_mount(&lfs, cfg) => LFS_ERR_INVAL;
-        }
-
-        lfs_t lfs2 = lfs;
-        struct lfs_config cfg2 = *cfg;
-        cfg2.block_count = AFTER_BLOCK_COUNT;
-        lfs2.cfg = &cfg2;
-        lfs_mount(&lfs2, &cfg2) => 0;
-        for (int i = 0; i < FILES_COUNT + 1; i++) {
-            lfs_file_t file;
-            char path[1024];
-            sprintf(path, "file_%03d", i);
-            lfs_file_open(&lfs2, &file, path,
-                    LFS_O_RDONLY ) => 0;
-            lfs_size_t size = BLOCK_SIZE - 0x40;
-            char wbuffer[size];
-            char wbuffer_ref[size];
-            // Ensure one block is taken per file, but that files are not inlined.
-            memset(wbuffer_ref, 'b', size);
-            sprintf(wbuffer_ref, "Hi %03d", i);
-            lfs_file_read(&lfs2, &file, wbuffer, BLOCK_SIZE) => size;
-            lfs_file_close(&lfs2, &file) => 0;
-            for (lfs_size_t j = 0; j < size; j++) {
-                wbuffer[j] => wbuffer_ref[j];
-            }
-        }
-        lfs_unmount(&lfs2);
-    }
-#endif
-'''
--- a/tests/test_superblocks.toml
+++ b/tests/test_superblocks.toml
@@ -14,24 +14,6 @@ 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 = '''
@@ -46,13 +28,10 @@ code = '''
    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);
@@ -152,39 +131,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 +174,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);
@@ -271,7 +213,6 @@ code = '''
    lfs_unmount(&lfs) => 0;
 '''

-
 # mount with unknown block_count
 [cases.test_superblocks_unknown_blocks]
 code = '''
@@ -523,138 +464,3 @@ code = '''
    assert(memcmp(buffer, "hello!", 6) == 0);
    lfs_unmount(&lfs) => 0;
 '''
-
-
-# mount and grow the filesystem
-[cases.test_superblocks_shrink]
-defines.BLOCK_COUNT = 'ERASE_COUNT'
-defines.BLOCK_COUNT_2 = ['ERASE_COUNT/2', 'ERASE_COUNT/4', '2']
-defines.KNOWN_BLOCK_COUNT = [true, false]
-code = '''
-#ifdef LFS_SHRINKNONRELOCATING
-    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;
-#endif
-'''
-
-# 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;
-'''
--- a/tests/test_truncate.toml
+++ b/tests/test_truncate.toml
@@ -231,10 +231,6 @@ defines.SMALLSIZE = [4, 512]
 defines.MEDIUMSIZE = [0, 3, 4, 5, 31, 32, 33, 511, 512, 513, 1023, 1024, 1025]
 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);