A number of small QOL changes related to lfs_util.h

- Removed stdlib includes from lfs.h, these should all go through
  lfs_util.h to let users override these definitions if stdlib is
  unavailable on their system.

- Changed the name of the LFS_CONFIG macro to LFS_UTIL to avoid
  confusion with the lfs_config struct. This also hints that LFS_UTIL
  is related to lfs_util.h.

  LFS_UTIL allows the user to override lfs_util.h so they can provide
  their own system-level dependencies such as malloc, tracing, builtins,
  stdint definitions, string.h, and others.

- Moved error code definitions to lfs_util.h. This lets users override
  the error codes to replace them with their own error codes and avoid
  a translation layer in some situations. Note the error codes must
  still be in the range of a negative int.

.travis.yml

@@ -248,30 +248,34 @@ jobs:
                   -m "Generated v$LFS_VERSION_MAJOR prefixes")
           git reset --hard
           # Update major version branches (vN and vN-prefix)
-          git push --atomic https://$GEKY_BOT_RELEASES@github.com/$TRAVIS_REPO_SLUG.git \
+          git push https://$GEKY_BOT_RELEASES@github.com/$TRAVIS_REPO_SLUG.git \
               v$LFS_VERSION_MAJOR \
               v$LFS_VERSION_MAJOR-prefix
+          # Create patch version tag (vN.N.N)
+          curl -f -u "$GEKY_BOT_RELEASES" -X POST \
+              https://api.github.com/repos/$TRAVIS_REPO_SLUG/git/refs \
+              -d "{
+                  \"ref\": \"refs/tags/$LFS_VERSION\",
+                  \"sha\": \"$TRAVIS_COMMIT\"
+              }"
+          # Create minor release?
+          [[ "$LFS_VERSION" == *.0 ]] || exit 0
           # Build release notes
-          PREV=$(git tag --sort=-v:refname -l "v*" | head -1)
+          PREV=$(git tag --sort=-v:refname -l "v*.0" | head -1)
           if [ ! -z "$PREV" ]
           then
               echo "PREV $PREV"
-              CHANGES=$(git log --oneline $PREV.. --grep='^Merge' --invert-grep)
+              CHANGES=$'### Changes\n\n'$( \
+                  git log --oneline $PREV.. --grep='^Merge' --invert-grep)
               printf "CHANGES\n%s\n\n" "$CHANGES"
           fi
-          case ${GEKY_BOT_DRAFT:-minor} in
+          # Create the release
-              true)  DRAFT=true ;;
-              minor) DRAFT=$(jq -R 'endswith(".0")' <<< "$LFS_VERSION") ;;
-              false) DRAFT=false ;;
-          esac
-          # Create the release and patch version tag (vN.N.N)
           curl -f -u "$GEKY_BOT_RELEASES" -X POST \
               https://api.github.com/repos/$TRAVIS_REPO_SLUG/releases \
               -d "{
                   \"tag_name\": \"$LFS_VERSION\",
                   \"name\": \"${LFS_VERSION%.0}\",
-                  \"target_commitish\": \"$TRAVIS_COMMIT\",
+                  \"draft\": true,
-                  \"draft\": $DRAFT,
                   \"body\": $(jq -sR '.' <<< "$CHANGES")
               }" #"
           SCRIPT

Makefile

@@ -29,7 +29,7 @@ override CFLAGS += -DLFS_YES_TRACE
 endif
 override CFLAGS += -I.
 override CFLAGS += -std=c99 -Wall -pedantic
-override CFLAGS += -Wextra -Wshadow -Wjump-misses-init -Wundef
+override CFLAGS += -Wextra -Wshadow -Wjump-misses-init
 # Remove missing-field-initializers because of GCC bug
 override CFLAGS += -Wno-missing-field-initializers
 

lfs.c

@@ -5,23 +5,20 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 #include "lfs.h"
-#include "lfs_util.h"
 
-#define LFS_BLOCK_NULL ((lfs_block_t)-1)
-#define LFS_BLOCK_INLINE ((lfs_block_t)-2)
 
 /// Caching block device operations ///
 static inline void lfs_cache_drop(lfs_t *lfs, lfs_cache_t *rcache) {
     // do not zero, cheaper if cache is readonly or only going to be
     // written with identical data (during relocates)
     (void)lfs;
-    rcache->block = LFS_BLOCK_NULL;
+    rcache->block = 0xffffffff;
 }
 
 static inline void lfs_cache_zero(lfs_t *lfs, lfs_cache_t *pcache) {
     // zero to avoid information leak
     memset(pcache->buffer, 0xff, lfs->cfg->cache_size);
-    pcache->block = LFS_BLOCK_NULL;
+    pcache->block = 0xffffffff;
 }
 
 static int lfs_bd_read(lfs_t *lfs,
@@ -29,7 +26,7 @@ static int lfs_bd_read(lfs_t *lfs,
         lfs_block_t block, lfs_off_t off,
         void *buffer, lfs_size_t size) {
     uint8_t *data = buffer;
-    LFS_ASSERT(block != LFS_BLOCK_NULL);
+    LFS_ASSERT(block != 0xffffffff);
     if (off+size > lfs->cfg->block_size) {
         return LFS_ERR_CORRUPT;
     }
@@ -123,7 +120,7 @@ static int lfs_bd_cmp(lfs_t *lfs,
 
 static int lfs_bd_flush(lfs_t *lfs,
         lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate) {
-    if (pcache->block != LFS_BLOCK_NULL && pcache->block != LFS_BLOCK_INLINE) {
+    if (pcache->block != 0xffffffff && pcache->block != 0xfffffffe) {
         LFS_ASSERT(pcache->block < lfs->cfg->block_count);
         lfs_size_t diff = lfs_alignup(pcache->size, lfs->cfg->prog_size);
         int err = lfs->cfg->prog(lfs->cfg, pcache->block,
@@ -173,7 +170,7 @@ static int lfs_bd_prog(lfs_t *lfs,
         lfs_block_t block, lfs_off_t off,
         const void *buffer, lfs_size_t size) {
     const uint8_t *data = buffer;
-    LFS_ASSERT(block != LFS_BLOCK_NULL);
+    LFS_ASSERT(block != 0xffffffff);
     LFS_ASSERT(off + size <= lfs->cfg->block_size);
 
     while (size > 0) {
@@ -203,7 +200,7 @@ static int lfs_bd_prog(lfs_t *lfs,
 
         // pcache must have been flushed, either by programming and
         // entire block or manually flushing the pcache
-        LFS_ASSERT(pcache->block == LFS_BLOCK_NULL);
+        LFS_ASSERT(pcache->block == 0xffffffff);
 
         // prepare pcache, first condition can no longer fail
         pcache->block = block;
@@ -231,7 +228,7 @@ static inline void lfs_pair_swap(lfs_block_t pair[2]) {
 }
 
 static inline bool lfs_pair_isnull(const lfs_block_t pair[2]) {
-    return pair[0] == LFS_BLOCK_NULL || pair[1] == LFS_BLOCK_NULL;
+    return pair[0] == 0xffffffff || pair[1] == 0xffffffff;
 }
 
 static inline int lfs_pair_cmp(
@@ -573,7 +570,7 @@ static int lfs_dir_getread(lfs_t *lfs, const lfs_mdir_t *dir,
     while (size > 0) {
         lfs_size_t diff = size;
 
-        if (pcache && pcache->block == LFS_BLOCK_INLINE &&
+        if (pcache && pcache->block == 0xfffffffe &&
                 off < pcache->off + pcache->size) {
             if (off >= pcache->off) {
                 // is already in pcache?
@@ -590,7 +587,7 @@ static int lfs_dir_getread(lfs_t *lfs, const lfs_mdir_t *dir,
             diff = lfs_min(diff, pcache->off-off);
         }
 
-        if (rcache->block == LFS_BLOCK_INLINE &&
+        if (rcache->block == 0xfffffffe &&
                 off < rcache->off + rcache->size) {
             if (off >= rcache->off) {
                 // is already in rcache?
@@ -608,7 +605,7 @@ static int lfs_dir_getread(lfs_t *lfs, const lfs_mdir_t *dir,
         }
 
         // load to cache, first condition can no longer fail
-        rcache->block = LFS_BLOCK_INLINE;
+        rcache->block = 0xfffffffe;
         rcache->off = lfs_aligndown(off, lfs->cfg->read_size);
         rcache->size = lfs_min(lfs_alignup(off+hint, lfs->cfg->read_size),
                 lfs->cfg->cache_size);
@@ -725,7 +722,7 @@ static int lfs_dir_traverse(lfs_t *lfs,
             uint16_t fromid = lfs_tag_size(tag);
             uint16_t toid = lfs_tag_id(tag);
             int err = lfs_dir_traverse(lfs,
-                    buffer, 0, LFS_BLOCK_NULL, NULL, 0, true,
+                    buffer, 0, 0xffffffff, NULL, 0, true,
                     LFS_MKTAG(0x600, 0x3ff, 0),
                     LFS_MKTAG(LFS_TYPE_STRUCT, 0, 0),
                     fromid, fromid+1, toid-fromid+diff,
@@ -785,15 +782,15 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
     // now scan tags to fetch the actual dir and find possible match
     for (int i = 0; i < 2; i++) {
         lfs_off_t off = 0;
-        lfs_tag_t ptag = LFS_BLOCK_NULL;
+        lfs_tag_t ptag = 0xffffffff;
 
         uint16_t tempcount = 0;
-        lfs_block_t temptail[2] = {LFS_BLOCK_NULL, LFS_BLOCK_NULL};
+        lfs_block_t temptail[2] = {0xffffffff, 0xffffffff};
         bool tempsplit = false;
         lfs_stag_t tempbesttag = besttag;
 
         dir->rev = lfs_tole32(dir->rev);
-        uint32_t crc = lfs_crc(LFS_BLOCK_NULL, &dir->rev, sizeof(dir->rev));
+        uint32_t crc = lfs_crc(0xffffffff, &dir->rev, sizeof(dir->rev));
         dir->rev = lfs_fromle32(dir->rev);
 
         while (true) {
@@ -862,7 +859,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
                 dir->split = tempsplit;
 
                 // reset crc
-                crc = LFS_BLOCK_NULL;
+                crc = 0xffffffff;
                 continue;
             }
 
@@ -1250,7 +1247,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
         }
 
         // read erased state from next program unit
-        lfs_tag_t tag = LFS_BLOCK_NULL;
+        lfs_tag_t tag = 0xffffffff;
         int err = lfs_bd_read(lfs,
                 NULL, &lfs->rcache, sizeof(tag),
                 commit->block, noff, &tag, sizeof(tag));
@@ -1276,7 +1273,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
 
         commit->off += sizeof(tag)+lfs_tag_size(tag);
         commit->ptag = tag ^ (reset << 31);
-        commit->crc = LFS_BLOCK_NULL; // reset crc for next "commit"
+        commit->crc = 0xffffffff; // reset crc for next "commit"
     }
 
     // flush buffers
@@ -1289,7 +1286,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
     lfs_off_t off = commit->begin;
     lfs_off_t noff = off1;
     while (off < end) {
-        uint32_t crc = LFS_BLOCK_NULL;
+        uint32_t crc = 0xffffffff;
         for (lfs_off_t i = off; i < noff+sizeof(uint32_t); i++) {
             // leave it up to caching to make this efficient
             uint8_t dat;
@@ -1343,10 +1340,10 @@ static int lfs_dir_alloc(lfs_t *lfs, lfs_mdir_t *dir) {
 
     // set defaults
     dir->off = sizeof(dir->rev);
-    dir->etag = LFS_BLOCK_NULL;
+    dir->etag = 0xffffffff;
     dir->count = 0;
-    dir->tail[0] = LFS_BLOCK_NULL;
+    dir->tail[0] = 0xffffffff;
-    dir->tail[1] = LFS_BLOCK_NULL;
+    dir->tail[1] = 0xffffffff;
     dir->erased = false;
     dir->split = false;
 
@@ -1436,7 +1433,7 @@ static int lfs_dir_compact(lfs_t *lfs,
         // find size
         lfs_size_t size = 0;
         int err = lfs_dir_traverse(lfs,
-                source, 0, LFS_BLOCK_NULL, attrs, attrcount, false,
+                source, 0, 0xffffffff, attrs, attrcount, false,
                 LFS_MKTAG(0x400, 0x3ff, 0),
                 LFS_MKTAG(LFS_TYPE_NAME, 0, 0),
                 begin, end, -begin,
@@ -1502,7 +1499,7 @@ static int lfs_dir_compact(lfs_t *lfs,
                     end = begin;
                 }
             }
-#ifdef LFS_MIGRATE
+#if LFS_MIGRATE
         } else if (lfs_pair_cmp(dir->pair, lfs->root) == 0 && lfs->lfs1) {
             // we can't relocate our root during migrations, as this would
             // cause the superblock to get updated, which would clobber v1
@@ -1528,8 +1525,8 @@ static int lfs_dir_compact(lfs_t *lfs,
             struct lfs_commit commit = {
                 .block = dir->pair[1],
                 .off = 0,
-                .ptag = LFS_BLOCK_NULL,
+                .ptag = 0xffffffff,
-                .crc = LFS_BLOCK_NULL,
+                .crc = 0xffffffff,
 
                 .begin = 0,
                 .end = lfs->cfg->block_size - 8,
@@ -1558,7 +1555,7 @@ static int lfs_dir_compact(lfs_t *lfs,
 
             // traverse the directory, this time writing out all unique tags
             err = lfs_dir_traverse(lfs,
-                    source, 0, LFS_BLOCK_NULL, attrs, attrcount, false,
+                    source, 0, 0xffffffff, attrs, attrcount, false,
                     LFS_MKTAG(0x400, 0x3ff, 0),
                     LFS_MKTAG(LFS_TYPE_NAME, 0, 0),
                     begin, end, -begin,
@@ -1684,8 +1681,8 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
     }
 
     // calculate changes to the directory
-    lfs_tag_t deletetag = LFS_BLOCK_NULL;
+    lfs_tag_t deletetag = 0xffffffff;
-    lfs_tag_t createtag = LFS_BLOCK_NULL;
+    lfs_tag_t createtag = 0xffffffff;
     for (int i = 0; i < attrcount; i++) {
         if (lfs_tag_type3(attrs[i].tag) == LFS_TYPE_CREATE) {
             createtag = attrs[i].tag;
@@ -1731,7 +1728,7 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
             .block = dir->pair[0],
             .off = dir->off,
             .ptag = dir->etag,
-            .crc = LFS_BLOCK_NULL,
+            .crc = 0xffffffff,
 
             .begin = dir->off,
             .end = lfs->cfg->block_size - 8,
@@ -1815,8 +1812,8 @@ compact:
         if (lfs_pair_cmp(d->m.pair, copy.pair) == 0) {
             d->m = *dir;
             if (d->id == lfs_tag_id(deletetag)) {
-                d->m.pair[0] = LFS_BLOCK_NULL;
+                d->m.pair[0] = 0xffffffff;
-                d->m.pair[1] = LFS_BLOCK_NULL;
+                d->m.pair[1] = 0xffffffff;
             } else if (d->id > lfs_tag_id(deletetag)) {
                 d->id -= 1;
                 if (d->type == LFS_TYPE_DIR) {
@@ -2131,7 +2128,7 @@ static int lfs_ctz_find(lfs_t *lfs,
         lfs_block_t head, lfs_size_t size,
         lfs_size_t pos, lfs_block_t *block, lfs_off_t *off) {
     if (size == 0) {
-        *block = LFS_BLOCK_NULL;
+        *block = 0xffffffff;
         *off = 0;
         return 0;
     }
@@ -2329,7 +2326,6 @@ int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
     file->cfg = cfg;
     file->flags = flags | LFS_F_OPENED;
     file->pos = 0;
-    file->off = 0;
     file->cache.buffer = NULL;
 
     // allocate entry for file if it doesn't exist
@@ -2429,7 +2425,7 @@ int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file,
 
     if (lfs_tag_type3(tag) == LFS_TYPE_INLINESTRUCT) {
         // load inline files
-        file->ctz.head = LFS_BLOCK_INLINE;
+        file->ctz.head = 0xfffffffe;
         file->ctz.size = lfs_tag_size(tag);
         file->flags |= LFS_F_INLINE;
         file->cache.block = file->ctz.head;
@@ -2617,7 +2613,7 @@ static int lfs_file_flush(lfs_t *lfs, lfs_file_t *file) {
                 }
 
                 // keep our reference to the rcache in sync
-                if (lfs->rcache.block != LFS_BLOCK_NULL) {
+                if (lfs->rcache.block != 0xffffffff) {
                     lfs_cache_drop(lfs, &orig.cache);
                     lfs_cache_drop(lfs, &lfs->rcache);
                 }
@@ -2765,7 +2761,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
                     return err;
                 }
             } else {
-                file->block = LFS_BLOCK_INLINE;
+                file->block = 0xfffffffe;
                 file->off = file->pos;
             }
 
@@ -2891,7 +2887,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
                     return err;
                 }
             } else {
-                file->block = LFS_BLOCK_INLINE;
+                file->block = 0xfffffffe;
                 file->off = file->pos;
             }
 
@@ -2981,7 +2977,6 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
         return LFS_ERR_INVAL;
     }
 
-    lfs_off_t pos = file->pos;
     lfs_off_t oldsize = lfs_file_size(lfs, file);
     if (size < oldsize) {
         // need to flush since directly changing metadata
@@ -3004,6 +2999,8 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
         file->ctz.size = size;
         file->flags |= LFS_F_DIRTY | LFS_F_READING;
     } else if (size > oldsize) {
+        lfs_off_t pos = file->pos;
+
         // flush+seek if not already at end
         if (file->pos != oldsize) {
             int err = lfs_file_seek(lfs, file, 0, LFS_SEEK_END);
@@ -3021,13 +3018,13 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
                 return res;
             }
         }
-    }
 
-    // restore pos
+        // restore pos
-    int err = lfs_file_seek(lfs, file, pos, LFS_SEEK_SET);
+        int err = lfs_file_seek(lfs, file, pos, LFS_SEEK_SET);
-    if (err < 0) {
+        if (err < 0) {
-      LFS_TRACE("lfs_file_truncate -> %d", err);
+            LFS_TRACE("lfs_file_truncate -> %d", err);
-      return err;
+            return err;
+        }
     }
 
     LFS_TRACE("lfs_file_truncate -> %d", 0);
@@ -3376,7 +3373,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
     LFS_ASSERT(lfs->cfg->block_size % lfs->cfg->cache_size == 0);
 
     // check that the block size is large enough to fit ctz pointers
-    LFS_ASSERT(4*lfs_npw2(LFS_BLOCK_NULL / (lfs->cfg->block_size-2*4))
+    LFS_ASSERT(4*lfs_npw2(0xffffffff / (lfs->cfg->block_size-2*4))
             <= lfs->cfg->block_size);
 
     // block_cycles = 0 is no longer supported.
@@ -3414,10 +3411,10 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
     lfs_cache_zero(lfs, &lfs->rcache);
     lfs_cache_zero(lfs, &lfs->pcache);
 
-    // setup lookahead, must be multiple of 64-bits, 32-bit aligned
+    // setup lookahead, must be multiple of 64-bits
     LFS_ASSERT(lfs->cfg->lookahead_size > 0);
     LFS_ASSERT(lfs->cfg->lookahead_size % 8 == 0 &&
-            (uintptr_t)lfs->cfg->lookahead_buffer % 4 == 0);
+            (uintptr_t)lfs->cfg->lookahead_buffer % 8 == 0);
     if (lfs->cfg->lookahead_buffer) {
         lfs->free.buffer = lfs->cfg->lookahead_buffer;
     } else {
@@ -3448,8 +3445,8 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
     }
 
     // setup default state
-    lfs->root[0] = LFS_BLOCK_NULL;
+    lfs->root[0] = 0xffffffff;
-    lfs->root[1] = LFS_BLOCK_NULL;
+    lfs->root[1] = 0xffffffff;
     lfs->mlist = NULL;
     lfs->seed = 0;
     lfs->gstate = (struct lfs_gstate){0};
@@ -4252,7 +4249,7 @@ static int lfs1_dir_fetch(lfs_t *lfs,
             continue;
         }
 
-        uint32_t crc = LFS_BLOCK_NULL;
+        uint32_t crc = 0xffffffff;
         lfs1_dir_tole32(&test);
         lfs1_crc(&crc, &test, sizeof(test));
         lfs1_dir_fromle32(&test);
@@ -4437,8 +4434,8 @@ static int lfs1_mount(lfs_t *lfs, struct lfs1 *lfs1,
         }
 
         lfs->lfs1 = lfs1;
-        lfs->lfs1->root[0] = LFS_BLOCK_NULL;
+        lfs->lfs1->root[0] = 0xffffffff;
-        lfs->lfs1->root[1] = LFS_BLOCK_NULL;
+        lfs->lfs1->root[1] = 0xffffffff;
 
         // setup free lookahead
         lfs->free.off = 0;
@@ -4687,7 +4684,7 @@ int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg) {
         dir2.pair[1] = dir1.pair[1];
         dir2.rev = dir1.d.rev;
         dir2.off = sizeof(dir2.rev);
-        dir2.etag = LFS_BLOCK_NULL;
+        dir2.etag = 0xffffffff;
         dir2.count = 0;
         dir2.tail[0] = lfs->lfs1->root[0];
         dir2.tail[1] = lfs->lfs1->root[1];

lfs.h

@@ -7,8 +7,7 @@
 #ifndef LFS_H
 #define LFS_H
 
-#include <stdint.h>
+#include "lfs_util.h"
-#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -66,25 +65,6 @@ typedef uint32_t lfs_block_t;
 #define LFS_ATTR_MAX 1022
 #endif
 
-// Possible error codes, these are negative to allow
-// valid positive return values
-enum lfs_error {
-    LFS_ERR_OK          = 0,    // No error
-    LFS_ERR_IO          = -5,   // Error during device operation
-    LFS_ERR_CORRUPT     = -84,  // Corrupted
-    LFS_ERR_NOENT       = -2,   // No directory entry
-    LFS_ERR_EXIST       = -17,  // Entry already exists
-    LFS_ERR_NOTDIR      = -20,  // Entry is not a dir
-    LFS_ERR_ISDIR       = -21,  // Entry is a dir
-    LFS_ERR_NOTEMPTY    = -39,  // Dir is not empty
-    LFS_ERR_BADF        = -9,   // Bad file number
-    LFS_ERR_FBIG        = -27,  // File too large
-    LFS_ERR_INVAL       = -22,  // Invalid parameter
-    LFS_ERR_NOSPC       = -28,  // No space left on device
-    LFS_ERR_NOMEM       = -12,  // No more memory available
-    LFS_ERR_NOATTR      = -61,  // No data/attr available
-    LFS_ERR_NAMETOOLONG = -36,  // File name too long
-};
 
 // File types
 enum lfs_type {

lfs_util.c

@@ -7,7 +7,7 @@
 #include "lfs_util.h"
 
 // Only compile if user does not provide custom config
-#ifndef LFS_CONFIG
+#ifndef LFS_UTIL
 
 
 // Software CRC implementation with small lookup table

lfs_util.h

@@ -3,20 +3,21 @@
  *
  * Copyright (c) 2017, Arm Limited. All rights reserved.
  * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Can be overridden by users with their own configuration by defining
+ * LFS_UTIL as a header file (-DLFS_UTIL=my_lfs_util.h)
+ *
+ * If LFS_UTIL is defined, none of the default definitions will be
+ * emitted and must be provided by the user's header file. To start, I would
+ * suggest copying lfs_util.h and modifying as needed.
  */
 #ifndef LFS_UTIL_H
 #define LFS_UTIL_H
 
-// Users can override lfs_util.h with their own configuration by defining
+#ifdef LFS_UTIL
-// LFS_CONFIG as a header file to include (-DLFS_CONFIG=lfs_config.h).
-//
-// If LFS_CONFIG is used, none of the default utils will be emitted and must be
-// provided by the config file. To start, I would suggest copying lfs_util.h
-// and modifying as needed.
-#ifdef LFS_CONFIG
 #define LFS_STRINGIZE(x) LFS_STRINGIZE2(x)
 #define LFS_STRINGIZE2(x) #x
-#include LFS_STRINGIZE(LFS_CONFIG)
+#include LFS_STRINGIZE(LFS_UTIL)
 #else
 
 // System includes
@@ -44,6 +45,28 @@ extern "C"
 #endif
 
 
+// Possible error codes, these are negative to allow valid positive
+// return values. May be redefined to system error codes as long as
+// they are negative.
+enum lfs_error {
+    LFS_ERR_OK          = 0,    // No error
+    LFS_ERR_IO          = -5,   // Error during device operation
+    LFS_ERR_CORRUPT     = -84,  // Corrupted
+    LFS_ERR_NOENT       = -2,   // No directory entry
+    LFS_ERR_EXIST       = -17,  // Entry already exists
+    LFS_ERR_NOTDIR      = -20,  // Entry is not a dir
+    LFS_ERR_ISDIR       = -21,  // Entry is a dir
+    LFS_ERR_NOTEMPTY    = -39,  // Dir is not empty
+    LFS_ERR_BADF        = -9,   // Bad file number
+    LFS_ERR_FBIG        = -27,  // File too large
+    LFS_ERR_INVAL       = -22,  // Invalid parameter
+    LFS_ERR_NOSPC       = -28,  // No space left on device
+    LFS_ERR_NOMEM       = -12,  // No more memory available
+    LFS_ERR_NOATTR      = -61,  // No data/attr available
+    LFS_ERR_NAMETOOLONG = -36,  // File name too long
+};
+
+
 // Macros, may be replaced by system specific wrappers. Arguments to these
 // macros must not have side-effects as the macros can be removed for a smaller
 // code footprint
@@ -146,8 +169,8 @@ static inline uint32_t lfs_popc(uint32_t a) {
 
 // Find the sequence comparison of a and b, this is the distance
 // between a and b ignoring overflow
-static inline int lfs_scmp(uint32_t a, uint32_t b) {
+static inline int32_t lfs_scmp(uint32_t a, uint32_t b) {
-    return (int)(unsigned)(a - b);
+    return (int32_t)(uint32_t)(a - b);
 }
 
 // Convert between 32-bit little-endian and native order

tests/test_truncate.sh

@@ -107,57 +107,6 @@ scripts/test.py << TEST
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Write, truncate, and read ---"
-scripts/test.py << TEST
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file, "sequence",
-            LFS_O_RDWR | LFS_O_CREAT | LFS_O_TRUNC) => 0;
-
-    lfs_size_t size = lfs.cfg->cache_size;
-    lfs_size_t qsize = size / 4;
-    uint8_t *wb = buffer;
-    uint8_t *rb = buffer + size;
-    for (lfs_off_t j = 0; j < size; ++j) {
-        wb[j] = j;
-    }
-
-    /* Spread sequence over size */
-    lfs_file_write(&lfs, &file, wb, size) => size;
-    lfs_file_size(&lfs, &file) => size;
-    lfs_file_tell(&lfs, &file) => size;
-
-    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
-    lfs_file_tell(&lfs, &file) => 0;
-
-    /* Chop off the last quarter */
-    lfs_size_t trunc = size - qsize;
-    lfs_file_truncate(&lfs, &file, trunc) => 0;
-    lfs_file_tell(&lfs, &file) => 0;
-    lfs_file_size(&lfs, &file) => trunc;
-
-    /* Read should produce first 3/4 */
-    lfs_file_read(&lfs, &file, rb, size) => trunc;
-    memcmp(rb, wb, trunc) => 0;
-
-    /* Move to 1/4 */
-    lfs_file_size(&lfs, &file) => trunc;
-    lfs_file_seek(&lfs, &file, qsize, LFS_SEEK_SET) => qsize;
-    lfs_file_tell(&lfs, &file) => qsize;
-
-    /* Chop to 1/2 */
-    trunc -= qsize;
-    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;
-
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-TEST
-
 echo "--- Truncate and write ---"
 scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;