Big rename! Renamed lfs -> lfs3 and lfsr -> lfs3
This commit is contained in:
Christopher Haster
+340
-337
File diff suppressed because it is too large
Load Diff
+265
@@ -0,0 +1,265 @@
|
||||
/*
|
||||
* Emulating block device, wraps filebd and rambd while providing a bunch
|
||||
* of hooks for testing littlefs in various conditions.
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* Copyright (c) 2017, Arm Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
#ifndef LFS3_EMUBD_H
|
||||
#define LFS3_EMUBD_H
|
||||
|
||||
#include "lfs3.h"
|
||||
#include "lfs3_util.h"
|
||||
#include "bd/lfs3_rambd.h"
|
||||
#include "bd/lfs3_filebd.h"
|
||||
|
||||
|
||||
// Block device specific tracing
|
||||
#ifndef LFS3_EMUBD_TRACE
|
||||
#ifdef LFS3_EMUBD_YES_TRACE
|
||||
#define LFS3_EMUBD_TRACE(...) LFS3_TRACE(__VA_ARGS__)
|
||||
#else
|
||||
#define LFS3_EMUBD_TRACE(...)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Mode determining how "bad-blocks" behave during testing. This simulates
|
||||
// some real-world circumstances such as progs not sticking (prog-noop),
|
||||
// a readonly disk (erase-noop), ECC failures (read-error), and of course,
|
||||
// random bit failures (prog-flip, read-flip)
|
||||
typedef enum lfs3_emubd_badblock_behavior {
|
||||
LFS3_EMUBD_BADBLOCK_PROGERROR = 0, // Error on prog
|
||||
LFS3_EMUBD_BADBLOCK_ERASEERROR = 1, // Error on erase
|
||||
LFS3_EMUBD_BADBLOCK_READERROR = 2, // Error on read
|
||||
LFS3_EMUBD_BADBLOCK_PROGNOOP = 3, // Prog does nothing silently
|
||||
LFS3_EMUBD_BADBLOCK_ERASENOOP = 4, // Erase does nothing silently
|
||||
LFS3_EMUBD_BADBLOCK_PROGFLIP = 5, // Prog flips a bit
|
||||
LFS3_EMUBD_BADBLOCK_READFLIP = 6, // Read flips a bit sometimes
|
||||
LFS3_EMUBD_BADBLOCK_MANUAL = 7, // Bits require manual flipping
|
||||
} lfs3_emubd_badblock_behavior_t;
|
||||
|
||||
// Mode determining how power-loss behaves during testing.
|
||||
typedef enum lfs3_emubd_powerloss_behavior {
|
||||
LFS3_EMUBD_POWERLOSS_ATOMIC = 0, // Progs are atomic
|
||||
LFS3_EMUBD_POWERLOSS_SOMEBITS = 1, // One bit is progged
|
||||
LFS3_EMUBD_POWERLOSS_MOSTBITS = 2, // All-but-one bit is progged
|
||||
LFS3_EMUBD_POWERLOSS_OOO = 3, // Blocks are written out-of-order
|
||||
LFS3_EMUBD_POWERLOSS_METASTABLE = 4, // Reads may flip a bit
|
||||
} lfs3_emubd_powerloss_behavior_t;
|
||||
|
||||
// Type for measuring read/program/erase operations
|
||||
typedef uint64_t lfs3_emubd_io_t;
|
||||
typedef int64_t lfs3_emubd_sio_t;
|
||||
|
||||
// Type for measuring wear
|
||||
typedef uint32_t lfs3_emubd_wear_t;
|
||||
typedef int32_t lfs3_emubd_swear_t;
|
||||
|
||||
// Type for tracking power-cycles
|
||||
typedef uint32_t lfs3_emubd_powercycles_t;
|
||||
typedef int32_t lfs3_emubd_spowercycles_t;
|
||||
|
||||
// Type for delays in nanoseconds
|
||||
typedef uint64_t lfs3_emubd_sleep_t;
|
||||
typedef int64_t lfs3_emubd_ssleep_t;
|
||||
|
||||
// emubd config, this is required for testing
|
||||
struct lfs3_emubd_config {
|
||||
// 8-bit erase value to use for simulating erases. -1 simulates a noop
|
||||
// erase, which is faster than simulating a fixed erase value.
|
||||
int32_t erase_value;
|
||||
|
||||
// Number of erase cycles before a block becomes "bad". The exact behavior
|
||||
// of bad blocks is controlled by badblock_behavior.
|
||||
uint32_t erase_cycles;
|
||||
|
||||
// The mode determining how bad-blocks fail
|
||||
lfs3_emubd_badblock_behavior_t badblock_behavior;
|
||||
|
||||
// Number of write operations (erase/prog) before triggering a power-loss.
|
||||
// power_cycles=0 disables this. The exact behavior of power-loss is
|
||||
// controlled by a combination of powerloss_behavior and powerloss_cb.
|
||||
lfs3_emubd_powercycles_t power_cycles;
|
||||
|
||||
// The mode determining how power-loss affects disk
|
||||
lfs3_emubd_powerloss_behavior_t powerloss_behavior;
|
||||
|
||||
// Function to call to emulate power-loss. The exact behavior of power-loss
|
||||
// is up to the runner to provide.
|
||||
void (*powerloss_cb)(void*);
|
||||
|
||||
// Data for power-loss callback
|
||||
void *powerloss_data;
|
||||
|
||||
// Seed for prng, which may be used for emulating failed progs. This does
|
||||
// not affect normal operation.
|
||||
uint32_t seed;
|
||||
|
||||
// Path to file to use as a mirror of the disk. This provides a way to view
|
||||
// the current state of the block device.
|
||||
const char *disk_path;
|
||||
|
||||
// Artificial delay in nanoseconds, there is no purpose for this other
|
||||
// than slowing down the simulation.
|
||||
lfs3_emubd_sleep_t read_sleep;
|
||||
|
||||
// Artificial delay in nanoseconds, there is no purpose for this other
|
||||
// than slowing down the simulation.
|
||||
lfs3_emubd_sleep_t prog_sleep;
|
||||
|
||||
// Artificial delay in nanoseconds, there is no purpose for this other
|
||||
// than slowing down the simulation.
|
||||
lfs3_emubd_sleep_t erase_sleep;
|
||||
};
|
||||
|
||||
// A reference counted block
|
||||
typedef struct lfs3_emubd_block {
|
||||
uint32_t rc;
|
||||
lfs3_emubd_wear_t wear;
|
||||
bool metastable;
|
||||
// sign(bad_bit)=0 => randomized on erase
|
||||
// sign(bad_bit)=1 => fixed
|
||||
lfs3_size_t bad_bit;
|
||||
|
||||
uint8_t data[];
|
||||
} lfs3_emubd_block_t;
|
||||
|
||||
// Disk mirror
|
||||
typedef struct lfs3_emubd_disk {
|
||||
uint32_t rc;
|
||||
int fd;
|
||||
uint8_t *scratch;
|
||||
} lfs3_emubd_disk_t;
|
||||
|
||||
// emubd state
|
||||
typedef struct lfs3_emubd {
|
||||
// array of copy-on-write blocks
|
||||
lfs3_emubd_block_t **blocks;
|
||||
|
||||
// some other test state
|
||||
lfs3_emubd_io_t readed;
|
||||
lfs3_emubd_io_t proged;
|
||||
lfs3_emubd_io_t erased;
|
||||
uint32_t prng;
|
||||
lfs3_emubd_powercycles_t power_cycles;
|
||||
lfs3_emubd_block_t **ooo_before;
|
||||
lfs3_emubd_block_t **ooo_after;
|
||||
lfs3_emubd_disk_t *disk;
|
||||
|
||||
const struct lfs3_emubd_config *cfg;
|
||||
} lfs3_emubd_t;
|
||||
|
||||
|
||||
/// Block device API ///
|
||||
|
||||
// Create an emulating block device using the geometry in lfs3_config
|
||||
//
|
||||
// Note that filebd is used if a path is provided, if path is NULL
|
||||
// emubd will use rambd which can be much faster.
|
||||
int lfs3_emubd_create(const struct lfs3_config *cfg, const char *path);
|
||||
int lfs3_emubd_createcfg(const struct lfs3_config *cfg, const char *path,
|
||||
const struct lfs3_emubd_config *bdcfg);
|
||||
|
||||
// Clean up memory associated with block device
|
||||
int lfs3_emubd_destroy(const struct lfs3_config *cfg);
|
||||
|
||||
// Read a block
|
||||
int lfs3_emubd_read(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, void *buffer, lfs3_size_t size);
|
||||
|
||||
// Program a block
|
||||
//
|
||||
// The block must have previously been erased.
|
||||
int lfs3_emubd_prog(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, const void *buffer, lfs3_size_t size);
|
||||
|
||||
// Erase a block
|
||||
//
|
||||
// A block must be erased before being programmed. The
|
||||
// state of an erased block is undefined.
|
||||
int lfs3_emubd_erase(const struct lfs3_config *cfg, lfs3_block_t block);
|
||||
|
||||
// Sync the block device
|
||||
int lfs3_emubd_sync(const struct lfs3_config *cfg);
|
||||
|
||||
|
||||
/// Additional extended API for driving test features ///
|
||||
|
||||
// Set the current prng state
|
||||
void lfs3_emubd_seed(const struct lfs3_config *cfg, uint32_t seed);
|
||||
|
||||
// Get a pseudo-random number from emubd's internal prng
|
||||
uint32_t lfs3_emubd_prng(const struct lfs3_config *cfg);
|
||||
|
||||
// Get total amount of bytes read
|
||||
lfs3_emubd_sio_t lfs3_emubd_readed(const struct lfs3_config *cfg);
|
||||
|
||||
// Get total amount of bytes programmed
|
||||
lfs3_emubd_sio_t lfs3_emubd_proged(const struct lfs3_config *cfg);
|
||||
|
||||
// Get total amount of bytes erased
|
||||
lfs3_emubd_sio_t lfs3_emubd_erased(const struct lfs3_config *cfg);
|
||||
|
||||
// Manually set amount of bytes read
|
||||
int lfs3_emubd_setreaded(const struct lfs3_config *cfg,
|
||||
lfs3_emubd_io_t readed);
|
||||
|
||||
// Manually set amount of bytes programmed
|
||||
int lfs3_emubd_setproged(const struct lfs3_config *cfg,
|
||||
lfs3_emubd_io_t proged);
|
||||
|
||||
// Manually set amount of bytes erased
|
||||
int lfs3_emubd_seterased(const struct lfs3_config *cfg,
|
||||
lfs3_emubd_io_t erased);
|
||||
|
||||
// Get simulated wear on a given block
|
||||
lfs3_emubd_swear_t lfs3_emubd_wear(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block);
|
||||
|
||||
// Manually set simulated wear on a given block
|
||||
int lfs3_emubd_setwear(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block, lfs3_emubd_wear_t wear);
|
||||
|
||||
// Mark a block as bad, this is equivalent to setting wear to maximum
|
||||
int lfs3_emubd_markbad(const struct lfs3_config *cfg, lfs3_block_t block);
|
||||
|
||||
// Clear any simulated wear on a given block
|
||||
int lfs3_emubd_markgood(const struct lfs3_config *cfg, lfs3_block_t block);
|
||||
|
||||
// Get which bit failed, this changes on erase/power-loss unless manually set
|
||||
lfs3_ssize_t lfs3_emubd_badbit(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block);
|
||||
|
||||
// Set which bit should fail in a given block
|
||||
int lfs3_emubd_setbadbit(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block, lfs3_size_t bit);
|
||||
|
||||
// Randomize the bad bit on erase (the default)
|
||||
int lfs3_emubd_randomizebadbit(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block);
|
||||
|
||||
// Mark a block as bad and which bit should fail
|
||||
int lfs3_emubd_markbadbit(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block, lfs3_size_t bit);
|
||||
|
||||
// Flip a bit in a given block, intended for emulating bit errors
|
||||
int lfs3_emubd_flipbit(const struct lfs3_config *cfg,
|
||||
lfs3_block_t block, lfs3_size_t bit);
|
||||
|
||||
// Flip all bits marked as bad
|
||||
int lfs3_emubd_flip(const struct lfs3_config *cfg);
|
||||
|
||||
// Get the remaining power-cycles
|
||||
lfs3_emubd_spowercycles_t lfs3_emubd_powercycles(
|
||||
const struct lfs3_config *cfg);
|
||||
|
||||
// Manually set the remaining power-cycles
|
||||
int lfs3_emubd_setpowercycles(const struct lfs3_config *cfg,
|
||||
lfs3_emubd_powercycles_t power_cycles);
|
||||
|
||||
// Create a copy-on-write copy of the state of this block device
|
||||
int lfs3_emubd_cpy(const struct lfs3_config *cfg, lfs3_emubd_t *copy);
|
||||
|
||||
|
||||
#endif
|
||||
@@ -5,7 +5,7 @@
|
||||
* Copyright (c) 2017, Arm Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
#include "bd/lfs_filebd.h"
|
||||
#include "bd/lfs3_filebd.h"
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
@@ -15,8 +15,8 @@
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int lfs_filebd_create(const struct lfs_config *cfg, const char *path) {
|
||||
LFS_FILEBD_TRACE("lfs_filebd_create(%p {.context=%p, "
|
||||
int lfs3_filebd_create(const struct lfs3_config *cfg, const char *path) {
|
||||
LFS3_FILEBD_TRACE("lfs3_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"}, "
|
||||
@@ -26,7 +26,7 @@ int lfs_filebd_create(const struct lfs_config *cfg, const char *path) {
|
||||
(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;
|
||||
lfs3_filebd_t *bd = cfg->context;
|
||||
|
||||
// open file
|
||||
#ifdef _WIN32
|
||||
@@ -37,39 +37,39 @@ int lfs_filebd_create(const struct lfs_config *cfg, const char *path) {
|
||||
|
||||
if (bd->fd < 0) {
|
||||
int err = -errno;
|
||||
LFS_FILEBD_TRACE("lfs_filebd_create -> %d", err);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_create -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
LFS_FILEBD_TRACE("lfs_filebd_create -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_create -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_filebd_destroy(const struct lfs_config *cfg) {
|
||||
LFS_FILEBD_TRACE("lfs_filebd_destroy(%p)", (void*)cfg);
|
||||
lfs_filebd_t *bd = cfg->context;
|
||||
int lfs3_filebd_destroy(const struct lfs3_config *cfg) {
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_destroy(%p)", (void*)cfg);
|
||||
lfs3_filebd_t *bd = cfg->context;
|
||||
int err = close(bd->fd);
|
||||
if (err < 0) {
|
||||
err = -errno;
|
||||
LFS_FILEBD_TRACE("lfs_filebd_destroy -> %d", err);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_destroy -> %d", err);
|
||||
return err;
|
||||
}
|
||||
LFS_FILEBD_TRACE("lfs_filebd_destroy -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_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_FILEBD_TRACE("lfs_filebd_read(%p, "
|
||||
int lfs3_filebd_read(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, void *buffer, lfs3_size_t size) {
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_read(%p, "
|
||||
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
|
||||
(void*)cfg, block, off, buffer, size);
|
||||
lfs_filebd_t *bd = cfg->context;
|
||||
lfs3_filebd_t *bd = cfg->context;
|
||||
|
||||
// check if read is valid
|
||||
LFS_ASSERT(block < cfg->block_count);
|
||||
LFS_ASSERT(off % cfg->read_size == 0);
|
||||
LFS_ASSERT(size % cfg->read_size == 0);
|
||||
LFS_ASSERT(off+size <= cfg->block_size);
|
||||
LFS3_ASSERT(block < cfg->block_count);
|
||||
LFS3_ASSERT(off % cfg->read_size == 0);
|
||||
LFS3_ASSERT(size % cfg->read_size == 0);
|
||||
LFS3_ASSERT(off+size <= cfg->block_size);
|
||||
|
||||
// zero for reproducibility (in case file is truncated)
|
||||
memset(buffer, 0, size);
|
||||
@@ -79,73 +79,73 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
|
||||
(off_t)block*cfg->block_size + (off_t)off, SEEK_SET);
|
||||
if (res1 < 0) {
|
||||
int err = -errno;
|
||||
LFS_FILEBD_TRACE("lfs_filebd_read -> %d", err);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_read -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
ssize_t res2 = read(bd->fd, buffer, size);
|
||||
if (res2 < 0) {
|
||||
int err = -errno;
|
||||
LFS_FILEBD_TRACE("lfs_filebd_read -> %d", err);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_read -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
LFS_FILEBD_TRACE("lfs_filebd_read -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_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_FILEBD_TRACE("lfs_filebd_prog(%p, "
|
||||
int lfs3_filebd_prog(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, const void *buffer, lfs3_size_t size) {
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_prog(%p, "
|
||||
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
|
||||
(void*)cfg, block, off, buffer, size);
|
||||
lfs_filebd_t *bd = cfg->context;
|
||||
lfs3_filebd_t *bd = cfg->context;
|
||||
|
||||
// check if write is valid
|
||||
LFS_ASSERT(block < cfg->block_count);
|
||||
LFS_ASSERT(off % cfg->prog_size == 0);
|
||||
LFS_ASSERT(size % cfg->prog_size == 0);
|
||||
LFS_ASSERT(off+size <= cfg->block_size);
|
||||
LFS3_ASSERT(block < cfg->block_count);
|
||||
LFS3_ASSERT(off % cfg->prog_size == 0);
|
||||
LFS3_ASSERT(size % cfg->prog_size == 0);
|
||||
LFS3_ASSERT(off+size <= cfg->block_size);
|
||||
|
||||
// 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_FILEBD_TRACE("lfs_filebd_prog -> %d", err);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_prog -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
ssize_t res2 = write(bd->fd, buffer, size);
|
||||
if (res2 < 0) {
|
||||
int err = -errno;
|
||||
LFS_FILEBD_TRACE("lfs_filebd_prog -> %d", err);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_prog -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
LFS_FILEBD_TRACE("lfs_filebd_prog -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_prog -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_filebd_erase(const struct lfs_config *cfg, lfs_block_t block) {
|
||||
LFS_FILEBD_TRACE("lfs_filebd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
|
||||
int lfs3_filebd_erase(const struct lfs3_config *cfg, lfs3_block_t block) {
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
|
||||
(void*)cfg, block, cfg->block_size);
|
||||
|
||||
// check if erase is valid
|
||||
LFS_ASSERT(block < cfg->block_count);
|
||||
LFS3_ASSERT(block < cfg->block_count);
|
||||
|
||||
// erase is a noop
|
||||
(void)block;
|
||||
|
||||
LFS_FILEBD_TRACE("lfs_filebd_erase -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_erase -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_filebd_sync(const struct lfs_config *cfg) {
|
||||
LFS_FILEBD_TRACE("lfs_filebd_sync(%p)", (void*)cfg);
|
||||
int lfs3_filebd_sync(const struct lfs3_config *cfg) {
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_sync(%p)", (void*)cfg);
|
||||
|
||||
// file sync
|
||||
lfs_filebd_t *bd = cfg->context;
|
||||
lfs3_filebd_t *bd = cfg->context;
|
||||
#ifdef _WIN32
|
||||
int err = FlushFileBuffers((HANDLE) _get_osfhandle(bd->fd)) ? 0 : -1;
|
||||
#else
|
||||
@@ -153,10 +153,10 @@ int lfs_filebd_sync(const struct lfs_config *cfg) {
|
||||
#endif
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_FILEBD_TRACE("lfs_filebd_sync -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_sync -> %d", 0);
|
||||
return err;
|
||||
}
|
||||
|
||||
LFS_FILEBD_TRACE("lfs_filebd_sync -> %d", 0);
|
||||
LFS3_FILEBD_TRACE("lfs3_filebd_sync -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/*
|
||||
* Block device emulated in a file
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* Copyright (c) 2017, Arm Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
#ifndef LFS3_FILEBD_H
|
||||
#define LFS3_FILEBD_H
|
||||
|
||||
#include "lfs3.h"
|
||||
#include "lfs3_util.h"
|
||||
|
||||
|
||||
// Block device specific tracing
|
||||
#ifndef LFS3_FILEBD_TRACE
|
||||
#ifdef LFS3_FILEBD_YES_TRACE
|
||||
#define LFS3_FILEBD_TRACE(...) LFS3_TRACE(__VA_ARGS__)
|
||||
#else
|
||||
#define LFS3_FILEBD_TRACE(...)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// filebd state
|
||||
typedef struct lfs3_filebd {
|
||||
int fd;
|
||||
} lfs3_filebd_t;
|
||||
|
||||
|
||||
// Create a file block device using the geometry in lfs3_config
|
||||
int lfs3_filebd_create(const struct lfs3_config *cfg, const char *path);
|
||||
|
||||
// Clean up memory associated with block device
|
||||
int lfs3_filebd_destroy(const struct lfs3_config *cfg);
|
||||
|
||||
// Read a block
|
||||
int lfs3_filebd_read(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, void *buffer, lfs3_size_t size);
|
||||
|
||||
// Program a block
|
||||
//
|
||||
// The block must have previously been erased.
|
||||
int lfs3_filebd_prog(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, const void *buffer, lfs3_size_t size);
|
||||
|
||||
// Erase a block
|
||||
//
|
||||
// A block must be erased before being programmed. The
|
||||
// state of an erased block is undefined.
|
||||
int lfs3_filebd_erase(const struct lfs3_config *cfg, lfs3_block_t block);
|
||||
|
||||
// Sync the block device
|
||||
int lfs3_filebd_sync(const struct lfs3_config *cfg);
|
||||
|
||||
|
||||
#endif
|
||||
+131
@@ -0,0 +1,131 @@
|
||||
/*
|
||||
* Block device emulated in RAM
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* Copyright (c) 2017, Arm Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
#include "bd/lfs3_rambd.h"
|
||||
|
||||
int lfs3_rambd_createcfg(const struct lfs3_config *cfg,
|
||||
const struct lfs3_rambd_config *bdcfg) {
|
||||
LFS3_RAMBD_TRACE("lfs3_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 {.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->buffer);
|
||||
lfs3_rambd_t *bd = cfg->context;
|
||||
bd->cfg = bdcfg;
|
||||
|
||||
// allocate buffer?
|
||||
if (bd->cfg->buffer) {
|
||||
bd->buffer = bd->cfg->buffer;
|
||||
} else {
|
||||
bd->buffer = lfs3_malloc(cfg->block_size * cfg->block_count);
|
||||
if (!bd->buffer) {
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_createcfg -> %d", LFS3_ERR_NOMEM);
|
||||
return LFS3_ERR_NOMEM;
|
||||
}
|
||||
}
|
||||
|
||||
// zero for reproducibility
|
||||
memset(bd->buffer, 0, cfg->block_size * cfg->block_count);
|
||||
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_createcfg -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs3_rambd_create(const struct lfs3_config *cfg) {
|
||||
LFS3_RAMBD_TRACE("lfs3_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 lfs3_rambd_config defaults = {0};
|
||||
int err = lfs3_rambd_createcfg(cfg, &defaults);
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_create -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
int lfs3_rambd_destroy(const struct lfs3_config *cfg) {
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_destroy(%p)", (void*)cfg);
|
||||
// clean up memory
|
||||
lfs3_rambd_t *bd = cfg->context;
|
||||
if (!bd->cfg->buffer) {
|
||||
lfs3_free(bd->buffer);
|
||||
}
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_destroy -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs3_rambd_read(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, void *buffer, lfs3_size_t size) {
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_read(%p, "
|
||||
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
|
||||
(void*)cfg, block, off, buffer, size);
|
||||
lfs3_rambd_t *bd = cfg->context;
|
||||
|
||||
// check if read is valid
|
||||
LFS3_ASSERT(block < cfg->block_count);
|
||||
LFS3_ASSERT(off % cfg->read_size == 0);
|
||||
LFS3_ASSERT(size % cfg->read_size == 0);
|
||||
LFS3_ASSERT(off+size <= cfg->block_size);
|
||||
|
||||
// read data
|
||||
memcpy(buffer, &bd->buffer[block*cfg->block_size + off], size);
|
||||
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_read -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs3_rambd_prog(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, const void *buffer, lfs3_size_t size) {
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_prog(%p, "
|
||||
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
|
||||
(void*)cfg, block, off, buffer, size);
|
||||
lfs3_rambd_t *bd = cfg->context;
|
||||
|
||||
// check if write is valid
|
||||
LFS3_ASSERT(block < cfg->block_count);
|
||||
LFS3_ASSERT(off % cfg->prog_size == 0);
|
||||
LFS3_ASSERT(size % cfg->prog_size == 0);
|
||||
LFS3_ASSERT(off+size <= cfg->block_size);
|
||||
|
||||
// program data
|
||||
memcpy(&bd->buffer[block*cfg->block_size + off], buffer, size);
|
||||
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_prog -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs3_rambd_erase(const struct lfs3_config *cfg, lfs3_block_t block) {
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
|
||||
(void*)cfg, block, cfg->block_size);
|
||||
|
||||
// check if erase is valid
|
||||
LFS3_ASSERT(block < cfg->block_count);
|
||||
|
||||
// erase is a noop
|
||||
(void)block;
|
||||
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_erase -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs3_rambd_sync(const struct lfs3_config *cfg) {
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_sync(%p)", (void*)cfg);
|
||||
|
||||
// sync is a noop
|
||||
(void)cfg;
|
||||
|
||||
LFS3_RAMBD_TRACE("lfs3_rambd_sync -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
/*
|
||||
* Block device emulated in RAM
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* Copyright (c) 2017, Arm Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
#ifndef LFS3_RAMBD_H
|
||||
#define LFS3_RAMBD_H
|
||||
|
||||
#include "lfs3.h"
|
||||
#include "lfs3_util.h"
|
||||
|
||||
|
||||
// Block device specific tracing
|
||||
#ifndef LFS3_RAMBD_TRACE
|
||||
#ifdef LFS3_RAMBD_YES_TRACE
|
||||
#define LFS3_RAMBD_TRACE(...) LFS3_TRACE(__VA_ARGS__)
|
||||
#else
|
||||
#define LFS3_RAMBD_TRACE(...)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// rambd config (optional)
|
||||
struct lfs3_rambd_config {
|
||||
// Optional statically allocated buffer for the block device.
|
||||
void *buffer;
|
||||
};
|
||||
|
||||
// rambd state
|
||||
typedef struct lfs3_rambd {
|
||||
uint8_t *buffer;
|
||||
const struct lfs3_rambd_config *cfg;
|
||||
} lfs3_rambd_t;
|
||||
|
||||
|
||||
// Create a RAM block device using the geometry in lfs3_config
|
||||
int lfs3_rambd_create(const struct lfs3_config *cfg);
|
||||
int lfs3_rambd_createcfg(const struct lfs3_config *cfg,
|
||||
const struct lfs3_rambd_config *bdcfg);
|
||||
|
||||
// Clean up memory associated with block device
|
||||
int lfs3_rambd_destroy(const struct lfs3_config *cfg);
|
||||
|
||||
// Read a block
|
||||
int lfs3_rambd_read(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, void *buffer, lfs3_size_t size);
|
||||
|
||||
// Program a block
|
||||
//
|
||||
// The block must have previously been erased.
|
||||
int lfs3_rambd_prog(const struct lfs3_config *cfg, lfs3_block_t block,
|
||||
lfs3_off_t off, const void *buffer, lfs3_size_t size);
|
||||
|
||||
// Erase a block
|
||||
//
|
||||
// A block must be erased before being programmed. The
|
||||
// state of an erased block is undefined.
|
||||
int lfs3_rambd_erase(const struct lfs3_config *cfg, lfs3_block_t block);
|
||||
|
||||
// Sync the block device
|
||||
int lfs3_rambd_sync(const struct lfs3_config *cfg);
|
||||
|
||||
|
||||
#endif
|
||||
-262
@@ -1,262 +0,0 @@
|
||||
/*
|
||||
* Emulating block device, wraps filebd and rambd while providing a bunch
|
||||
* of hooks for testing littlefs in various conditions.
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* Copyright (c) 2017, Arm Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
#ifndef LFS_EMUBD_H
|
||||
#define LFS_EMUBD_H
|
||||
|
||||
#include "lfs.h"
|
||||
#include "lfs_util.h"
|
||||
#include "bd/lfs_rambd.h"
|
||||
#include "bd/lfs_filebd.h"
|
||||
|
||||
|
||||
// Block device specific tracing
|
||||
#ifndef LFS_EMUBD_TRACE
|
||||
#ifdef LFS_EMUBD_YES_TRACE
|
||||
#define LFS_EMUBD_TRACE(...) LFS_TRACE(__VA_ARGS__)
|
||||
#else
|
||||
#define LFS_EMUBD_TRACE(...)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Mode determining how "bad-blocks" behave during testing. This simulates
|
||||
// some real-world circumstances such as progs not sticking (prog-noop),
|
||||
// a readonly disk (erase-noop), ECC failures (read-error), and of course,
|
||||
// random bit failures (prog-flip, read-flip)
|
||||
typedef enum lfs_emubd_badblock_behavior {
|
||||
LFS_EMUBD_BADBLOCK_PROGERROR = 0, // Error on prog
|
||||
LFS_EMUBD_BADBLOCK_ERASEERROR = 1, // Error on erase
|
||||
LFS_EMUBD_BADBLOCK_READERROR = 2, // Error on read
|
||||
LFS_EMUBD_BADBLOCK_PROGNOOP = 3, // Prog does nothing silently
|
||||
LFS_EMUBD_BADBLOCK_ERASENOOP = 4, // Erase does nothing silently
|
||||
LFS_EMUBD_BADBLOCK_PROGFLIP = 5, // Prog flips a bit
|
||||
LFS_EMUBD_BADBLOCK_READFLIP = 6, // Read flips a bit sometimes
|
||||
LFS_EMUBD_BADBLOCK_MANUAL = 7, // Bits require manual flipping
|
||||
} lfs_emubd_badblock_behavior_t;
|
||||
|
||||
// Mode determining how power-loss behaves during testing.
|
||||
typedef enum lfs_emubd_powerloss_behavior {
|
||||
LFS_EMUBD_POWERLOSS_ATOMIC = 0, // Progs are atomic
|
||||
LFS_EMUBD_POWERLOSS_SOMEBITS = 1, // One bit is progged
|
||||
LFS_EMUBD_POWERLOSS_MOSTBITS = 2, // All-but-one bit is progged
|
||||
LFS_EMUBD_POWERLOSS_OOO = 3, // Blocks are written out-of-order
|
||||
LFS_EMUBD_POWERLOSS_METASTABLE = 4, // Reads may flip a bit
|
||||
} lfs_emubd_powerloss_behavior_t;
|
||||
|
||||
// Type for measuring read/program/erase operations
|
||||
typedef uint64_t lfs_emubd_io_t;
|
||||
typedef int64_t lfs_emubd_sio_t;
|
||||
|
||||
// Type for measuring wear
|
||||
typedef uint32_t lfs_emubd_wear_t;
|
||||
typedef int32_t lfs_emubd_swear_t;
|
||||
|
||||
// Type for tracking power-cycles
|
||||
typedef uint32_t lfs_emubd_powercycles_t;
|
||||
typedef int32_t lfs_emubd_spowercycles_t;
|
||||
|
||||
// Type for delays in nanoseconds
|
||||
typedef uint64_t lfs_emubd_sleep_t;
|
||||
typedef int64_t lfs_emubd_ssleep_t;
|
||||
|
||||
// emubd config, this is required for testing
|
||||
struct lfs_emubd_config {
|
||||
// 8-bit erase value to use for simulating erases. -1 simulates a noop
|
||||
// erase, which is faster than simulating a fixed erase value.
|
||||
int32_t erase_value;
|
||||
|
||||
// Number of erase cycles before a block becomes "bad". The exact behavior
|
||||
// of bad blocks is controlled by badblock_behavior.
|
||||
uint32_t erase_cycles;
|
||||
|
||||
// The mode determining how bad-blocks fail
|
||||
lfs_emubd_badblock_behavior_t badblock_behavior;
|
||||
|
||||
// Number of write operations (erase/prog) before triggering a power-loss.
|
||||
// power_cycles=0 disables this. The exact behavior of power-loss is
|
||||
// controlled by a combination of powerloss_behavior and powerloss_cb.
|
||||
lfs_emubd_powercycles_t power_cycles;
|
||||
|
||||
// The mode determining how power-loss affects disk
|
||||
lfs_emubd_powerloss_behavior_t powerloss_behavior;
|
||||
|
||||
// Function to call to emulate power-loss. The exact behavior of power-loss
|
||||
// is up to the runner to provide.
|
||||
void (*powerloss_cb)(void*);
|
||||
|
||||
// Data for power-loss callback
|
||||
void *powerloss_data;
|
||||
|
||||
// Seed for prng, which may be used for emulating failed progs. This does
|
||||
// not affect normal operation.
|
||||
uint32_t seed;
|
||||
|
||||
// Path to file to use as a mirror of the disk. This provides a way to view
|
||||
// the current state of the block device.
|
||||
const char *disk_path;
|
||||
|
||||
// Artificial delay in nanoseconds, there is no purpose for this other
|
||||
// than slowing down the simulation.
|
||||
lfs_emubd_sleep_t read_sleep;
|
||||
|
||||
// Artificial delay in nanoseconds, there is no purpose for this other
|
||||
// than slowing down the simulation.
|
||||
lfs_emubd_sleep_t prog_sleep;
|
||||
|
||||
// Artificial delay in nanoseconds, there is no purpose for this other
|
||||
// than slowing down the simulation.
|
||||
lfs_emubd_sleep_t erase_sleep;
|
||||
};
|
||||
|
||||
// A reference counted block
|
||||
typedef struct lfs_emubd_block {
|
||||
uint32_t rc;
|
||||
lfs_emubd_wear_t wear;
|
||||
bool metastable;
|
||||
// sign(bad_bit)=0 => randomized on erase
|
||||
// sign(bad_bit)=1 => fixed
|
||||
lfs_size_t bad_bit;
|
||||
|
||||
uint8_t data[];
|
||||
} lfs_emubd_block_t;
|
||||
|
||||
// Disk mirror
|
||||
typedef struct lfs_emubd_disk {
|
||||
uint32_t rc;
|
||||
int fd;
|
||||
uint8_t *scratch;
|
||||
} lfs_emubd_disk_t;
|
||||
|
||||
// emubd state
|
||||
typedef struct lfs_emubd {
|
||||
// array of copy-on-write blocks
|
||||
lfs_emubd_block_t **blocks;
|
||||
|
||||
// some other test state
|
||||
lfs_emubd_io_t readed;
|
||||
lfs_emubd_io_t proged;
|
||||
lfs_emubd_io_t erased;
|
||||
uint32_t prng;
|
||||
lfs_emubd_powercycles_t power_cycles;
|
||||
lfs_emubd_block_t **ooo_before;
|
||||
lfs_emubd_block_t **ooo_after;
|
||||
lfs_emubd_disk_t *disk;
|
||||
|
||||
const struct lfs_emubd_config *cfg;
|
||||
} lfs_emubd_t;
|
||||
|
||||
|
||||
/// Block device API ///
|
||||
|
||||
// Create an emulating block device using the geometry in lfs_config
|
||||
//
|
||||
// Note that filebd is used if a path is provided, if path is NULL
|
||||
// emubd will use rambd which can be much faster.
|
||||
int lfs_emubd_create(const struct lfs_config *cfg, const char *path);
|
||||
int lfs_emubd_createcfg(const struct lfs_config *cfg, const char *path,
|
||||
const struct lfs_emubd_config *bdcfg);
|
||||
|
||||
// Clean up memory associated with block device
|
||||
int lfs_emubd_destroy(const struct lfs_config *cfg);
|
||||
|
||||
// Read a block
|
||||
int lfs_emubd_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_emubd_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_emubd_erase(const struct lfs_config *cfg, lfs_block_t block);
|
||||
|
||||
// Sync the block device
|
||||
int lfs_emubd_sync(const struct lfs_config *cfg);
|
||||
|
||||
|
||||
/// Additional extended API for driving test features ///
|
||||
|
||||
// Set the current prng state
|
||||
void lfs_emubd_seed(const struct lfs_config *cfg, uint32_t seed);
|
||||
|
||||
// Get a pseudo-random number from emubd's internal prng
|
||||
uint32_t lfs_emubd_prng(const struct lfs_config *cfg);
|
||||
|
||||
// Get total amount of bytes read
|
||||
lfs_emubd_sio_t lfs_emubd_readed(const struct lfs_config *cfg);
|
||||
|
||||
// Get total amount of bytes programmed
|
||||
lfs_emubd_sio_t lfs_emubd_proged(const struct lfs_config *cfg);
|
||||
|
||||
// Get total amount of bytes erased
|
||||
lfs_emubd_sio_t lfs_emubd_erased(const struct lfs_config *cfg);
|
||||
|
||||
// Manually set amount of bytes read
|
||||
int lfs_emubd_setreaded(const struct lfs_config *cfg, lfs_emubd_io_t readed);
|
||||
|
||||
// Manually set amount of bytes programmed
|
||||
int lfs_emubd_setproged(const struct lfs_config *cfg, lfs_emubd_io_t proged);
|
||||
|
||||
// Manually set amount of bytes erased
|
||||
int lfs_emubd_seterased(const struct lfs_config *cfg, lfs_emubd_io_t erased);
|
||||
|
||||
// Get simulated wear on a given block
|
||||
lfs_emubd_swear_t lfs_emubd_wear(const struct lfs_config *cfg,
|
||||
lfs_block_t block);
|
||||
|
||||
// Manually set simulated wear on a given block
|
||||
int lfs_emubd_setwear(const struct lfs_config *cfg,
|
||||
lfs_block_t block, lfs_emubd_wear_t wear);
|
||||
|
||||
// Mark a block as bad, this is equivalent to setting wear to maximum
|
||||
int lfs_emubd_markbad(const struct lfs_config *cfg, lfs_block_t block);
|
||||
|
||||
// Clear any simulated wear on a given block
|
||||
int lfs_emubd_markgood(const struct lfs_config *cfg, lfs_block_t block);
|
||||
|
||||
// Get which bit failed, this changes on erase/power-loss unless manually set
|
||||
lfs_ssize_t lfs_emubd_badbit(const struct lfs_config *cfg,
|
||||
lfs_block_t block);
|
||||
|
||||
// Set which bit should fail in a given block
|
||||
int lfs_emubd_setbadbit(const struct lfs_config *cfg,
|
||||
lfs_block_t block, lfs_size_t bit);
|
||||
|
||||
// Randomize the bad bit on erase (the default)
|
||||
int lfs_emubd_randomizebadbit(const struct lfs_config *cfg,
|
||||
lfs_block_t block);
|
||||
|
||||
// Mark a block as bad and which bit should fail
|
||||
int lfs_emubd_markbadbit(const struct lfs_config *cfg,
|
||||
lfs_block_t block, lfs_size_t bit);
|
||||
|
||||
// Flip a bit in a given block, intended for emulating bit errors
|
||||
int lfs_emubd_flipbit(const struct lfs_config *cfg,
|
||||
lfs_block_t block, lfs_size_t bit);
|
||||
|
||||
// Flip all bits marked as bad
|
||||
int lfs_emubd_flip(const struct lfs_config *cfg);
|
||||
|
||||
// Get the remaining power-cycles
|
||||
lfs_emubd_spowercycles_t lfs_emubd_powercycles(
|
||||
const struct lfs_config *cfg);
|
||||
|
||||
// Manually set the remaining power-cycles
|
||||
int lfs_emubd_setpowercycles(const struct lfs_config *cfg,
|
||||
lfs_emubd_powercycles_t power_cycles);
|
||||
|
||||
// Create a copy-on-write copy of the state of this block device
|
||||
int lfs_emubd_cpy(const struct lfs_config *cfg, lfs_emubd_t *copy);
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,56 +0,0 @@
|
||||
/*
|
||||
* Block device emulated in a file
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* 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"
|
||||
|
||||
|
||||
// Block device specific tracing
|
||||
#ifndef LFS_FILEBD_TRACE
|
||||
#ifdef LFS_FILEBD_YES_TRACE
|
||||
#define LFS_FILEBD_TRACE(...) LFS_TRACE(__VA_ARGS__)
|
||||
#else
|
||||
#define LFS_FILEBD_TRACE(...)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// filebd state
|
||||
typedef struct lfs_filebd {
|
||||
int fd;
|
||||
} 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);
|
||||
|
||||
// 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);
|
||||
|
||||
|
||||
#endif
|
||||
-131
@@ -1,131 +0,0 @@
|
||||
/*
|
||||
* Block device emulated in RAM
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* 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_RAMBD_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 {.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->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_RAMBD_TRACE("lfs_rambd_createcfg -> %d", LFS_ERR_NOMEM);
|
||||
return LFS_ERR_NOMEM;
|
||||
}
|
||||
}
|
||||
|
||||
// zero for reproducibility
|
||||
memset(bd->buffer, 0, cfg->block_size * cfg->block_count);
|
||||
|
||||
LFS_RAMBD_TRACE("lfs_rambd_createcfg -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_rambd_create(const struct lfs_config *cfg) {
|
||||
LFS_RAMBD_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 = {0};
|
||||
int err = lfs_rambd_createcfg(cfg, &defaults);
|
||||
LFS_RAMBD_TRACE("lfs_rambd_create -> %d", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
int lfs_rambd_destroy(const struct lfs_config *cfg) {
|
||||
LFS_RAMBD_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_RAMBD_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_RAMBD_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(block < cfg->block_count);
|
||||
LFS_ASSERT(off % cfg->read_size == 0);
|
||||
LFS_ASSERT(size % cfg->read_size == 0);
|
||||
LFS_ASSERT(off+size <= cfg->block_size);
|
||||
|
||||
// read data
|
||||
memcpy(buffer, &bd->buffer[block*cfg->block_size + off], size);
|
||||
|
||||
LFS_RAMBD_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_RAMBD_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(block < cfg->block_count);
|
||||
LFS_ASSERT(off % cfg->prog_size == 0);
|
||||
LFS_ASSERT(size % cfg->prog_size == 0);
|
||||
LFS_ASSERT(off+size <= cfg->block_size);
|
||||
|
||||
// program data
|
||||
memcpy(&bd->buffer[block*cfg->block_size + off], buffer, size);
|
||||
|
||||
LFS_RAMBD_TRACE("lfs_rambd_prog -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_rambd_erase(const struct lfs_config *cfg, lfs_block_t block) {
|
||||
LFS_RAMBD_TRACE("lfs_rambd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
|
||||
(void*)cfg, block, cfg->block_size);
|
||||
|
||||
// check if erase is valid
|
||||
LFS_ASSERT(block < cfg->block_count);
|
||||
|
||||
// erase is a noop
|
||||
(void)block;
|
||||
|
||||
LFS_RAMBD_TRACE("lfs_rambd_erase -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_rambd_sync(const struct lfs_config *cfg) {
|
||||
LFS_RAMBD_TRACE("lfs_rambd_sync(%p)", (void*)cfg);
|
||||
|
||||
// sync is a noop
|
||||
(void)cfg;
|
||||
|
||||
LFS_RAMBD_TRACE("lfs_rambd_sync -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
/*
|
||||
* Block device emulated in RAM
|
||||
*
|
||||
* Copyright (c) 2022, The littlefs authors.
|
||||
* 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"
|
||||
|
||||
|
||||
// Block device specific tracing
|
||||
#ifndef LFS_RAMBD_TRACE
|
||||
#ifdef LFS_RAMBD_YES_TRACE
|
||||
#define LFS_RAMBD_TRACE(...) LFS_TRACE(__VA_ARGS__)
|
||||
#else
|
||||
#define LFS_RAMBD_TRACE(...)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// rambd config (optional)
|
||||
struct lfs_rambd_config {
|
||||
// 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);
|
||||
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user