github-mirrors/thirdparty-littlefs
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-littlefs.git synced 2025-11-01 00:38:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Changed callbacks to take user-provided context directly

Browse Source 
This is a style change to make littlefs's callbacks consistent with most
callback declarations found in C. That is, taking in a user-provided
`void*`.

Previously, these callbacks took a pointer to the config struct itself,
which indirectly contained a user provided context, and this gets the
job done, but taking in a callback with a `void*` is arguably more
expected, has a better chance of integrating with C++/OS-specific code,
and is more likely to be optimized out by a clever compiler.

---

As a part of these changes, the geometry for the test bds needed to be
moved into bd specific configuration objects. This is a good change as
it also allows for testing situations where littlefs's geometry does not
match the underlying bd.
This commit is contained in:
Christopher Haster
2020-11-26 09:16:20 -06:00
parent a549413077
commit a7cdd563f6
15 changed files with 383 additions and 397 deletions
Download Patch File Download Diff File Expand all files Collapse all files

204
bd/lfs_testbd.c
View File

@@ -10,185 +10,164 @@
#include <stdlib.h>
int lfs_testbd_createcfg(const struct lfs_cfg *cfg, const char *path,
const struct lfs_testbd_cfg *bdcfg) {
LFS_TESTBD_TRACE("lfs_testbd_createcfg(%p {.context=%p, "
".read=%p, .prog=%p, .erase=%p, .sync=%p, "
int lfs_testbd_createcfg(lfs_testbd_t *bd, const char *path,
const struct lfs_testbd_cfg *cfg) {
LFS_TESTBD_TRACE("lfs_testbd_createcfg(%p, \"%s\", %p {"
".read_size=%"PRIu32", .prog_size=%"PRIu32", "
".block_size=%"PRIu32", .block_count=%"PRIu32"}, "
"\"%s\", "
"%p {.erase_value=%"PRId32", .erase_cycles=%"PRIu32", "
".erase_size=%"PRIu32", .erase_count=%"PRIu32", "
".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;
(void*)bd, path, (void*)cfg,
cfg->read_size, cfg->prog_size, cfg->erase_size, cfg->erase_count,
cfg->erase_value, cfg->erase_cycles,
cfg->badblock_behavior, cfg->power_cycles,
cfg->buffer, cfg->wear_buffer);
// copy over config
bd->cfg = *cfg;
// setup testing things
bd->persist = path;
bd->power_cycles = bd->cfg->power_cycles;
bd->power_cycles = bd->cfg.power_cycles;
if (bd->cfg->erase_cycles) {
if (bd->cfg->wear_buffer) {
bd->wear = bd->cfg->wear_buffer;
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);
bd->wear = lfs_malloc(sizeof(lfs_testbd_wear_t)*cfg->erase_count);
if (!bd->wear) {
LFS_TESTBD_TRACE("lfs_testbd_createcfg -> %d", LFS_ERR_NOMEM);
return LFS_ERR_NOMEM;
}
}
memset(bd->wear, 0, sizeof(lfs_testbd_wear_t) * cfg->block_count);
memset(bd->wear, 0, sizeof(lfs_testbd_wear_t) * bd->cfg.erase_count);
}
// create underlying block device
if (bd->persist) {
bd->u.file.cfg = (struct lfs_filebd_cfg){
.erase_value = bd->cfg->erase_value,
};
int err = lfs_filebd_createcfg(cfg, path, &bd->u.file.cfg);
int err = lfs_filebd_createcfg(&bd->impl.filebd, path,
&(struct lfs_filebd_cfg){
.read_size=bd->cfg.read_size,
.prog_size=bd->cfg.prog_size,
.erase_size=bd->cfg.erase_size,
.erase_count=bd->cfg.erase_count,
.erase_value=bd->cfg.erase_value});
LFS_TESTBD_TRACE("lfs_testbd_createcfg -> %d", err);
return err;
} else {
bd->u.ram.cfg = (struct lfs_rambd_cfg){
.erase_value = bd->cfg->erase_value,
.buffer = bd->cfg->buffer,
};
int err = lfs_rambd_createcfg(cfg, &bd->u.ram.cfg);
int err = lfs_rambd_createcfg(&bd->impl.rambd,
&(struct lfs_rambd_cfg){
.read_size=bd->cfg.read_size,
.prog_size=bd->cfg.prog_size,
.erase_size=bd->cfg.erase_size,
.erase_count=bd->cfg.erase_count,
.erase_value=bd->cfg.erase_value,
.buffer=bd->cfg.buffer});
LFS_TESTBD_TRACE("lfs_testbd_createcfg -> %d", err);
return err;
}
}
int lfs_testbd_create(const struct lfs_cfg *cfg, const char *path) {
LFS_TESTBD_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_cfg defaults = {.erase_value=-1};
int err = lfs_testbd_createcfg(cfg, path, &defaults);
LFS_TESTBD_TRACE("lfs_testbd_create -> %d", err);
return err;
}
int lfs_testbd_destroy(const struct lfs_cfg *cfg) {
LFS_TESTBD_TRACE("lfs_testbd_destroy(%p)", (void*)cfg);
lfs_testbd_t *bd = cfg->context;
if (bd->cfg->erase_cycles && !bd->cfg->wear_buffer) {
int lfs_testbd_destroy(lfs_testbd_t *bd) {
LFS_TESTBD_TRACE("lfs_testbd_destroy(%p)", (void*)bd);
if (bd->cfg.erase_cycles && !bd->cfg.wear_buffer) {
lfs_free(bd->wear);
}
if (bd->persist) {
int err = lfs_filebd_destroy(cfg);
int err = lfs_filebd_destroy(&bd->impl.filebd);
LFS_TESTBD_TRACE("lfs_testbd_destroy -> %d", err);
return err;
} else {
int err = lfs_rambd_destroy(cfg);
int err = lfs_rambd_destroy(&bd->impl.rambd);
LFS_TESTBD_TRACE("lfs_testbd_destroy -> %d", err);
return err;
}
}
/// Internal mapping to block devices ///
static int lfs_testbd_rawread(const struct lfs_cfg *cfg, lfs_block_t block,
static int lfs_testbd_rawread(lfs_testbd_t *bd, 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);
return lfs_filebd_read(&bd->impl.filebd, block, off, buffer, size);
} else {
return lfs_rambd_read(cfg, block, off, buffer, size);
return lfs_rambd_read(&bd->impl.rambd, block, off, buffer, size);
}
}
static int lfs_testbd_rawprog(const struct lfs_cfg *cfg, lfs_block_t block,
static int lfs_testbd_rawprog(lfs_testbd_t *bd, 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);
return lfs_filebd_prog(&bd->impl.filebd, block, off, buffer, size);
} else {
return lfs_rambd_prog(cfg, block, off, buffer, size);
return lfs_rambd_prog(&bd->impl.rambd, block, off, buffer, size);
}
}
static int lfs_testbd_rawerase(const struct lfs_cfg *cfg,
static int lfs_testbd_rawerase(lfs_testbd_t *bd,
lfs_block_t block) {
lfs_testbd_t *bd = cfg->context;
if (bd->persist) {
return lfs_filebd_erase(cfg, block);
return lfs_filebd_erase(&bd->impl.filebd, block);
} else {
return lfs_rambd_erase(cfg, block);
return lfs_rambd_erase(&bd->impl.rambd, block);
}
}
static int lfs_testbd_rawsync(const struct lfs_cfg *cfg) {
lfs_testbd_t *bd = cfg->context;
static int lfs_testbd_rawsync(lfs_testbd_t *bd) {
if (bd->persist) {
return lfs_filebd_sync(cfg);
return lfs_filebd_sync(&bd->impl.filebd);
} else {
return lfs_rambd_sync(cfg);
return lfs_rambd_sync(&bd->impl.rambd);
}
}
/// block device API ///
int lfs_testbd_read(const struct lfs_cfg *cfg, lfs_block_t block,
int lfs_testbd_read(lfs_testbd_t *bd, lfs_block_t block,
lfs_off_t off, void *buffer, lfs_size_t size) {
LFS_TESTBD_TRACE("lfs_testbd_read(%p, "
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
(void*)cfg, block, off, buffer, size);
lfs_testbd_t *bd = cfg->context;
(void*)bd, block, off, buffer, size);
// 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);
LFS_ASSERT(off % bd->cfg.read_size == 0);
LFS_ASSERT(size % bd->cfg.read_size == 0);
LFS_ASSERT(block < bd->cfg.erase_count);
// block bad?
if (bd->cfg->erase_cycles && bd->wear[block] >= bd->cfg->erase_cycles &&
bd->cfg->badblock_behavior == LFS_TESTBD_BADBLOCK_READERROR) {
if (bd->cfg.erase_cycles && bd->wear[block] >= bd->cfg.erase_cycles &&
bd->cfg.badblock_behavior == LFS_TESTBD_BADBLOCK_READERROR) {
LFS_TESTBD_TRACE("lfs_testbd_read -> %d", LFS_ERR_CORRUPT);
return LFS_ERR_CORRUPT;
}
// read
int err = lfs_testbd_rawread(cfg, block, off, buffer, size);
int err = lfs_testbd_rawread(bd, block, off, buffer, size);
LFS_TESTBD_TRACE("lfs_testbd_read -> %d", err);
return err;
}
int lfs_testbd_prog(const struct lfs_cfg *cfg, lfs_block_t block,
int lfs_testbd_prog(lfs_testbd_t *bd, lfs_block_t block,
lfs_off_t off, const void *buffer, lfs_size_t size) {
LFS_TESTBD_TRACE("lfs_testbd_prog(%p, "
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
(void*)cfg, block, off, buffer, size);
lfs_testbd_t *bd = cfg->context;
(void*)bd, block, off, buffer, size);
// 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);
LFS_ASSERT(off % bd->cfg.prog_size == 0);
LFS_ASSERT(size % bd->cfg.prog_size == 0);
LFS_ASSERT(block < bd->cfg.erase_count);
// block bad?
if (bd->cfg->erase_cycles && bd->wear[block] >= bd->cfg->erase_cycles) {
if (bd->cfg->badblock_behavior ==
if (bd->cfg.erase_cycles && bd->wear[block] >= bd->cfg.erase_cycles) {
if (bd->cfg.badblock_behavior ==
LFS_TESTBD_BADBLOCK_PROGERROR) {
LFS_TESTBD_TRACE("lfs_testbd_prog -> %d", LFS_ERR_CORRUPT);
return LFS_ERR_CORRUPT;
} else if (bd->cfg->badblock_behavior ==
} else if (bd->cfg.badblock_behavior ==
LFS_TESTBD_BADBLOCK_PROGNOOP ||
bd->cfg->badblock_behavior ==
bd->cfg.badblock_behavior ==
LFS_TESTBD_BADBLOCK_ERASENOOP) {
LFS_TESTBD_TRACE("lfs_testbd_prog -> %d", 0);
return 0;
@@ -196,7 +175,7 @@ int lfs_testbd_prog(const struct lfs_cfg *cfg, lfs_block_t block,
}
// prog
int err = lfs_testbd_rawprog(cfg, block, off, buffer, size);
int err = lfs_testbd_rawprog(bd, block, off, buffer, size);
if (err) {
LFS_TESTBD_TRACE("lfs_testbd_prog -> %d", err);
return err;
@@ -207,7 +186,7 @@ int lfs_testbd_prog(const struct lfs_cfg *cfg, lfs_block_t block,
bd->power_cycles -= 1;
if (bd->power_cycles == 0) {
// sync to make sure we persist the last changes
assert(lfs_testbd_rawsync(cfg) == 0);
assert(lfs_testbd_rawsync(bd) == 0);
// simulate power loss
exit(33);
}
@@ -217,21 +196,20 @@ int lfs_testbd_prog(const struct lfs_cfg *cfg, lfs_block_t block,
return 0;
}
int lfs_testbd_erase(const struct lfs_cfg *cfg, lfs_block_t block) {
LFS_TESTBD_TRACE("lfs_testbd_erase(%p, 0x%"PRIx32")", (void*)cfg, block);
lfs_testbd_t *bd = cfg->context;
int lfs_testbd_erase(lfs_testbd_t *bd, lfs_block_t block) {
LFS_TESTBD_TRACE("lfs_testbd_erase(%p, 0x%"PRIx32")", (void*)bd, block);
// check if erase is valid
LFS_ASSERT(block < cfg->block_count);
LFS_ASSERT(block < bd->cfg.erase_count);
// block bad?
if (bd->cfg->erase_cycles) {
if (bd->wear[block] >= bd->cfg->erase_cycles) {
if (bd->cfg->badblock_behavior ==
if (bd->cfg.erase_cycles) {
if (bd->wear[block] >= bd->cfg.erase_cycles) {
if (bd->cfg.badblock_behavior ==
LFS_TESTBD_BADBLOCK_ERASEERROR) {
LFS_TESTBD_TRACE("lfs_testbd_erase -> %d", LFS_ERR_CORRUPT);
return LFS_ERR_CORRUPT;
} else if (bd->cfg->badblock_behavior ==
} else if (bd->cfg.badblock_behavior ==
LFS_TESTBD_BADBLOCK_ERASENOOP) {
LFS_TESTBD_TRACE("lfs_testbd_erase -> %d", 0);
return 0;
@@ -243,7 +221,7 @@ int lfs_testbd_erase(const struct lfs_cfg *cfg, lfs_block_t block) {
}
// erase
int err = lfs_testbd_rawerase(cfg, block);
int err = lfs_testbd_rawerase(bd, block);
if (err) {
LFS_TESTBD_TRACE("lfs_testbd_erase -> %d", err);
return err;
@@ -254,7 +232,7 @@ int lfs_testbd_erase(const struct lfs_cfg *cfg, lfs_block_t block) {
bd->power_cycles -= 1;
if (bd->power_cycles == 0) {
// sync to make sure we persist the last changes
assert(lfs_testbd_rawsync(cfg) == 0);
assert(lfs_testbd_rawsync(bd) == 0);
// simulate power loss
exit(33);
}
@@ -264,36 +242,34 @@ int lfs_testbd_erase(const struct lfs_cfg *cfg, lfs_block_t block) {
return 0;
}
int lfs_testbd_sync(const struct lfs_cfg *cfg) {
LFS_TESTBD_TRACE("lfs_testbd_sync(%p)", (void*)cfg);
int err = lfs_testbd_rawsync(cfg);
int lfs_testbd_sync(lfs_testbd_t *bd) {
LFS_TESTBD_TRACE("lfs_testbd_sync(%p)", (void*)bd);
int err = lfs_testbd_rawsync(bd);
LFS_TESTBD_TRACE("lfs_testbd_sync -> %d", err);
return err;
}
/// simulated wear operations ///
lfs_testbd_swear_t lfs_testbd_getwear(const struct lfs_cfg *cfg,
lfs_testbd_swear_t lfs_testbd_getwear(lfs_testbd_t *bd,
lfs_block_t block) {
LFS_TESTBD_TRACE("lfs_testbd_getwear(%p, %"PRIu32")", (void*)cfg, block);
lfs_testbd_t *bd = cfg->context;
LFS_TESTBD_TRACE("lfs_testbd_getwear(%p, %"PRIu32")", (void*)bd, block);
// check if block is valid
LFS_ASSERT(bd->cfg->erase_cycles);
LFS_ASSERT(block < cfg->block_count);
LFS_ASSERT(bd->cfg.erase_cycles);
LFS_ASSERT(block < bd->cfg.erase_count);
LFS_TESTBD_TRACE("lfs_testbd_getwear -> %"PRIu32, bd->wear[block]);
return bd->wear[block];
}
int lfs_testbd_setwear(const struct lfs_cfg *cfg,
int lfs_testbd_setwear(lfs_testbd_t *bd,
lfs_block_t block, lfs_testbd_wear_t wear) {
LFS_TESTBD_TRACE("lfs_testbd_setwear(%p, %"PRIu32")", (void*)cfg, block);
lfs_testbd_t *bd = cfg->context;
LFS_TESTBD_TRACE("lfs_testbd_setwear(%p, %"PRIu32")", (void*)bd, block);
// check if block is valid
LFS_ASSERT(bd->cfg->erase_cycles);
LFS_ASSERT(block < cfg->block_count);
LFS_ASSERT(bd->cfg.erase_cycles);
LFS_ASSERT(block < bd->cfg.erase_count);
bd->wear[block] = wear;