Cleaned up test script and directory naming

- Removed old tests and test scripts
- Reorganize the block devices to live under one directory
- Plugged new test framework into Makefile

renamed:
- scripts/test_.py -> scripts/test.py
- tests_ -> tests
- {file,ram,test}bd/* -> bd/*

It took a surprising amount of effort to make the Makefile behave since
it turns out the "test_%" rule could override "tests/test_%.toml.test"
which is generated as part of test.py.

bd/lfs_filebd.c

@@ -0,0 +1,204 @@
+/*
+ * Block device emulated in a file
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "bd/lfs_filebd.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+int lfs_filebd_createcfg(const struct lfs_config *cfg, const char *path,
+        const struct lfs_filebd_config *bdcfg) {
+    LFS_TRACE("lfs_filebd_createcfg(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
+                "\"%s\", "
+                "%p {.erase_value=%"PRId32"})",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path, (void*)bdcfg, bdcfg->erase_value);
+    lfs_filebd_t *bd = cfg->context;
+    bd->cfg = bdcfg;
+
+    // open file
+    bd->fd = open(path, O_RDWR | O_CREAT, 0666);
+    if (bd->fd < 0) {
+        int err = -errno;
+        LFS_TRACE("lfs_filebd_createcfg -> %d", err);
+        return err;
+    }
+
+    LFS_TRACE("lfs_filebd_createcfg -> %d", 0);
+    return 0;
+}
+
+int lfs_filebd_create(const struct lfs_config *cfg, const char *path) {
+    LFS_TRACE("lfs_filebd_create(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
+                "\"%s\")",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path);
+    static const struct lfs_filebd_config defaults = {.erase_value=-1};
+    int err = lfs_filebd_createcfg(cfg, path, &defaults);
+    LFS_TRACE("lfs_filebd_create -> %d", err);
+    return err;
+}
+
+int lfs_filebd_destroy(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_filebd_destroy(%p)", (void*)cfg);
+    lfs_filebd_t *bd = cfg->context;
+    int err = close(bd->fd);
+    if (err < 0) {
+        err = -errno;
+        LFS_TRACE("lfs_filebd_destroy -> %d", err);
+        return err;
+    }
+    LFS_TRACE("lfs_filebd_destroy -> %d", 0);
+    return 0;
+}
+
+int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_filebd_read(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
+    lfs_filebd_t *bd = cfg->context;
+
+    // check if read is valid
+    LFS_ASSERT(off  % cfg->read_size == 0);
+    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);
+    if (res1 < 0) {
+        int err = -errno;
+        LFS_TRACE("lfs_filebd_read -> %d", err);
+        return err;
+    }
+
+    ssize_t res2 = read(bd->fd, buffer, size);
+    if (res2 < 0) {
+        int err = -errno;
+        LFS_TRACE("lfs_filebd_read -> %d", err);
+        return err;
+    }
+
+    LFS_TRACE("lfs_filebd_read -> %d", 0);
+    return 0;
+}
+
+int lfs_filebd_prog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_filebd_prog(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
+    lfs_filebd_t *bd = cfg->context;
+
+    // check if write is valid
+    LFS_ASSERT(off  % cfg->prog_size == 0);
+    LFS_ASSERT(size % cfg->prog_size == 0);
+    LFS_ASSERT(block < cfg->block_count);
+
+    // check that data was erased? only needed for testing
+    if (bd->cfg->erase_value != -1) {
+        off_t res1 = lseek(bd->fd,
+                (off_t)block*cfg->block_size + (off_t)off, SEEK_SET);
+        if (res1 < 0) {
+            int err = -errno;
+            LFS_TRACE("lfs_filebd_prog -> %d", err);
+            return err;
+        }
+
+        for (lfs_off_t i = 0; i < size; i++) {
+            uint8_t c;
+            ssize_t res2 = read(bd->fd, &c, 1);
+            if (res2 < 0) {
+                int err = -errno;
+                LFS_TRACE("lfs_filebd_prog -> %d", err);
+                return err;
+            }
+
+            LFS_ASSERT(c == bd->cfg->erase_value);
+        }
+    }
+
+    // program data
+    off_t res1 = lseek(bd->fd,
+            (off_t)block*cfg->block_size + (off_t)off, SEEK_SET);
+    if (res1 < 0) {
+        int err = -errno;
+        LFS_TRACE("lfs_filebd_prog -> %d", err);
+        return err;
+    }
+
+    ssize_t res2 = write(bd->fd, buffer, size);
+    if (res2 < 0) {
+        int err = -errno;
+        LFS_TRACE("lfs_filebd_prog -> %d", err);
+        return err;
+    }
+
+    LFS_TRACE("lfs_filebd_prog -> %d", 0);
+    return 0;
+}
+
+int lfs_filebd_erase(const struct lfs_config *cfg, lfs_block_t block) {
+    LFS_TRACE("lfs_filebd_erase(%p, 0x%"PRIx32")", (void*)cfg, block);
+    lfs_filebd_t *bd = cfg->context;
+
+    // check if erase is valid
+    LFS_ASSERT(block < cfg->block_count);
+
+    // erase, only needed for testing
+    if (bd->cfg->erase_value != -1) {
+        off_t res1 = lseek(bd->fd, (off_t)block*cfg->block_size, SEEK_SET);
+        if (res1 < 0) {
+            int err = -errno;
+            LFS_TRACE("lfs_filebd_erase -> %d", err);
+            return err;
+        }
+
+        for (lfs_off_t i = 0; i < cfg->block_size; i++) {
+            ssize_t res2 = write(bd->fd, &(uint8_t){bd->cfg->erase_value}, 1);
+            if (res2 < 0) {
+                int err = -errno;
+                LFS_TRACE("lfs_filebd_erase -> %d", err);
+                return err;
+            }
+        }
+    }
+
+    LFS_TRACE("lfs_filebd_erase -> %d", 0);
+    return 0;
+}
+
+int lfs_filebd_sync(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_filebd_sync(%p)", (void*)cfg);
+    // file sync
+    lfs_filebd_t *bd = cfg->context;
+    int err = fsync(bd->fd);
+    if (err) {
+        err = -errno;
+        LFS_TRACE("lfs_filebd_sync -> %d", 0);
+        return err;
+    }
+
+    LFS_TRACE("lfs_filebd_sync -> %d", 0);
+    return 0;
+}

bd/lfs_filebd.h

@@ -0,0 +1,65 @@
+/*
+ * Block device emulated in a file
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS_FILEBD_H
+#define LFS_FILEBD_H
+
+#include "lfs.h"
+#include "lfs_util.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+// filebd config (optional)
+struct lfs_filebd_config {
+    // 8-bit erase value to use for simulating erases. -1 does not simulate
+    // erases, which can speed up testing by avoiding all the extra block-device
+    // operations to store the erase value.
+    int32_t erase_value;
+};
+
+// filebd state
+typedef struct lfs_filebd {
+    int fd;
+    const struct lfs_filebd_config *cfg;
+} lfs_filebd_t;
+
+
+// Create a file block device using the geometry in lfs_config
+int lfs_filebd_create(const struct lfs_config *cfg, const char *path);
+int lfs_filebd_createcfg(const struct lfs_config *cfg, const char *path,
+        const struct lfs_filebd_config *bdcfg);
+
+// Clean up memory associated with block device
+int lfs_filebd_destroy(const struct lfs_config *cfg);
+
+// Read a block
+int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size);
+
+// Program a block
+//
+// The block must have previously been erased.
+int lfs_filebd_prog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size);
+
+// Erase a block
+//
+// A block must be erased before being programmed. The
+// state of an erased block is undefined.
+int lfs_filebd_erase(const struct lfs_config *cfg, lfs_block_t block);
+
+// Sync the block device
+int lfs_filebd_sync(const struct lfs_config *cfg);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

bd/lfs_rambd.c

@@ -0,0 +1,138 @@
+/*
+ * Block device emulated in RAM
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "bd/lfs_rambd.h"
+
+int lfs_rambd_createcfg(const struct lfs_config *cfg,
+        const struct lfs_rambd_config *bdcfg) {
+    LFS_TRACE("lfs_rambd_createcfg(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
+                "%p {.erase_value=%"PRId32", .buffer=%p})",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            (void*)bdcfg, bdcfg->erase_value, bdcfg->buffer);
+    lfs_rambd_t *bd = cfg->context;
+    bd->cfg = bdcfg;
+
+    // allocate buffer?
+    if (bd->cfg->buffer) {
+        bd->buffer = bd->cfg->buffer;
+    } else {
+        bd->buffer = lfs_malloc(cfg->block_size * cfg->block_count);
+        if (!bd->buffer) {
+            LFS_TRACE("lfs_rambd_createcfg -> %d", LFS_ERR_NOMEM);
+            return LFS_ERR_NOMEM;
+        }
+    }
+
+    // zero for reproducability?
+    if (bd->cfg->erase_value != -1) {
+        memset(bd->buffer, bd->cfg->erase_value,
+                cfg->block_size * cfg->block_count);
+    }
+
+    LFS_TRACE("lfs_rambd_createcfg -> %d", 0);
+    return 0;
+}
+
+int lfs_rambd_create(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_rambd_create(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"})",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count);
+    static const struct lfs_rambd_config defaults = {.erase_value=-1};
+    int err = lfs_rambd_createcfg(cfg, &defaults);
+    LFS_TRACE("lfs_rambd_create -> %d", err);
+    return err;
+}
+
+int lfs_rambd_destroy(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_rambd_destroy(%p)", (void*)cfg);
+    // clean up memory
+    lfs_rambd_t *bd = cfg->context;
+    if (!bd->cfg->buffer) {
+        lfs_free(bd->buffer);
+    }
+    LFS_TRACE("lfs_rambd_destroy -> %d", 0);
+    return 0;
+}
+
+int lfs_rambd_read(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_rambd_read(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
+    lfs_rambd_t *bd = cfg->context;
+
+    // check if read is valid
+    LFS_ASSERT(off  % cfg->read_size == 0);
+    LFS_ASSERT(size % cfg->read_size == 0);
+    LFS_ASSERT(block < cfg->block_count);
+
+    // read data
+    memcpy(buffer, &bd->buffer[block*cfg->block_size + off], size);
+
+    LFS_TRACE("lfs_rambd_read -> %d", 0);
+    return 0;
+}
+
+int lfs_rambd_prog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_rambd_prog(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
+    lfs_rambd_t *bd = cfg->context;
+
+    // check if write is valid
+    LFS_ASSERT(off  % cfg->prog_size == 0);
+    LFS_ASSERT(size % cfg->prog_size == 0);
+    LFS_ASSERT(block < cfg->block_count);
+
+    // check that data was erased? only needed for testing
+    if (bd->cfg->erase_value != -1) {
+        for (lfs_off_t i = 0; i < size; i++) {
+            LFS_ASSERT(bd->buffer[block*cfg->block_size + off + i] ==
+                    bd->cfg->erase_value);
+        }
+    }
+
+    // program data
+    memcpy(&bd->buffer[block*cfg->block_size + off], buffer, size);
+
+    LFS_TRACE("lfs_rambd_prog -> %d", 0);
+    return 0;
+}
+
+int lfs_rambd_erase(const struct lfs_config *cfg, lfs_block_t block) {
+    LFS_TRACE("lfs_rambd_erase(%p, 0x%"PRIx32")", (void*)cfg, block);
+    lfs_rambd_t *bd = cfg->context;
+
+    // check if erase is valid
+    LFS_ASSERT(block < cfg->block_count);
+
+    // erase, only needed for testing
+    if (bd->cfg->erase_value != -1) {
+        memset(&bd->buffer[block*cfg->block_size],
+                bd->cfg->erase_value, cfg->block_size);
+    }
+
+    LFS_TRACE("lfs_rambd_erase -> %d", 0);
+    return 0;
+}
+
+int lfs_rambd_sync(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_rambd_sync(%p)", (void*)cfg);
+    // sync does nothing because we aren't backed by anything real
+    (void)cfg;
+    LFS_TRACE("lfs_rambd_sync -> %d", 0);
+    return 0;
+}

bd/lfs_rambd.h

@@ -0,0 +1,67 @@
+/*
+ * Block device emulated in RAM
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS_RAMBD_H
+#define LFS_RAMBD_H
+
+#include "lfs.h"
+#include "lfs_util.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+// rambd config (optional)
+struct lfs_rambd_config {
+    // 8-bit erase value to simulate erasing with. -1 indicates no erase
+    // occurs, which is still a valid block device
+    int32_t erase_value;
+
+    // Optional statically allocated buffer for the block device.
+    void *buffer;
+};
+
+// rambd state
+typedef struct lfs_rambd {
+    uint8_t *buffer;
+    const struct lfs_rambd_config *cfg;
+} lfs_rambd_t;
+
+
+// Create a RAM block device using the geometry in lfs_config
+int lfs_rambd_create(const struct lfs_config *cfg);
+int lfs_rambd_createcfg(const struct lfs_config *cfg,
+        const struct lfs_rambd_config *bdcfg);
+
+// Clean up memory associated with block device
+int lfs_rambd_destroy(const struct lfs_config *cfg);
+
+// Read a block
+int lfs_rambd_read(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size);
+
+// Program a block
+//
+// The block must have previously been erased.
+int lfs_rambd_prog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size);
+
+// Erase a block
+//
+// A block must be erased before being programmed. The
+// state of an erased block is undefined.
+int lfs_rambd_erase(const struct lfs_config *cfg, lfs_block_t block);
+
+// Sync the block device
+int lfs_rambd_sync(const struct lfs_config *cfg);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

bd/lfs_testbd.c

@@ -0,0 +1,289 @@
+/*
+ * Testing block device, wraps filebd and rambd while providing a bunch
+ * of hooks for testing littlefs in various conditions.
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "bd/lfs_testbd.h"
+
+#include <stdlib.h>
+
+
+int lfs_testbd_createcfg(const struct lfs_config *cfg, const char *path,
+        const struct lfs_testbd_config *bdcfg) {
+    LFS_TRACE("lfs_testbd_createcfg(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
+                "\"%s\", "
+                "%p {.erase_value=%"PRId32", .erase_cycles=%"PRIu32", "
+                ".badblock_behavior=%"PRIu8", .power_cycles=%"PRIu32", "
+                ".buffer=%p, .wear_buffer=%p})",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path, (void*)bdcfg, bdcfg->erase_value, bdcfg->erase_cycles,
+            bdcfg->badblock_behavior, bdcfg->power_cycles,
+            bdcfg->buffer, bdcfg->wear_buffer);
+    lfs_testbd_t *bd = cfg->context;
+    bd->cfg = bdcfg;
+
+    // setup testing things
+    bd->persist = path;
+    bd->power_cycles = bd->cfg->power_cycles;
+
+    if (bd->cfg->erase_cycles) {
+        if (bd->cfg->wear_buffer) {
+            bd->wear = bd->cfg->wear_buffer;
+        } else {
+            bd->wear = lfs_malloc(sizeof(lfs_testbd_wear_t) * cfg->block_count);
+            if (!bd->wear) {
+                LFS_TRACE("lfs_testbd_createcfg -> %d", LFS_ERR_NOMEM);
+                return LFS_ERR_NOMEM;
+            }
+        }
+
+        memset(bd->wear, 0, sizeof(lfs_testbd_wear_t) * cfg->block_count);
+    }
+    
+    // create underlying block device
+    if (bd->persist) {
+        bd->u.file.cfg = (struct lfs_filebd_config){
+            .erase_value = bd->cfg->erase_value,
+        };
+        int err = lfs_filebd_createcfg(cfg, path, &bd->u.file.cfg);
+        LFS_TRACE("lfs_testbd_createcfg -> %d", err);
+        return err;
+    } else {
+        bd->u.ram.cfg = (struct lfs_rambd_config){
+            .erase_value = bd->cfg->erase_value,
+            .buffer = bd->cfg->buffer,
+        };
+        int err = lfs_rambd_createcfg(cfg, &bd->u.ram.cfg);
+        LFS_TRACE("lfs_testbd_createcfg -> %d", err);
+        return err;
+    }
+}
+
+int lfs_testbd_create(const struct lfs_config *cfg, const char *path) {
+    LFS_TRACE("lfs_testbd_create(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
+                "\"%s\")",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path);
+    static const struct lfs_testbd_config defaults = {.erase_value=-1};
+    int err = lfs_testbd_createcfg(cfg, path, &defaults);
+    LFS_TRACE("lfs_testbd_create -> %d", err);
+    return err;
+}
+
+int lfs_testbd_destroy(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_testbd_destroy(%p)", (void*)cfg);
+    lfs_testbd_t *bd = cfg->context;
+    if (bd->cfg->erase_cycles && !bd->cfg->wear_buffer) {
+        lfs_free(bd->wear);
+    }
+
+    if (bd->persist) {
+        int err = lfs_filebd_destroy(cfg);
+        LFS_TRACE("lfs_testbd_destroy -> %d", err);
+        return err;
+    } else {
+        int err = lfs_rambd_destroy(cfg);
+        LFS_TRACE("lfs_testbd_destroy -> %d", err);
+        return err;
+    }
+}
+
+/// Internal mapping to block devices ///
+static int lfs_testbd_rawread(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size) {
+    lfs_testbd_t *bd = cfg->context;
+    if (bd->persist) {
+        return lfs_filebd_read(cfg, block, off, buffer, size);
+    } else {
+        return lfs_rambd_read(cfg, block, off, buffer, size);
+    }
+}
+
+static int lfs_testbd_rawprog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size) {
+    lfs_testbd_t *bd = cfg->context;
+    if (bd->persist) {
+        return lfs_filebd_prog(cfg, block, off, buffer, size);
+    } else {
+        return lfs_rambd_prog(cfg, block, off, buffer, size);
+    }
+}
+
+static int lfs_testbd_rawerase(const struct lfs_config *cfg,
+        lfs_block_t block) {
+    lfs_testbd_t *bd = cfg->context;
+    if (bd->persist) {
+        return lfs_filebd_erase(cfg, block);
+    } else {
+        return lfs_rambd_erase(cfg, block);
+    }
+}
+
+static int lfs_testbd_rawsync(const struct lfs_config *cfg) {
+    lfs_testbd_t *bd = cfg->context;
+    if (bd->persist) {
+        return lfs_filebd_sync(cfg);
+    } else {
+        return lfs_rambd_sync(cfg);
+    }
+}
+
+/// block device API ///
+int lfs_testbd_read(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_testbd_read(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
+    lfs_testbd_t *bd = cfg->context;
+
+    // check if read is valid
+    LFS_ASSERT(off  % cfg->read_size == 0);
+    LFS_ASSERT(size % cfg->read_size == 0);
+    LFS_ASSERT(block < cfg->block_count);
+
+    // block bad?
+    if (bd->cfg->erase_cycles &&
+            bd->cfg->badblock_behavior == LFS_TESTBD_BADBLOCK_NOREAD &&
+            bd->wear[block] >= bd->cfg->erase_cycles) {
+        LFS_TRACE("lfs_testbd_read -> %d", LFS_ERR_CORRUPT);
+        return LFS_ERR_CORRUPT;
+    }
+
+    // read
+    int err = lfs_testbd_rawread(cfg, block, off, buffer, size);
+    LFS_TRACE("lfs_testbd_read -> %d", err);
+    return err;
+}
+
+int lfs_testbd_prog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_testbd_prog(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
+    lfs_testbd_t *bd = cfg->context;
+
+    // check if write is valid
+    LFS_ASSERT(off  % cfg->prog_size == 0);
+    LFS_ASSERT(size % cfg->prog_size == 0);
+    LFS_ASSERT(block < cfg->block_count);
+
+    // block bad?
+    if (bd->cfg->erase_cycles &&
+            bd->cfg->badblock_behavior == LFS_TESTBD_BADBLOCK_NOPROG &&
+            bd->wear[block] >= bd->cfg->erase_cycles) {
+        LFS_TRACE("lfs_testbd_prog -> %d", LFS_ERR_CORRUPT);
+        return LFS_ERR_CORRUPT;
+    }
+
+    // prog
+    int err = lfs_testbd_rawprog(cfg, block, off, buffer, size);
+    if (err) {
+        LFS_TRACE("lfs_testbd_prog -> %d", err);
+        return err;
+    }
+
+    // lose power?
+    if (bd->power_cycles > 0) {
+        bd->power_cycles -= 1;
+        if (bd->power_cycles == 0) {
+            // sync to make sure we persist the last changes
+            assert(lfs_testbd_rawsync(cfg) == 0);
+            // simulate power loss
+            exit(33);
+        }
+    }
+
+    LFS_TRACE("lfs_testbd_prog -> %d", 0);
+    return 0;
+}
+
+int lfs_testbd_erase(const struct lfs_config *cfg, lfs_block_t block) {
+    LFS_TRACE("lfs_testbd_erase(%p, 0x%"PRIx32")", (void*)cfg, block);
+    lfs_testbd_t *bd = cfg->context;
+
+    // check if erase is valid
+    LFS_ASSERT(block < cfg->block_count);
+
+    // block bad?
+    if (bd->cfg->erase_cycles) {
+        if (bd->wear[block] >= bd->cfg->erase_cycles) {
+            if (bd->cfg->badblock_behavior == LFS_TESTBD_BADBLOCK_NOERASE) {
+                LFS_TRACE("lfs_testbd_erase -> %d", LFS_ERR_CORRUPT);
+                return LFS_ERR_CORRUPT;
+            }
+        } else {
+            // mark wear
+            bd->wear[block] += 1;
+        }
+    }
+
+    // erase
+    int err = lfs_testbd_rawerase(cfg, block);
+    if (err) {
+        LFS_TRACE("lfs_testbd_erase -> %d", err);
+        return err;
+    }
+
+    // lose power?
+    if (bd->power_cycles > 0) {
+        bd->power_cycles -= 1;
+        if (bd->power_cycles == 0) {
+            // sync to make sure we persist the last changes
+            assert(lfs_testbd_rawsync(cfg) == 0);
+            // simulate power loss
+            exit(33);
+        }
+    }
+
+    LFS_TRACE("lfs_testbd_prog -> %d", 0);
+    return 0;
+}
+
+int lfs_testbd_sync(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_testbd_sync(%p)", (void*)cfg);
+    int err = lfs_testbd_rawsync(cfg);
+    LFS_TRACE("lfs_testbd_sync -> %d", err);
+    return err;
+}
+
+
+/// simulated wear operations ///
+lfs_testbd_swear_t lfs_testbd_getwear(const struct lfs_config *cfg,
+        lfs_block_t block) {
+    LFS_TRACE("lfs_testbd_getwear(%p, %"PRIu32")", (void*)cfg, block);
+    lfs_testbd_t *bd = cfg->context;
+
+    // check if block is valid
+    LFS_ASSERT(bd->cfg->erase_cycles);
+    LFS_ASSERT(block < cfg->block_count);
+
+    LFS_TRACE("lfs_testbd_getwear -> %"PRIu32, bd->wear[block]);
+    return bd->wear[block];
+}
+
+int lfs_testbd_setwear(const struct lfs_config *cfg,
+        lfs_block_t block, lfs_testbd_wear_t wear) {
+    LFS_TRACE("lfs_testbd_setwear(%p, %"PRIu32")", (void*)cfg, block);
+    lfs_testbd_t *bd = cfg->context;
+
+    // check if block is valid
+    LFS_ASSERT(bd->cfg->erase_cycles);
+    LFS_ASSERT(block < cfg->block_count);
+
+    bd->wear[block] = wear;
+
+    LFS_TRACE("lfs_testbd_setwear -> %d", 0);
+    return 0;
+}

bd/lfs_testbd.h

@@ -0,0 +1,130 @@
+/*
+ * Testing block device, wraps filebd and rambd while providing a bunch
+ * of hooks for testing littlefs in various conditions.
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS_TESTBD_H
+#define LFS_TESTBD_H
+
+#include "lfs.h"
+#include "lfs_util.h"
+#include "bd/lfs_rambd.h"
+#include "bd/lfs_filebd.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+// Mode determining how "bad blocks" behave during testing. This
+// simulates some real-world circumstances such as writes not
+// going through (noprog), erases not sticking (noerase), and ECC
+// failures (noread).
+enum lfs_testbd_badblock_behavior {
+    LFS_TESTBD_BADBLOCK_NOPROG  = 0,
+    LFS_TESTBD_BADBLOCK_NOERASE = 1,
+    LFS_TESTBD_BADBLOCK_NOREAD  = 2,
+};
+
+// Type for measuring wear
+typedef uint32_t lfs_testbd_wear_t;
+typedef int32_t  lfs_testbd_swear_t;
+
+// testbd config, this is required for testing
+struct lfs_testbd_config {
+    // 8-bit erase value to use for simulating erases. -1 does not simulate
+    // erases, which can speed up testing by avoiding all the extra block-device
+    // operations to store the erase value.
+    int32_t erase_value;
+
+    // Number of erase cycles before a block becomes "bad". The exact behavior
+    // of bad blocks is controlled by the badblock_mode.
+    uint32_t erase_cycles;
+
+    // The mode determining how bad blocks fail
+    uint8_t badblock_behavior;
+
+    // Number of write operations (erase/prog) before forcefully killing
+    // the program with exit. Simulates power-loss. 0 disables.
+    uint32_t power_cycles;
+
+    // Optional buffer for RAM block device.
+    void *buffer;
+
+    // Optional buffer for wear
+    void *wear_buffer;
+};
+
+// testbd state
+typedef struct lfs_testbd {
+    union {
+        struct {
+            lfs_filebd_t bd;
+            struct lfs_filebd_config cfg;
+        } file;
+        struct {
+            lfs_rambd_t bd;
+            struct lfs_rambd_config cfg;
+        } ram;
+    } u;
+
+    bool persist;
+    uint32_t power_cycles;
+    lfs_testbd_wear_t *wear;
+
+    const struct lfs_testbd_config *cfg;
+} lfs_testbd_t;
+
+
+/// Block device API ///
+
+// Create a test block device using the geometry in lfs_config
+// 
+// Note that filebd is used if a path is provided, if path is NULL
+// testbd will use rambd which can be much faster.
+int lfs_testbd_create(const struct lfs_config *cfg, const char *path);
+int lfs_testbd_createcfg(const struct lfs_config *cfg, const char *path,
+        const struct lfs_testbd_config *bdcfg);
+
+// Clean up memory associated with block device
+int lfs_testbd_destroy(const struct lfs_config *cfg);
+
+// Read a block
+int lfs_testbd_read(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, void *buffer, lfs_size_t size);
+
+// Program a block
+//
+// The block must have previously been erased.
+int lfs_testbd_prog(const struct lfs_config *cfg, lfs_block_t block,
+        lfs_off_t off, const void *buffer, lfs_size_t size);
+
+// Erase a block
+//
+// A block must be erased before being programmed. The
+// state of an erased block is undefined.
+int lfs_testbd_erase(const struct lfs_config *cfg, lfs_block_t block);
+
+// Sync the block device
+int lfs_testbd_sync(const struct lfs_config *cfg);
+
+
+/// Additional extended API for driving test features ///
+
+// Get simulated wear on a given block
+lfs_testbd_swear_t lfs_testbd_getwear(const struct lfs_config *cfg,
+        lfs_block_t block);
+
+// Manually set simulated wear on a given block
+int lfs_testbd_setwear(const struct lfs_config *cfg,
+        lfs_block_t block, lfs_testbd_wear_t wear);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif