Moved lfs_mdir_isopen behind LFS_NO_ASSERT

lfs_mdir_isopen goes unused if asserts are disabled, and this caused an
"unused function" warning on Clang (curiously not on GCC since the
function was static inline, commonly used for header-only functions).

Also removed "inline" from the lfs_mdir_* functions as these involve
linked-list operations and really shouldn't be inlined. And since they
are static, inlining should occur automatically if there is a benefit.

Found by dpgeorge

bd/lfs_filebd.c

@@ -80,6 +80,11 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
     LFS_ASSERT(size % cfg->read_size == 0);
     LFS_ASSERT(block < cfg->block_count);
 
+    // zero for reproducability (in case file is truncated)
+    if (bd->cfg->erase_value != -1) {
+        memset(buffer, bd->cfg->erase_value, size);
+    }
+
     // read
     off_t res1 = lseek(bd->fd,
             (off_t)block*cfg->block_size + (off_t)off, SEEK_SET);
@@ -96,11 +101,6 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
         return err;
     }
 
-    // file truncated? zero for reproducability
-    if ((lfs_size_t)res2 < size) {
-        memset((uint8_t*)buffer + res2, 0, size-res2);
-    }
-
     LFS_FILEBD_TRACE("lfs_filebd_read -> %d", 0);
     return 0;
 }

bd/lfs_rambd.c

@@ -32,8 +32,11 @@ int lfs_rambd_createcfg(const struct lfs_config *cfg,
         }
     }
 
-    // zero for reproducability (this matches filebd)
-    memset(bd->buffer, 0, cfg->block_size * cfg->block_count);
+    // zero for reproducability?
+    if (bd->cfg->erase_value != -1) {
+        memset(bd->buffer, bd->cfg->erase_value,
+                cfg->block_size * cfg->block_count);
+    }
 
     LFS_RAMBD_TRACE("lfs_rambd_createcfg -> %d", 0);
     return 0;

lfs.h

@@ -113,8 +113,6 @@ enum lfs_type {
     LFS_TYPE_SOFTTAIL       = 0x600,
     LFS_TYPE_HARDTAIL       = 0x601,
     LFS_TYPE_MOVESTATE      = 0x7ff,
-    LFS_TYPE_COMMITCRC      = 0x502,
-    LFS_TYPE_NPROGCRC       = 0x5ff,
 
     // internal chip sources
     LFS_FROM_NOOP           = 0x000,

scripts/readmdir.py

@@ -24,7 +24,6 @@ TAG_TYPES = {
     'gstate':       (0x700, 0x700),
     'movestate':    (0x7ff, 0x7ff),
     'crc':          (0x700, 0x500),
-    'nprogcrc':     (0x7ff, 0x5ff),
 }
 
 class Tag:
@@ -100,16 +99,7 @@ class Tag:
         return struct.unpack('b', struct.pack('B', self.chunk))[0]
 
     def is_(self, type):
-        try:
-            if ' ' in type:
-                type1, type3 = type.split()
-                return (self.is_(type1) and
-                    (self.type & ~TAG_TYPES[type1][0]) == int(type3, 0))
-
-            return self.type == int(type, 0)
-
-        except (ValueError, KeyError):
-            return (self.type & TAG_TYPES[type][0]) == TAG_TYPES[type][1]
+        return (self.type & TAG_TYPES[type][0]) == TAG_TYPES[type][1]
 
     def mkmask(self):
         return Tag(
@@ -119,20 +109,14 @@ class Tag:
 
     def chid(self, nid):
         ntag = Tag(self.type, nid, self.size)
-        if hasattr(self, 'off'):    ntag.off    = self.off
-        if hasattr(self, 'data'):   ntag.data   = self.data
-        if hasattr(self, 'crc'):    ntag.crc    = self.crc
-        if hasattr(self, 'erased'): ntag.erased = self.erased
+        if hasattr(self, 'off'):  ntag.off  = self.off
+        if hasattr(self, 'data'): ntag.data = self.data
+        if hasattr(self, 'crc'):  ntag.crc  = self.crc
         return ntag
 
     def typerepr(self):
-        if (self.is_('crc') and not self.is_('nprogcrc') and
-                getattr(self, 'crc', 0xffffffff) != 0xffffffff):
-            crc_status = ' (bad)'
-        elif self.is_('nprogcrc') and getattr(self, 'erased', False):
-            crc_status = ' (era)'
-        else:
-            crc_status = ''
+        if self.is_('crc') and getattr(self, 'crc', 0xffffffff) != 0xffffffff:
+            return 'crc (bad)'
 
         reverse_types = {v: k for k, v in TAG_TYPES.items()}
         for prefix in range(12):
@@ -140,12 +124,12 @@ class Tag:
             if (mask, self.type & mask) in reverse_types:
                 type = reverse_types[mask, self.type & mask]
                 if prefix > 0:
-                    return '%s %#x%s' % (
-                        type, self.type & ((1 << prefix)-1), crc_status)
+                    return '%s %#0*x' % (
+                        type, prefix//4, self.type & ((1 << prefix)-1))
                 else:
-                    return '%s%s' % (type, crc_status)
+                    return type
         else:
-            return '%02x%s' % (self.type, crc_status)
+            return '%02x' % self.type
 
     def idrepr(self):
         return repr(self.id) if self.id != 0x3ff else '.'
@@ -188,8 +172,6 @@ class MetadataPair:
 
         self.rev, = struct.unpack('<I', block[0:4])
         crc = binascii.crc32(block[0:4])
-        etag = None
-        estate = None
 
         # parse tags
         corrupt = False
@@ -200,11 +182,11 @@ class MetadataPair:
         while len(block) - off >= 4:
             ntag, = struct.unpack('>I', block[off:off+4])
 
-            tag = Tag((int(tag) ^ ntag) & 0x7fffffff)
+            tag = Tag(int(tag) ^ ntag)
             tag.off = off + 4
             tag.data = block[off+4:off+tag.dsize]
-            if tag.is_('crc') and not tag.is_('nprogcrc'):
-                crc = binascii.crc32(block[off:off+2*4], crc)
+            if tag.is_('crc'):
+                crc = binascii.crc32(block[off:off+4+4], crc)
             else:
                 crc = binascii.crc32(block[off:off+tag.dsize], crc)
             tag.crc = crc
@@ -212,29 +194,16 @@ class MetadataPair:
 
             self.all_.append(tag)
 
-            if tag.is_('nprogcrc') and len(tag.data) == 8:
-                etag = tag
-                estate = struct.unpack('<II', tag.data)
-            elif tag.is_('crc'):
+            if tag.is_('crc'):
                 # is valid commit?
                 if crc != 0xffffffff:
                     corrupt = True
                 if not corrupt:
                     self.log = self.all_.copy()
-                    # end of commit?
-                    if estate:
-                        esize, ecrc = estate
-                        dcrc = 0xffffffff ^ binascii.crc32(block[off:off+esize])
-                        if ecrc == dcrc:
-                            etag.erased = True
-                            corrupt = True
-                    elif not (tag.is_('crc 0x0') or tag.is_('crc 0x1')):
-                        corrupt = True
 
                 # reset tag parsing
                 crc = 0
-                etag = None
-                estate = None
+                tag = Tag(int(tag) ^ ((tag.type & 1) << 31))
 
         # find active ids
         self.ids = list(it.takewhile(
@@ -311,7 +280,7 @@ class MetadataPair:
         f.write('\n')
 
         for tag in tags:
-            f.write("%08x: %08x  %-14s %3s %4s" % (
+            f.write("%08x: %08x  %-13s %4s %4s" % (
                 tag.off, tag,
                 tag.typerepr(), tag.idrepr(), tag.sizerepr()))
             if truncate:

tests/test_powerloss.toml

@@ -1,172 +0,0 @@
-# There are already a number of tests that test general operations under
-# power-loss (see the reentrant attribute). These tests are for explicitly
-# testing specific corner cases.
-
-[[case]] # only a revision count
-code = '''
-    lfs_format(&lfs, &cfg) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_mkdir(&lfs, "notebook") => 0;
-    lfs_file_open(&lfs, &file, "notebook/paper",
-            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    strcpy((char*)buffer, "hello");
-    size = strlen("hello");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file, buffer, size) => size;
-        lfs_file_sync(&lfs, &file) => 0;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    char rbuffer[256];
-    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // get pair/rev count
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir, "notebook") => 0;
-    lfs_block_t pair[2] = {dir.m.pair[0], dir.m.pair[1]};
-    uint32_t rev = dir.m.rev;
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // write just the revision count
-    uint8_t bbuffer[LFS_BLOCK_SIZE];
-    cfg.read(&cfg, pair[1], 0, bbuffer, LFS_BLOCK_SIZE) => 0;
-
-    memcpy(bbuffer, &(uint32_t){lfs_tole32(rev+1)}, sizeof(uint32_t));
-
-    cfg.erase(&cfg, pair[1]) => 0;
-    cfg.prog(&cfg, pair[1], 0, bbuffer, LFS_BLOCK_SIZE) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-
-    // can read?
-    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    // can write?
-    lfs_file_open(&lfs, &file, "notebook/paper",
-            LFS_O_WRONLY | LFS_O_APPEND) => 0;
-    strcpy((char*)buffer, "goodbye");
-    size = strlen("goodbye");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file, buffer, size) => size;
-        lfs_file_sync(&lfs, &file) => 0;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
-    strcpy((char*)buffer, "hello");
-    size = strlen("hello");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    strcpy((char*)buffer, "goodbye");
-    size = strlen("goodbye");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # partial prog, may not be byte in order!
-if = "LFS_PROG_SIZE < LFS_BLOCK_SIZE"
-define.BYTE_OFF = ["0", "LFS_PROG_SIZE-1", "LFS_PROG_SIZE/2"]
-define.BYTE_VALUE = [0x33, 0xcc]
-in = "lfs.c"
-code = '''
-    lfs_format(&lfs, &cfg) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_mkdir(&lfs, "notebook") => 0;
-    lfs_file_open(&lfs, &file, "notebook/paper",
-            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    strcpy((char*)buffer, "hello");
-    size = strlen("hello");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file, buffer, size) => size;
-        lfs_file_sync(&lfs, &file) => 0;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    char rbuffer[256];
-    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // imitate a partial prog, value should not matter, if littlefs
-    // doesn't notice the partial prog testbd will assert
-
-    // get offset to next prog
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir, "notebook") => 0;
-    lfs_block_t block = dir.m.pair[0];
-    lfs_off_t off = dir.m.off;
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // tweak byte
-    uint8_t bbuffer[LFS_BLOCK_SIZE];
-    cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0;
-
-    bbuffer[off + BYTE_OFF] = BYTE_VALUE;
-
-    cfg.erase(&cfg, block) => 0;
-    cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-
-    // can read?
-    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    // can write?
-    lfs_file_open(&lfs, &file, "notebook/paper",
-            LFS_O_WRONLY | LFS_O_APPEND) => 0;
-    strcpy((char*)buffer, "goodbye");
-    size = strlen("goodbye");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file, buffer, size) => size;
-        lfs_file_sync(&lfs, &file) => 0;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
-    strcpy((char*)buffer, "hello");
-    size = strlen("hello");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    strcpy((char*)buffer, "goodbye");
-    size = strlen("goodbye");
-    for (int i = 0; i < 5; i++) {
-        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        assert(memcmp(rbuffer, buffer, size) == 0);
-    }
-    lfs_file_close(&lfs, &file) => 0;
-
-    lfs_unmount(&lfs) => 0;
-'''