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

.gitattributes

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

.github/workflows/release.yml

@@ -102,7 +102,7 @@ jobs:
           # sizes table
           i=0
           j=0
-          for c in "" readonly threadsafe multiversion migrate error-asserts
+          for c in "" readonly threadsafe migrate error-asserts
           do
             # per-config results
             c_or_default=${c:-default}

.github/workflows/test.yml

@@ -170,27 +170,6 @@ jobs:
           cp lfs.data.csv sizes/${{matrix.arch}}-threadsafe.data.csv
           cp lfs.stack.csv sizes/${{matrix.arch}}-threadsafe.stack.csv
           cp lfs.structs.csv sizes/${{matrix.arch}}-threadsafe.structs.csv
-      - name: sizes-multiversion
-        run: |
-          make clean
-          CFLAGS="$CFLAGS \
-            -DLFS_NO_ASSERT \
-            -DLFS_NO_DEBUG \
-            -DLFS_NO_WARN \
-            -DLFS_NO_ERROR \
-            -DLFS_MULTIVERSION" \
-            make lfs.code.csv lfs.data.csv lfs.stack.csv lfs.structs.csv
-          ./scripts/structs.py -u lfs.structs.csv
-          ./scripts/summary.py lfs.code.csv lfs.data.csv lfs.stack.csv \
-            -bfunction \
-            -fcode=code_size \
-            -fdata=data_size \
-            -fstack=stack_limit --max=stack_limit
-          mkdir -p sizes
-          cp lfs.code.csv sizes/${{matrix.arch}}-multiversion.code.csv
-          cp lfs.data.csv sizes/${{matrix.arch}}-multiversion.data.csv
-          cp lfs.stack.csv sizes/${{matrix.arch}}-multiversion.stack.csv
-          cp lfs.structs.csv sizes/${{matrix.arch}}-multiversion.structs.csv
       - name: sizes-migrate
         run: |
           make clean
@@ -374,42 +353,6 @@ jobs:
         run: |
           CFLAGS="$CFLAGS -DLFS_NO_INTRINSICS" make test
 
-  # run LFS_MULTIVERSION tests
-  test-multiversion:
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v2
-      - name: install
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      - name: test-multiversion
-        run: |
-          CFLAGS="$CFLAGS -DLFS_MULTIVERSION" make test
-
-  # run tests on the older version lfs2.0
-  test-lfs2_0:
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v2
-      - name: install
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      - name: test-lfs2_0
-        run: |
-          CFLAGS="$CFLAGS -DLFS_MULTIVERSION" \
-          TESTFLAGS="$TESTFLAGS -DDISK_VERSION=0x00020000" \
-            make test
-
   # run under Valgrind to check for memory errors
   test-valgrind:
     runs-on: ubuntu-22.04
@@ -428,8 +371,7 @@ jobs:
       # on one geometry
       - name: test-valgrind
         run: |
-          TESTFLAGS="$TESTFLAGS --valgrind --context=1024 -Gdefault -Pnone" \
-            make test
+          TESTFLAGS="$TESTFLAGS --valgrind -Gdefault -Pnone" make test
 
   # test that compilation is warning free under clang
   # run with Clang, mostly to check for Clang-specific warnings
@@ -531,42 +473,6 @@ jobs:
           path: status
           retention-days: 1
 
-  # run compatibility tests using the current master as the previous version
-  test-compat:
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v2
-        if: ${{github.event_name == 'pull_request'}}
-      # checkout the current pr target into lfsp
-      - uses: actions/checkout@v2
-        if: ${{github.event_name == 'pull_request'}}
-        with:
-          ref: ${{github.event.pull_request.base.ref}}
-          path: lfsp
-      - name: install
-        if: ${{github.event_name == 'pull_request'}}
-        run: |
-          # need a few things
-          sudo apt-get update -qq
-          sudo apt-get install -qq gcc python3 python3-pip
-          pip3 install toml
-          gcc --version
-          python3 --version
-      # adjust prefix of lfsp
-      - name: changeprefix
-        if: ${{github.event_name == 'pull_request'}}
-        run: |
-          ./scripts/changeprefix.py lfs lfsp lfsp/*.h lfsp/*.c
-      - name: test-compat
-        if: ${{github.event_name == 'pull_request'}}
-        run: |
-          TESTS=tests/test_compat.toml \
-            SRC="$(find . lfsp -name '*.c' -maxdepth 1 \
-                -and -not -name '*.t.*' \
-                -and -not -name '*.b.*')" \
-            CFLAGS="-DLFSP=lfsp/lfsp.h" \
-            make test
-
   # self-host with littlefs-fuse for a fuzz-like test
   fuse:
     runs-on: ubuntu-22.04
@@ -742,7 +648,7 @@ jobs:
           # sizes table
           i=0
           j=0
-          for c in "" readonly threadsafe multiversion migrate error-asserts
+          for c in "" readonly threadsafe migrate error-asserts
           do
             # per-config results
             c_or_default=${c:-default}

Makefile

@@ -1,5 +1,15 @@
-# overrideable build dir, default is in-place
+ifdef BUILDDIR
+# bit of a hack, but we want to make sure BUILDDIR directory structure
+# is correct before any commands
+$(if $(findstring n,$(MAKEFLAGS)),, $(shell mkdir -p \
+	$(BUILDDIR)/ \
+	$(BUILDDIR)/bd \
+	$(BUILDDIR)/runners \
+	$(BUILDDIR)/tests \
+	$(BUILDDIR)/benches))
+endif
 BUILDDIR ?= .
+
 # overridable target/src/tools/flags/etc
 ifneq ($(wildcard test.c main.c),)
 TARGET ?= $(BUILDDIR)/lfs
@@ -153,18 +163,6 @@ TESTFLAGS  += --perf-path="$(PERF)"
 BENCHFLAGS += --perf-path="$(PERF)"
 endif
 
-# this is a bit of a hack, but we want to make sure the BUILDDIR
-# directory structure is correct before we run any commands
-ifneq ($(BUILDDIR),.)
-$(if $(findstring n,$(MAKEFLAGS)),, $(shell mkdir -p \
-	$(addprefix $(BUILDDIR)/,$(dir \
-		$(SRC) \
-		$(TESTS) \
-		$(TEST_SRC) \
-		$(BENCHES) \
-		$(BENCH_SRC)))))
-endif
-
 
 # commands
 
@@ -516,9 +514,6 @@ $(BUILDDIR)/runners/bench_runner: $(BENCH_OBJ)
 $(BUILDDIR)/%.o $(BUILDDIR)/%.ci: %.c
 	$(CC) -c -MMD $(CFLAGS) $< -o $(BUILDDIR)/$*.o
 
-$(BUILDDIR)/%.o $(BUILDDIR)/%.ci: $(BUILDDIR)/%.c
-	$(CC) -c -MMD $(CFLAGS) $< -o $(BUILDDIR)/$*.o
-
 $(BUILDDIR)/%.s: %.c
 	$(CC) -S $(CFLAGS) $< -o $@
 

README.md

@@ -226,13 +226,6 @@ License Identifiers that are here available: http://spdx.org/licenses/
   to create images of the filesystem on your PC. Check if littlefs will fit
   your needs, create images for a later download to the target memory or
   inspect the content of a binary image of the target memory.
-  
-- [littlefs2-rust] - A Rust wrapper for littlefs. This project allows you
-  to use littlefs in a Rust-friendly API, reaping the benefits of Rust's memory
-  safety and other guarantees.
-
-- [littlefs-disk-img-viewer] - A memory-efficient web application for viewing
-  littlefs disk images in your web browser.
 
 - [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.
@@ -250,16 +243,8 @@ License Identifiers that are here available: http://spdx.org/licenses/
   MCUs. It offers static wear-leveling and power-resilience with only a fixed
   _O(|address|)_ pointer structure stored on each block and in RAM.
 
-- [ChaN's FatFs] - A lightweight reimplementation of the infamous FAT filesystem
-  for microcontroller-scale devices. Due to limitations of FAT it can't provide
-  power-loss resilience, but it does allow easy interop with PCs.
-
-- [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
@@ -270,7 +255,4 @@ License Identifiers that are here available: http://spdx.org/licenses/
 [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

SPEC.md

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

lfs.c

@@ -409,7 +409,7 @@ static inline bool lfs_gstate_hasorphans(const lfs_gstate_t *a) {
 }
 
 static inline uint8_t lfs_gstate_getorphans(const lfs_gstate_t *a) {
-    return lfs_tag_size(a->tag) & 0x1ff;
+    return lfs_tag_size(a->tag);
 }
 
 static inline bool lfs_gstate_hasmove(const lfs_gstate_t *a) {
@@ -417,10 +417,6 @@ static inline bool lfs_gstate_hasmove(const lfs_gstate_t *a) {
 }
 #endif
 
-static inline bool lfs_gstate_needssuperblock(const lfs_gstate_t *a) {
-    return lfs_tag_size(a->tag) >> 9;
-}
-
 static inline bool lfs_gstate_hasmovehere(const lfs_gstate_t *a,
         const lfs_block_t *pair) {
     return lfs_tag_type1(a->tag) && lfs_pair_cmp(a->pair, pair) == 0;
@@ -518,28 +514,6 @@ static void lfs_mlist_append(lfs_t *lfs, struct lfs_mlist *mlist) {
     lfs->mlist = mlist;
 }
 
-// some other filesystem operations
-static uint32_t lfs_fs_disk_version(lfs_t *lfs) {
-    (void)lfs;
-#ifdef LFS_MULTIVERSION
-    if (lfs->cfg->disk_version) {
-        return lfs->cfg->disk_version;
-    } else
-#endif
-    {
-        return LFS_DISK_VERSION;
-    }
-}
-
-static uint16_t lfs_fs_disk_version_major(lfs_t *lfs) {
-    return 0xffff & (lfs_fs_disk_version(lfs) >> 16);
-
-}
-
-static uint16_t lfs_fs_disk_version_minor(lfs_t *lfs) {
-    return 0xffff & (lfs_fs_disk_version(lfs) >> 0);
-}
-
 
 /// Internal operations predeclared here ///
 #ifndef LFS_READONLY
@@ -567,8 +541,6 @@ static lfs_stag_t lfs_fs_parent(lfs_t *lfs, const lfs_block_t dir[2],
 static int lfs_fs_forceconsistency(lfs_t *lfs);
 #endif
 
-static void lfs_fs_prepsuperblock(lfs_t *lfs, bool needssuperblock);
-
 #ifdef LFS_MIGRATE
 static int lfs1_traverse(lfs_t *lfs,
         int (*cb)(void*, lfs_block_t), void *data);
@@ -1133,8 +1105,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
 
             // next commit not yet programmed?
             if (!lfs_tag_isvalid(tag)) {
-                // we only might be erased if the last tag was a crc
-                maybeerased = (lfs_tag_type2(ptag) == LFS_TYPE_CCRC);
+                maybeerased = true;
                 break;
             // out of range?
             } else if (off + lfs_tag_dsize(tag) > lfs->cfg->block_size) {
@@ -1179,11 +1150,14 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
                 dir->tail[1] = temptail[1];
                 dir->split = tempsplit;
 
-                // reset crc, hasfcrc
+                // reset crc
                 crc = 0xffffffff;
                 continue;
             }
 
+            // fcrc is only valid when last tag was a crc
+            hasfcrc = false;
+
             // crc the entry first, hopefully leaving it in the cache
             err = lfs_bd_crc(lfs,
                     NULL, &lfs->rcache, lfs->cfg->block_size,
@@ -1277,33 +1251,20 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
 
         // did we end on a valid commit? we may have an erased block
         dir->erased = false;
-        if (maybeerased && dir->off % lfs->cfg->prog_size == 0) {
-        #ifdef LFS_MULTIVERSION
-            // note versions < lfs2.1 did not have fcrc tags, if
-            // we're < lfs2.1 treat missing fcrc as erased data
-            //
-            // we don't strictly need to do this, but otherwise writing
-            // to lfs2.0 disks becomes very inefficient
-            if (lfs_fs_disk_version(lfs) < 0x00020001) {
-                dir->erased = true;
-
-            } else
-        #endif
-            if (hasfcrc) {
-                // check for an fcrc matching the next prog's erased state, if
-                // this failed most likely a previous prog was interrupted, we
-                // need a new erase
-                uint32_t fcrc_ = 0xffffffff;
-                int err = lfs_bd_crc(lfs,
-                        NULL, &lfs->rcache, lfs->cfg->block_size,
-                        dir->pair[0], dir->off, fcrc.size, &fcrc_);
-                if (err && err != LFS_ERR_CORRUPT) {
-                    return err;
-                }
-
-                // found beginning of erased part?
-                dir->erased = (fcrc_ == fcrc.crc);
+        if (maybeerased && hasfcrc && dir->off % lfs->cfg->prog_size == 0) {
+            // check for an fcrc matching the next prog's erased state, if
+            // this failed most likely a previous prog was interrupted, we
+            // need a new erase
+            uint32_t fcrc_ = 0xffffffff;
+            int err = lfs_bd_crc(lfs,
+                    NULL, &lfs->rcache, lfs->cfg->block_size,
+                    dir->pair[0], dir->off, fcrc.size, &fcrc_);
+            if (err && err != LFS_ERR_CORRUPT) {
+                return err;
             }
+
+            // found beginning of erased part?
+            dir->erased = (fcrc_ == fcrc.crc);
         }
 
         // synthetic move
@@ -1628,7 +1589,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
         }
 
         // space for fcrc?
-        uint8_t eperturb = (uint8_t)-1;
+        uint8_t eperturb = -1;
         if (noff >= end && noff <= lfs->cfg->block_size - lfs->cfg->prog_size) {
             // first read the leading byte, this always contains a bit
             // we can perturb to avoid writes that don't change the fcrc
@@ -1639,34 +1600,22 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
                 return err;
             }
 
-        #ifdef LFS_MULTIVERSION
-            // unfortunately fcrcs break mdir fetching < lfs2.1, so only write
-            // these if we're a >= lfs2.1 filesystem
-            if (lfs_fs_disk_version(lfs) <= 0x00020000) {
-                // don't write fcrc
-            } else
-        #endif
-            {
-                // find the expected fcrc, don't bother avoiding a reread
-                // of the eperturb, it should still be in our cache
-                struct lfs_fcrc fcrc = {
-                    .size = lfs->cfg->prog_size,
-                    .crc = 0xffffffff
-                };
-                err = lfs_bd_crc(lfs,
-                        NULL, &lfs->rcache, lfs->cfg->prog_size,
-                        commit->block, noff, fcrc.size, &fcrc.crc);
-                if (err && err != LFS_ERR_CORRUPT) {
-                    return err;
-                }
+            // find the expected fcrc, don't bother avoiding a reread
+            // of the eperturb, it should still be in our cache
+            struct lfs_fcrc fcrc = {.size=lfs->cfg->prog_size, .crc=0xffffffff};
+            err = lfs_bd_crc(lfs,
+                    NULL, &lfs->rcache, lfs->cfg->prog_size,
+                    commit->block, noff, fcrc.size, &fcrc.crc);
+            if (err && err != LFS_ERR_CORRUPT) {
+                return err;
+            }
 
-                lfs_fcrc_tole32(&fcrc);
-                err = lfs_dir_commitattr(lfs, commit,
-                        LFS_MKTAG(LFS_TYPE_FCRC, 0x3ff, sizeof(struct lfs_fcrc)),
-                        &fcrc);
-                if (err) {
-                    return err;
-                }
+            lfs_fcrc_tole32(&fcrc);
+            err = lfs_dir_commitattr(lfs, commit,
+                    LFS_MKTAG(LFS_TYPE_FCRC, 0x3ff, sizeof(struct lfs_fcrc)),
+                    &fcrc);
+            if (err) {
+                return err;
             }
         }
 
@@ -1697,7 +1646,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
 
         commit->off = noff;
         // perturb valid bit?
-        commit->ptag = ntag ^ ((0x80UL & ~eperturb) << 24);
+        commit->ptag = ntag ^ ((0x80 & ~eperturb) << 24);
         // reset crc for next commit
         commit->crc = 0xffffffff;
 
@@ -2758,6 +2707,11 @@ static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
     dir->id = (off > 0 && lfs_pair_cmp(dir->head, lfs->root) == 0);
 
     while (off > 0) {
+        int diff = lfs_min(dir->m.count - dir->id, off);
+        dir->id += diff;
+        dir->pos += diff;
+        off -= diff;
+
         if (dir->id == dir->m.count) {
             if (!dir->m.split) {
                 return LFS_ERR_INVAL;
@@ -2770,11 +2724,6 @@ static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
 
             dir->id = 0;
         }
-
-        int diff = lfs_min(dir->m.count - dir->id, off);
-        dir->id += diff;
-        dir->pos += diff;
-        off -= diff;
     }
 
     return 0;
@@ -3511,7 +3460,7 @@ static lfs_ssize_t lfs_file_flushedwrite(lfs_t *lfs, lfs_file_t *file,
                     // find out which block we're extending from
                     int err = lfs_ctz_find(lfs, NULL, &file->cache,
                             file->ctz.head, file->ctz.size,
-                            file->pos-1, &file->block, &(lfs_off_t){0});
+                            file->pos-1, &file->block, &file->off);
                     if (err) {
                         file->flags |= LFS_F_ERRED;
                         return err;
@@ -3689,55 +3638,26 @@ static int lfs_file_rawtruncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
     lfs_off_t pos = file->pos;
     lfs_off_t oldsize = lfs_file_rawsize(lfs, file);
     if (size < oldsize) {
-        // revert to inline file?
-        if (size <= lfs_min(0x3fe, lfs_min(
-                lfs->cfg->cache_size,
-                (lfs->cfg->metadata_max ?
-                    lfs->cfg->metadata_max : lfs->cfg->block_size) / 8))) {
-            // flush+seek to head
-            lfs_soff_t res = lfs_file_rawseek(lfs, file, 0, LFS_SEEK_SET);
-            if (res < 0) {
-                return (int)res;
-            }
-
-            // read our data into rcache temporarily
-            lfs_cache_drop(lfs, &lfs->rcache);
-            res = lfs_file_flushedread(lfs, file,
-                    lfs->rcache.buffer, size);
-            if (res < 0) {
-                return (int)res;
-            }
-
-            file->ctz.head = LFS_BLOCK_INLINE;
-            file->ctz.size = size;
-            file->flags |= LFS_F_DIRTY | LFS_F_READING | LFS_F_INLINE;
-            file->cache.block = file->ctz.head;
-            file->cache.off = 0;
-            file->cache.size = lfs->cfg->cache_size;
-            memcpy(file->cache.buffer, lfs->rcache.buffer, size);
-
-        } else {
-            // need to flush since directly changing metadata
-            int err = lfs_file_flush(lfs, file);
-            if (err) {
-                return err;
-            }
-
-            // lookup new head in ctz skip list
-            err = lfs_ctz_find(lfs, NULL, &file->cache,
-                    file->ctz.head, file->ctz.size,
-                    size-1, &file->block, &(lfs_off_t){0});
-            if (err) {
-                return err;
-            }
-
-            // need to set pos/block/off consistently so seeking back to
-            // the old position does not get confused
-            file->pos = size;
-            file->ctz.head = file->block;
-            file->ctz.size = size;
-            file->flags |= LFS_F_DIRTY | LFS_F_READING;
+        // need to flush since directly changing metadata
+        int err = lfs_file_flush(lfs, file);
+        if (err) {
+            return err;
         }
+
+        // lookup new head in ctz skip list
+        err = lfs_ctz_find(lfs, NULL, &file->cache,
+                file->ctz.head, file->ctz.size,
+                size, &file->block, &file->off);
+        if (err) {
+            return err;
+        }
+
+        // need to set pos/block/off consistently so seeking back to
+        // the old position does not get confused
+        file->pos = size;
+        file->ctz.head = file->block;
+        file->ctz.size = size;
+        file->flags |= LFS_F_DIRTY | LFS_F_READING;
     } else if (size > oldsize) {
         // flush+seek if not already at end
         lfs_soff_t res = lfs_file_rawseek(lfs, file, 0, LFS_SEEK_END);
@@ -4097,21 +4017,6 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
     lfs->cfg = cfg;
     int err = 0;
 
-#ifdef LFS_MULTIVERSION
-    // this driver only supports minor version < current minor version
-    LFS_ASSERT(!lfs->cfg->disk_version || (
-            (0xffff & (lfs->cfg->disk_version >> 16))
-                    == LFS_DISK_VERSION_MAJOR
-                && (0xffff & (lfs->cfg->disk_version >> 0))
-                    <= LFS_DISK_VERSION_MINOR));
-#endif
-
-    // check that bool is a truthy-preserving type
-    //
-    // note the most common reason for this failure is a before-c99 compiler,
-    // which littlefs currently does not support
-    LFS_ASSERT((bool)0x80000000);
-
     // validate that the lfs-cfg sizes were initiated properly before
     // performing any arithmetic logics with them
     LFS_ASSERT(lfs->cfg->read_size != 0);
@@ -4124,10 +4029,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
     LFS_ASSERT(lfs->cfg->cache_size % lfs->cfg->prog_size == 0);
     LFS_ASSERT(lfs->cfg->block_size % lfs->cfg->cache_size == 0);
 
-    // check that the block size is large enough to fit all ctz pointers
-    LFS_ASSERT(lfs->cfg->block_size >= 128);
-    // this is the exact calculation for all ctz pointers, if this fails
-    // and the simpler assert above does not, math must be broken
+    // check that the block size is large enough to fit ctz pointers
     LFS_ASSERT(4*lfs_npw2(0xffffffff / (lfs->cfg->block_size-2*4))
             <= lfs->cfg->block_size);
 
@@ -4263,7 +4165,7 @@ static int lfs_rawformat(lfs_t *lfs, const struct lfs_config *cfg) {
 
         // write one superblock
         lfs_superblock_t superblock = {
-            .version     = lfs_fs_disk_version(lfs),
+            .version     = LFS_DISK_VERSION,
             .block_size  = lfs->cfg->block_size,
             .block_count = lfs->cfg->block_count,
             .name_max    = lfs->name_max,
@@ -4361,33 +4263,14 @@ static int lfs_rawmount(lfs_t *lfs, const struct lfs_config *cfg) {
             // check version
             uint16_t major_version = (0xffff & (superblock.version >> 16));
             uint16_t minor_version = (0xffff & (superblock.version >>  0));
-            if (major_version != lfs_fs_disk_version_major(lfs)
-                    || minor_version > lfs_fs_disk_version_minor(lfs)) {
-                LFS_ERROR("Invalid version "
-                        "v%"PRIu16".%"PRIu16" != v%"PRIu16".%"PRIu16,
-                        major_version,
-                        minor_version,
-                        lfs_fs_disk_version_major(lfs),
-                        lfs_fs_disk_version_minor(lfs));
+            if ((major_version != LFS_DISK_VERSION_MAJOR ||
+                 minor_version > LFS_DISK_VERSION_MINOR)) {
+                LFS_ERROR("Invalid version v%"PRIu16".%"PRIu16,
+                        major_version, minor_version);
                 err = LFS_ERR_INVAL;
                 goto cleanup;
             }
 
-            // found older minor version? set an in-device only bit in the
-            // gstate so we know we need to rewrite the superblock before
-            // the first write
-            if (minor_version < lfs_fs_disk_version_minor(lfs)) {
-                LFS_DEBUG("Found older minor version "
-                        "v%"PRIu16".%"PRIu16" < v%"PRIu16".%"PRIu16,
-                        major_version,
-                        minor_version,
-                        lfs_fs_disk_version_major(lfs),
-                        lfs_fs_disk_version_minor(lfs));
-                // note this bit is reserved on disk, so fetching more gstate
-                // will not interfere here
-                lfs_fs_prepsuperblock(lfs, true);
-            }
-
             // check superblock configuration
             if (superblock.name_max) {
                 if (superblock.name_max > lfs->name_max) {
@@ -4478,42 +4361,6 @@ static int lfs_rawunmount(lfs_t *lfs) {
 
 
 /// Filesystem filesystem operations ///
-static int lfs_fs_rawstat(lfs_t *lfs, struct lfs_fsinfo *fsinfo) {
-    // if the superblock is up-to-date, we must be on the most recent
-    // minor version of littlefs
-    if (!lfs_gstate_needssuperblock(&lfs->gstate)) {
-        fsinfo->disk_version = lfs_fs_disk_version(lfs);
-
-    // otherwise we need to read the minor version on disk
-    } else {
-        // fetch the superblock
-        lfs_mdir_t dir;
-        int err = lfs_dir_fetch(lfs, &dir, lfs->root);
-        if (err) {
-            return err;
-        }
-
-        lfs_superblock_t superblock;
-        lfs_stag_t tag = lfs_dir_get(lfs, &dir, LFS_MKTAG(0x7ff, 0x3ff, 0),
-                LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
-                &superblock);
-        if (tag < 0) {
-            return tag;
-        }
-        lfs_superblock_fromle32(&superblock);
-
-        // read the on-disk version
-        fsinfo->disk_version = superblock.version;
-    }
-
-    // other on-disk configuration, we cache all of these for internal use
-    fsinfo->name_max = lfs->name_max;
-    fsinfo->file_max = lfs->file_max;
-    fsinfo->attr_max = lfs->attr_max;
-
-    return 0;
-}
-
 int lfs_fs_rawtraverse(lfs_t *lfs,
         int (*cb)(void *data, lfs_block_t block), void *data,
         bool includeorphans) {
@@ -4724,15 +4571,10 @@ static lfs_stag_t lfs_fs_parent(lfs_t *lfs, const lfs_block_t pair[2],
 }
 #endif
 
-static void lfs_fs_prepsuperblock(lfs_t *lfs, bool needssuperblock) {
-    lfs->gstate.tag = (lfs->gstate.tag & ~LFS_MKTAG(0, 0, 0x200))
-            | (uint32_t)needssuperblock << 9;
-}
-
 #ifndef LFS_READONLY
 static int lfs_fs_preporphans(lfs_t *lfs, int8_t orphans) {
     LFS_ASSERT(lfs_tag_size(lfs->gstate.tag) > 0x000 || orphans >= 0);
-    LFS_ASSERT(lfs_tag_size(lfs->gstate.tag) < 0x1ff || orphans <= 0);
+    LFS_ASSERT(lfs_tag_size(lfs->gstate.tag) < 0x3ff || orphans <= 0);
     lfs->gstate.tag += orphans;
     lfs->gstate.tag = ((lfs->gstate.tag & ~LFS_MKTAG(0x800, 0, 0)) |
             ((uint32_t)lfs_gstate_hasorphans(&lfs->gstate) << 31));
@@ -4751,45 +4593,6 @@ static void lfs_fs_prepmove(lfs_t *lfs,
 }
 #endif
 
-#ifndef LFS_READONLY
-static int lfs_fs_desuperblock(lfs_t *lfs) {
-    if (!lfs_gstate_needssuperblock(&lfs->gstate)) {
-        return 0;
-    }
-
-    LFS_DEBUG("Rewriting superblock {0x%"PRIx32", 0x%"PRIx32"}",
-            lfs->root[0],
-            lfs->root[1]);
-
-    lfs_mdir_t root;
-    int err = lfs_dir_fetch(lfs, &root, lfs->root);
-    if (err) {
-        return err;
-    }
-
-    // write a new superblock
-    lfs_superblock_t superblock = {
-        .version     = lfs_fs_disk_version(lfs),
-        .block_size  = lfs->cfg->block_size,
-        .block_count = lfs->cfg->block_count,
-        .name_max    = lfs->name_max,
-        .file_max    = lfs->file_max,
-        .attr_max    = lfs->attr_max,
-    };
-
-    lfs_superblock_tole32(&superblock);
-    err = lfs_dir_commit(lfs, &root, LFS_MKATTRS(
-            {LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
-                &superblock}));
-    if (err) {
-        return err;
-    }
-
-    lfs_fs_prepsuperblock(lfs, false);
-    return 0;
-}
-#endif
-
 #ifndef LFS_READONLY
 static int lfs_fs_demove(lfs_t *lfs) {
     if (!lfs_gstate_hasmove(&lfs->gdisk)) {
@@ -4832,6 +4635,8 @@ static int lfs_fs_deorphan(lfs_t *lfs, bool powerloss) {
         return 0;
     }
 
+    int8_t found = 0;
+
     // Check for orphans in two separate passes:
     // - 1 for half-orphans (relocations)
     // - 2 for full-orphans (removes/renames)
@@ -4902,6 +4707,8 @@ static int lfs_fs_deorphan(lfs_t *lfs, bool powerloss) {
                             return state;
                         }
 
+                        found += 1;
+
                         // did our commit create more orphans?
                         if (state == LFS_OK_ORPHANED) {
                             moreorphans = true;
@@ -4936,6 +4743,8 @@ static int lfs_fs_deorphan(lfs_t *lfs, bool powerloss) {
                         return state;
                     }
 
+                    found += 1;
+
                     // did our commit create more orphans?
                     if (state == LFS_OK_ORPHANED) {
                         moreorphans = true;
@@ -4953,18 +4762,15 @@ static int lfs_fs_deorphan(lfs_t *lfs, bool powerloss) {
     }
 
     // mark orphans as fixed
-    return lfs_fs_preporphans(lfs, -lfs_gstate_getorphans(&lfs->gstate));
+    return lfs_fs_preporphans(lfs, -lfs_min(
+            lfs_gstate_getorphans(&lfs->gstate),
+            found));
 }
 #endif
 
 #ifndef LFS_READONLY
 static int lfs_fs_forceconsistency(lfs_t *lfs) {
-    int err = lfs_fs_desuperblock(lfs);
-    if (err) {
-        return err;
-    }
-
-    err = lfs_fs_demove(lfs);
+    int err = lfs_fs_demove(lfs);
     if (err) {
         return err;
     }
@@ -4978,36 +4784,6 @@ static int lfs_fs_forceconsistency(lfs_t *lfs) {
 }
 #endif
 
-#ifndef LFS_READONLY
-int lfs_fs_rawmkconsistent(lfs_t *lfs) {
-    // lfs_fs_forceconsistency does most of the work here
-    int err = lfs_fs_forceconsistency(lfs);
-    if (err) {
-        return err;
-    }
-
-    // do we have any pending gstate?
-    lfs_gstate_t delta = {0};
-    lfs_gstate_xor(&delta, &lfs->gdisk);
-    lfs_gstate_xor(&delta, &lfs->gstate);
-    if (!lfs_gstate_iszero(&delta)) {
-        // lfs_dir_commit will implicitly write out any pending gstate
-        lfs_mdir_t root;
-        err = lfs_dir_fetch(lfs, &root, lfs->root);
-        if (err) {
-            return err;
-        }
-
-        err = lfs_dir_commit(lfs, &root, NULL, 0);
-        if (err) {
-            return err;
-        }
-    }
-
-    return 0;
-}
-#endif
-
 static int lfs_fs_size_count(void *p, lfs_block_t block) {
     (void)block;
     lfs_size_t *size = p;
@@ -5025,7 +4801,6 @@ static lfs_ssize_t lfs_fs_rawsize(lfs_t *lfs) {
     return size;
 }
 
-
 #ifdef LFS_MIGRATE
 ////// Migration from littelfs v1 below this //////
 
@@ -6145,20 +5920,6 @@ int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir) {
     return err;
 }
 
-int lfs_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo) {
-    int err = LFS_LOCK(lfs->cfg);
-    if (err) {
-        return err;
-    }
-    LFS_TRACE("lfs_fs_stat(%p, %p)", (void*)lfs, (void*)fsinfo);
-
-    err = lfs_fs_rawstat(lfs, fsinfo);
-
-    LFS_TRACE("lfs_fs_stat -> %d", err);
-    LFS_UNLOCK(lfs->cfg);
-    return err;
-}
-
 lfs_ssize_t lfs_fs_size(lfs_t *lfs) {
     int err = LFS_LOCK(lfs->cfg);
     if (err) {
@@ -6188,22 +5949,6 @@ int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void *, lfs_block_t), void *data) {
     return err;
 }
 
-#ifndef LFS_READONLY
-int lfs_fs_mkconsistent(lfs_t *lfs) {
-    int err = LFS_LOCK(lfs->cfg);
-    if (err) {
-        return err;
-    }
-    LFS_TRACE("lfs_fs_mkconsistent(%p)", (void*)lfs);
-
-    err = lfs_fs_rawmkconsistent(lfs);
-
-    LFS_TRACE("lfs_fs_mkconsistent -> %d", err);
-    LFS_UNLOCK(lfs->cfg);
-    return err;
-}
-#endif
-
 #ifdef LFS_MIGRATE
 int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg) {
     int err = LFS_LOCK(cfg);

lfs.h

@@ -21,14 +21,14 @@ extern "C"
 // Software library version
 // Major (top-nibble), incremented on backwards incompatible changes
 // Minor (bottom-nibble), incremented on feature additions
-#define LFS_VERSION 0x00020007
+#define LFS_VERSION 0x00020005
 #define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16))
 #define LFS_VERSION_MINOR (0xffff & (LFS_VERSION >>  0))
 
 // Version of On-disk data structures
 // Major (top-nibble), incremented on backwards incompatible changes
 // Minor (bottom-nibble), incremented on feature additions
-#define LFS_DISK_VERSION 0x00020001
+#define LFS_DISK_VERSION 0x00020000
 #define LFS_DISK_VERSION_MAJOR (0xffff & (LFS_DISK_VERSION >> 16))
 #define LFS_DISK_VERSION_MINOR (0xffff & (LFS_DISK_VERSION >>  0))
 
@@ -263,14 +263,6 @@ struct lfs_config {
     // can help bound the metadata compaction time. Must be <= block_size.
     // Defaults to block_size when zero.
     lfs_size_t metadata_max;
-
-#ifdef LFS_MULTIVERSION
-    // On-disk version to use when writing in the form of 16-bit major version
-    // + 16-bit minor version. This limiting metadata to what is supported by
-    // older minor versions. Note that some features will be lost. Defaults to 
-    // to the most recent minor version when zero.
-    uint32_t disk_version;
-#endif
 };
 
 // File info structure
@@ -288,21 +280,6 @@ struct lfs_info {
     char name[LFS_NAME_MAX+1];
 };
 
-// Filesystem info structure
-struct lfs_fsinfo {
-    // On-disk version.
-    uint32_t disk_version;
-
-    // Upper limit on the length of file names in bytes.
-    lfs_size_t name_max;
-
-    // Upper limit on the size of files in bytes.
-    lfs_size_t file_max;
-
-    // Upper limit on the size of custom attributes in bytes.
-    lfs_size_t attr_max;
-};
-
 // Custom attribute structure, used to describe custom attributes
 // committed atomically during file writes.
 struct lfs_attr {
@@ -682,12 +659,6 @@ int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir);
 
 /// Filesystem-level filesystem operations
 
-// Find on-disk info about the filesystem
-//
-// Fills out the fsinfo structure based on the filesystem found on-disk.
-// Returns a negative error code on failure.
-int lfs_fs_stat(lfs_t *lfs, struct lfs_fsinfo *fsinfo);
-
 // Finds the current size of the filesystem
 //
 // Note: Result is best effort. If files share COW structures, the returned
@@ -705,18 +676,6 @@ lfs_ssize_t lfs_fs_size(lfs_t *lfs);
 // Returns a negative error code on failure.
 int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data);
 
-#ifndef LFS_READONLY
-// Attempt to make the filesystem consistent and ready for writing
-//
-// Calling this function is not required, consistency will be implicitly
-// enforced on the first operation that writes to the filesystem, but this
-// function allows the work to be performed earlier and without other
-// filesystem changes.
-//
-// Returns a negative error code on failure.
-int lfs_fs_mkconsistent(lfs_t *lfs);
-#endif
-
 #ifndef LFS_READONLY
 #ifdef LFS_MIGRATE
 // Attempts to migrate a previous version of littlefs

lfs_util.h

@@ -23,6 +23,7 @@
 // System includes
 #include <stdint.h>
 #include <stdbool.h>
+#include <sys/types.h>
 #include <string.h>
 #include <inttypes.h>
 

runners/test_runner.c

@@ -1346,9 +1346,6 @@ static void run_powerloss_none(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
@@ -1418,9 +1415,6 @@ static void run_powerloss_linear(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
@@ -1507,9 +1501,6 @@ static void run_powerloss_log(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
@@ -1594,9 +1585,6 @@ static void run_powerloss_cycles(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {
@@ -1779,9 +1767,6 @@ static void run_powerloss_exhaustive(
         .block_cycles       = BLOCK_CYCLES,
         .cache_size         = CACHE_SIZE,
         .lookahead_size     = LOOKAHEAD_SIZE,
-    #ifdef LFS_MULTIVERSION
-        .disk_version       = DISK_VERSION,
-    #endif
     };
 
     struct lfs_emubd_config bdcfg = {

runners/test_runner.h

@@ -91,7 +91,6 @@ intmax_t test_define(size_t define);
 #define ERASE_CYCLES_i       8
 #define BADBLOCK_BEHAVIOR_i  9
 #define POWERLOSS_BEHAVIOR_i 10
-#define DISK_VERSION_i       11
 
 #define READ_SIZE           TEST_DEFINE(READ_SIZE_i)
 #define PROG_SIZE           TEST_DEFINE(PROG_SIZE_i)
@@ -104,7 +103,6 @@ intmax_t test_define(size_t define);
 #define ERASE_CYCLES        TEST_DEFINE(ERASE_CYCLES_i)
 #define BADBLOCK_BEHAVIOR   TEST_DEFINE(BADBLOCK_BEHAVIOR_i)
 #define POWERLOSS_BEHAVIOR  TEST_DEFINE(POWERLOSS_BEHAVIOR_i)
-#define DISK_VERSION        TEST_DEFINE(DISK_VERSION_i)
 
 #define TEST_IMPLICIT_DEFINES \
     TEST_DEF(READ_SIZE,          PROG_SIZE) \
@@ -117,10 +115,9 @@ intmax_t test_define(size_t define);
     TEST_DEF(ERASE_VALUE,        0xff) \
     TEST_DEF(ERASE_CYCLES,       0) \
     TEST_DEF(BADBLOCK_BEHAVIOR,  LFS_EMUBD_BADBLOCK_PROGERROR) \
-    TEST_DEF(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_NOOP) \
-    TEST_DEF(DISK_VERSION,       0)
+    TEST_DEF(POWERLOSS_BEHAVIOR, LFS_EMUBD_POWERLOSS_NOOP)
 
-#define TEST_IMPLICIT_DEFINE_COUNT 12
+#define TEST_IMPLICIT_DEFINE_COUNT 11
 #define TEST_GEOMETRY_DEFINE_COUNT 4
 
 

scripts/changeprefix.py

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

tests/test_dirs.toml

@@ -810,8 +810,7 @@ code = '''
     }
     lfs_unmount(&lfs) => 0;
 
-    // try seeking to each dir entry
-    for (int j = 0; j < COUNT; j++) {
+    for (int j = 2; j < COUNT; j++) {
         lfs_mount(&lfs, cfg) => 0;
         lfs_dir_t dir;
         lfs_dir_open(&lfs, &dir, "hello") => 0;
@@ -823,15 +822,16 @@ code = '''
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
 
+        lfs_soff_t pos;
         for (int i = 0; i < j; i++) {
             char path[1024];
             sprintf(path, "kitty%03d", i);
             lfs_dir_read(&lfs, &dir, &info) => 1;
             assert(strcmp(info.name, path) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            pos = lfs_dir_tell(&lfs, &dir);
+            assert(pos >= 0);
         }
-        lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-        assert(pos >= 0);
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         char path[1024];
@@ -861,52 +861,6 @@ code = '''
         lfs_dir_close(&lfs, &dir) => 0;
         lfs_unmount(&lfs) => 0;
     }
-
-    // try seeking to end of dir
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_dir_t dir;
-    lfs_dir_open(&lfs, &dir, "hello") => 0;
-    struct lfs_info info;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    for (int i = 0; i < COUNT; i++) {
-        char path[1024];
-        sprintf(path, "kitty%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        assert(strcmp(info.name, path) == 0);
-        assert(info.type == LFS_TYPE_DIR);
-    }
-    lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-    assert(pos >= 0);
-
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_rewind(&lfs, &dir) => 0;
-    char path[1024];
-    sprintf(path, "kitty%03d", 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, path) == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs) => 0;
 '''
 
 [cases.test_dirs_toot_seek]
@@ -923,7 +877,7 @@ code = '''
     }
     lfs_unmount(&lfs) => 0;
 
-    for (int j = 0; j < COUNT; j++) {
+    for (int j = 2; j < COUNT; j++) {
         lfs_mount(&lfs, cfg) => 0;
         lfs_dir_t dir;
         lfs_dir_open(&lfs, &dir, "/") => 0;
@@ -935,15 +889,16 @@ code = '''
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
 
+        lfs_soff_t pos;
         for (int i = 0; i < j; i++) {
             char path[1024];
             sprintf(path, "hi%03d", i);
             lfs_dir_read(&lfs, &dir, &info) => 1;
             assert(strcmp(info.name, path) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            pos = lfs_dir_tell(&lfs, &dir);
+            assert(pos >= 0);
         }
-        lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-        assert(pos >= 0);
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         char path[1024];
@@ -973,51 +928,5 @@ code = '''
         lfs_dir_close(&lfs, &dir) => 0;
         lfs_unmount(&lfs) => 0;
     }
-
-    // try seeking to end of dir
-    lfs_mount(&lfs, cfg) => 0;
-    lfs_dir_t dir;
-    lfs_dir_open(&lfs, &dir, "/") => 0;
-    struct lfs_info info;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    for (int i = 0; i < COUNT; i++) {
-        char path[1024];
-        sprintf(path, "hi%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        assert(strcmp(info.name, path) == 0);
-        assert(info.type == LFS_TYPE_DIR);
-    }
-    lfs_soff_t pos = lfs_dir_tell(&lfs, &dir);
-    assert(pos >= 0);
-
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_rewind(&lfs, &dir) => 0;
-    char path[1024];
-    sprintf(path, "hi%03d", 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, path) == 0);
-    assert(info.type == LFS_TYPE_DIR);
-
-    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs) => 0;
 '''
 

tests/test_orphans.toml

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

tests/test_powerloss.toml

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

tests/test_superblocks.toml

@@ -34,54 +34,6 @@ code = '''
     lfs_mount(&lfs, cfg) => LFS_ERR_CORRUPT;
 '''
 
-# test we can read superblock info through lfs_fs_stat
-[cases.test_superblocks_stat]
-if = 'DISK_VERSION == 0'
-code = '''
-    lfs_t lfs;
-    lfs_format(&lfs, cfg) => 0;
-
-    // test we can mount and read fsinfo
-    lfs_mount(&lfs, cfg) => 0;
-
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.disk_version == LFS_DISK_VERSION);
-    assert(fsinfo.name_max == LFS_NAME_MAX);
-    assert(fsinfo.file_max == LFS_FILE_MAX);
-    assert(fsinfo.attr_max == LFS_ATTR_MAX);
-
-    lfs_unmount(&lfs) => 0;
-'''
-
-[cases.test_superblocks_stat_tweaked]
-if = 'DISK_VERSION == 0'
-defines.TWEAKED_NAME_MAX = 63
-defines.TWEAKED_FILE_MAX = '(1 << 16)-1'
-defines.TWEAKED_ATTR_MAX = 512
-code = '''
-    // create filesystem with tweaked params
-    struct lfs_config tweaked_cfg = *cfg;
-    tweaked_cfg.name_max = TWEAKED_NAME_MAX;
-    tweaked_cfg.file_max = TWEAKED_FILE_MAX;
-    tweaked_cfg.attr_max = TWEAKED_ATTR_MAX;
-
-    lfs_t lfs;
-    lfs_format(&lfs, &tweaked_cfg) => 0;
-
-    // test we can mount and read these params with the original config
-    lfs_mount(&lfs, cfg) => 0;
-
-    struct lfs_fsinfo fsinfo;
-    lfs_fs_stat(&lfs, &fsinfo) => 0;
-    assert(fsinfo.disk_version == LFS_DISK_VERSION);
-    assert(fsinfo.name_max == TWEAKED_NAME_MAX);
-    assert(fsinfo.file_max == TWEAKED_FILE_MAX);
-    assert(fsinfo.attr_max == TWEAKED_ATTR_MAX);
-
-    lfs_unmount(&lfs) => 0;
-'''
-
 # expanding superblock
 [cases.test_superblocks_expand]
 defines.BLOCK_CYCLES = [32, 33, 1]

tests/test_truncate.toml

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