Imagelibrary/littlefs
1
0
Fork 1
mirror of https://github.com/littlefs-project/littlefs.git synced 2025-11-16 12:34:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Changed bd callbacks to use "bd_" prefix

Browse Source 
This makes the block-device related operations more clearly block-device
related operations, and helps avoid possible conflicts with user
provided `lfs_bd_read/prog/erase` functions in the LFS_STATICCFG mode.
This commit is contained in:
Christopher Haster
2020-11-26 13:51:32 -06:00
parent 30ed816feb
commit 190eb833a2
3 changed files with 81 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
lfs.c
View File

@@ -10,14 +10,14 @@
/// Configuration mapping ///
#ifdef LFS_STATICCFG
// direct config towards user defines
#define LFS_CFG_READ(lfs, block, off, buffer, size) \
((void)lfs, lfs_read(block, off, buffer, size))
#define LFS_CFG_PROG(lfs, block, off, buffer, size) \
((void)lfs, lfs_prog(block, off, buffer, size))
#define LFS_CFG_ERASE(lfs, block) \
((void)lfs, lfs_erase(block))
#define LFS_CFG_SYNC(lfs) \
((void)lfs, lfs_sync())
#define LFS_CFG_BD_READ(lfs, block, off, buffer, size) \
((void)lfs, lfs_bd_read(block, off, buffer, size))
#define LFS_CFG_BD_PROG(lfs, block, off, buffer, size) \
((void)lfs, lfs_bd_prog(block, off, buffer, size))
#define LFS_CFG_BD_ERASE(lfs, block) \
((void)lfs, lfs_bd_erase(block))
#define LFS_CFG_BD_SYNC(lfs) \
((void)lfs, lfs_bd_sync())
#define LFS_CFG_READ_SIZE(lfs) ((void)lfs, LFS_READ_SIZE)
#define LFS_CFG_PROG_SIZE(lfs) ((void)lfs, LFS_PROG_SIZE)
#define LFS_CFG_BLOCK_SIZE(lfs) ((void)lfs, LFS_BLOCK_SIZE)
@@ -33,14 +33,14 @@
#define LFS_CFG_ATTR_MAX(lfs) ((void)lfs, LFS_ATTR_MAX)
#else
// direct config towards dynamic lfs_cfg struct
#define LFS_CFG_READ(lfs, block, off, buffer, size) \
lfs->cfg->read(lfs->cfg->ctx, block, off, buffer, size)
#define LFS_CFG_PROG(lfs, block, off, buffer, size) \
lfs->cfg->prog(lfs->cfg->ctx, block, off, buffer, size)
#define LFS_CFG_ERASE(lfs, block) \
lfs->cfg->erase(lfs->cfg->ctx, block)
#define LFS_CFG_SYNC(lfs) \
lfs->cfg->sync(lfs->cfg->ctx)
#define LFS_CFG_BD_READ(lfs, block, off, buffer, size) \
lfs->cfg->bd_read(lfs->cfg->bd_ctx, block, off, buffer, size)
#define LFS_CFG_BD_PROG(lfs, block, off, buffer, size) \
lfs->cfg->bd_prog(lfs->cfg->bd_ctx, block, off, buffer, size)
#define LFS_CFG_BD_ERASE(lfs, block) \
lfs->cfg->bd_erase(lfs->cfg->bd_ctx, block)
#define LFS_CFG_BD_SYNC(lfs) \
lfs->cfg->bd_sync(lfs->cfg->bd_ctx)
#define LFS_CFG_READ_SIZE(lfs) lfs->cfg->read_size
#define LFS_CFG_PROG_SIZE(lfs) lfs->cfg->prog_size
#define LFS_CFG_BLOCK_SIZE(lfs) lfs->cfg->block_size
@@ -87,7 +87,7 @@ static inline void lfs_cache_zero(lfs_t *lfs, lfs_cache_t *pcache) {
pcache->block = LFS_BLOCK_NULL;
}
static int lfs_bd_read(lfs_t *lfs,
static int lfs_cache_read(lfs_t *lfs,
const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
lfs_block_t block, lfs_off_t off,
void *buffer, lfs_size_t size) {
@@ -138,7 +138,7 @@ static int lfs_bd_read(lfs_t *lfs,
size >= LFS_CFG_READ_SIZE(lfs)) {
// bypass cache?
diff = lfs_aligndown(diff, LFS_CFG_READ_SIZE(lfs));
int err = LFS_CFG_READ(lfs, block, off, data, diff);
int err = LFS_CFG_BD_READ(lfs, block, off, data, diff);
if (err) {
return err;
}
@@ -159,7 +159,7 @@ static int lfs_bd_read(lfs_t *lfs,
LFS_CFG_BLOCK_SIZE(lfs))
- rcache->off,
LFS_CFG_CACHE_SIZE(lfs));
int err = LFS_CFG_READ(lfs, rcache->block,
int err = LFS_CFG_BD_READ(lfs, rcache->block,
rcache->off, rcache->buffer, rcache->size);
LFS_ASSERT(err <= 0);
if (err) {
@@ -176,7 +176,7 @@ enum {
LFS_CMP_GT = 2,
};
static int lfs_bd_cmp(lfs_t *lfs,
static int lfs_cache_cmp(lfs_t *lfs,
const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
lfs_block_t block, lfs_off_t off,
const void *buffer, lfs_size_t size) {
@@ -184,7 +184,7 @@ static int lfs_bd_cmp(lfs_t *lfs,
for (lfs_off_t i = 0; i < size; i++) {
uint8_t dat;
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
pcache, rcache, hint-i,
block, off+i, &dat, 1);
if (err) {
@@ -199,12 +199,12 @@ static int lfs_bd_cmp(lfs_t *lfs,
return LFS_CMP_EQ;
}
static int lfs_bd_flush(lfs_t *lfs,
static int lfs_cache_flush(lfs_t *lfs,
lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate) {
if (pcache->block != LFS_BLOCK_NULL && pcache->block != LFS_BLOCK_INLINE) {
LFS_ASSERT(pcache->block < LFS_CFG_BLOCK_COUNT(lfs));
lfs_size_t diff = lfs_alignup(pcache->size, LFS_CFG_PROG_SIZE(lfs));
int err = LFS_CFG_PROG(lfs, pcache->block,
int err = LFS_CFG_BD_PROG(lfs, pcache->block,
pcache->off, pcache->buffer, diff);
LFS_ASSERT(err <= 0);
if (err) {
@@ -214,7 +214,7 @@ static int lfs_bd_flush(lfs_t *lfs,
if (validate) {
// check data on disk
lfs_cache_drop(lfs, rcache);
int res = lfs_bd_cmp(lfs,
int res = lfs_cache_cmp(lfs,
NULL, rcache, diff,
pcache->block, pcache->off, pcache->buffer, diff);
if (res < 0) {
@@ -232,21 +232,21 @@ static int lfs_bd_flush(lfs_t *lfs,
return 0;
}
static int lfs_bd_sync(lfs_t *lfs,
static int lfs_cache_sync(lfs_t *lfs,
lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate) {
lfs_cache_drop(lfs, rcache);
int err = lfs_bd_flush(lfs, pcache, rcache, validate);
int err = lfs_cache_flush(lfs, pcache, rcache, validate);
if (err) {
return err;
}
err = LFS_CFG_SYNC(lfs);
err = LFS_CFG_BD_SYNC(lfs);
LFS_ASSERT(err <= 0);
return err;
}
static int lfs_bd_prog(lfs_t *lfs,
static int lfs_cache_prog(lfs_t *lfs,
lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate,
lfs_block_t block, lfs_off_t off,
const void *buffer, lfs_size_t size) {
@@ -270,7 +270,7 @@ static int lfs_bd_prog(lfs_t *lfs,
pcache->size = lfs_max(pcache->size, off - pcache->off);
if (pcache->size == LFS_CFG_CACHE_SIZE(lfs)) {
// eagerly flush out pcache if we fill up
int err = lfs_bd_flush(lfs, pcache, rcache, validate);
int err = lfs_cache_flush(lfs, pcache, rcache, validate);
if (err) {
return err;
}
@@ -292,9 +292,9 @@ static int lfs_bd_prog(lfs_t *lfs,
return 0;
}
static int lfs_bd_erase(lfs_t *lfs, lfs_block_t block) {
static int lfs_cache_erase(lfs_t *lfs, lfs_block_t block) {
LFS_ASSERT(block < LFS_CFG_BLOCK_COUNT(lfs));
int err = LFS_CFG_ERASE(lfs, block);
int err = LFS_CFG_BD_ERASE(lfs, block);
LFS_ASSERT(err <= 0);
return err;
}
@@ -593,7 +593,7 @@ static lfs_stag_t lfs_dir_getslice(lfs_t *lfs, const lfs_mdir_t *dir,
while (off >= sizeof(lfs_tag_t) + lfs_tag_dsize(ntag)) {
off -= lfs_tag_dsize(ntag);
lfs_tag_t tag = ntag;
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &lfs->rcache, sizeof(ntag),
dir->pair[0], off, &ntag, sizeof(ntag));
if (err) {
@@ -621,7 +621,7 @@ static lfs_stag_t lfs_dir_getslice(lfs_t *lfs, const lfs_mdir_t *dir,
}
lfs_size_t diff = lfs_min(lfs_tag_size(tag), gsize);
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, diff,
dir->pair[0], off+sizeof(tag)+goff, gbuffer, diff);
if (err) {
@@ -746,7 +746,7 @@ static int lfs_dir_traverse(lfs_t *lfs,
struct lfs_diskoff disk;
if (off+lfs_tag_dsize(ptag) < dir->off) {
off += lfs_tag_dsize(ptag);
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &lfs->rcache, sizeof(tag),
dir->pair[0], off, &tag, sizeof(tag));
if (err) {
@@ -846,7 +846,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
uint32_t revs[2] = {0, 0};
int r = 0;
for (int i = 0; i < 2; i++) {
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &lfs->rcache, sizeof(revs[i]),
pair[i], 0, &revs[i], sizeof(revs[i]));
revs[i] = lfs_fromle32(revs[i]);
@@ -883,7 +883,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
// extract next tag
lfs_tag_t tag;
off += lfs_tag_dsize(ptag);
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &lfs->rcache, LFS_CFG_BLOCK_SIZE(lfs),
dir->pair[0], off, &tag, sizeof(tag));
if (err) {
@@ -913,7 +913,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
if (lfs_tag_type1(tag) == LFS_TYPE_CRC) {
// check the crc attr
uint32_t dcrc;
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, LFS_CFG_BLOCK_SIZE(lfs),
dir->pair[0], off+sizeof(tag), &dcrc, sizeof(dcrc));
if (err) {
@@ -954,7 +954,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
// crc the entry first, hopefully leaving it in the cache
for (lfs_off_t j = sizeof(tag); j < lfs_tag_dsize(tag); j++) {
uint8_t dat;
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, LFS_CFG_BLOCK_SIZE(lfs),
dir->pair[0], off+j, &dat, 1);
if (err) {
@@ -987,7 +987,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
} else if (lfs_tag_type1(tag) == LFS_TYPE_TAIL) {
tempsplit = (lfs_tag_chunk(tag) & 1);
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, LFS_CFG_BLOCK_SIZE(lfs),
dir->pair[0], off+sizeof(tag), &temptail, 8);
if (err) {
@@ -1137,7 +1137,7 @@ static int lfs_dir_find_match(void *data,
// compare with disk
lfs_size_t diff = lfs_min(name->size, lfs_tag_size(tag));
int res = lfs_bd_cmp(lfs,
int res = lfs_cache_cmp(lfs,
NULL, &lfs->rcache, diff,
disk->block, disk->off, name->name, diff);
if (res != LFS_CMP_EQ) {
@@ -1266,7 +1266,7 @@ struct lfs_commit {
static int lfs_dir_commitprog(lfs_t *lfs, struct lfs_commit *commit,
const void *buffer, lfs_size_t size) {
int err = lfs_bd_prog(lfs,
int err = lfs_cache_prog(lfs,
&lfs->pcache, &lfs->rcache, false,
commit->block, commit->off ,
(const uint8_t*)buffer, size);
@@ -1306,7 +1306,7 @@ static int lfs_dir_commitattr(lfs_t *lfs, struct lfs_commit *commit,
for (lfs_off_t i = 0; i < dsize-sizeof(tag); i++) {
// rely on caching to make this efficient
uint8_t dat;
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, dsize-sizeof(tag)-i,
disk->block, disk->off+i, &dat, 1);
if (err) {
@@ -1343,7 +1343,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
// read erased state from next program unit
lfs_tag_t tag = 0xffffffff;
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &lfs->rcache, sizeof(tag),
commit->block, noff, &tag, sizeof(tag));
if (err && err != LFS_ERR_CORRUPT) {
@@ -1359,7 +1359,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
footer[0] = lfs_tobe32(tag ^ commit->ptag);
commit->crc = lfs_crc(commit->crc, &footer[0], sizeof(footer[0]));
footer[1] = lfs_tole32(commit->crc);
err = lfs_bd_prog(lfs,
err = lfs_cache_prog(lfs,
&lfs->pcache, &lfs->rcache, false,
commit->block, commit->off, &footer, sizeof(footer));
if (err) {
@@ -1372,7 +1372,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
}
// flush buffers
int err = lfs_bd_sync(lfs, &lfs->pcache, &lfs->rcache, false);
int err = lfs_cache_sync(lfs, &lfs->pcache, &lfs->rcache, false);
if (err) {
return err;
}
@@ -1391,7 +1391,7 @@ static int lfs_dir_commitcrc(lfs_t *lfs, struct lfs_commit *commit) {
// leave it up to caching to make this efficient
uint8_t dat;
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, noff+sizeof(uint32_t)-i,
commit->block, i, &dat, 1);
if (err) {
@@ -1431,7 +1431,7 @@ static int lfs_dir_alloc(lfs_t *lfs, lfs_mdir_t *dir) {
// rather than clobbering one of the blocks we just pretend
// the revision may be valid
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &lfs->rcache, sizeof(dir->rev),
dir->pair[0], 0, &dir->rev, sizeof(dir->rev));
dir->rev = lfs_fromle32(dir->rev);
@@ -1641,7 +1641,7 @@ static int lfs_dir_compact(lfs_t *lfs,
};
// erase block to write to
int err = lfs_bd_erase(lfs, dir->pair[1]);
int err = lfs_cache_erase(lfs, dir->pair[1]);
if (err) {
if (err == LFS_ERR_CORRUPT) {
goto relocate;
@@ -2285,7 +2285,7 @@ static int lfs_ctz_find(lfs_t *lfs,
lfs_npw2(current-target+1) - 1,
lfs_ctz(current));
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
pcache, rcache, sizeof(head),
head, 4*skip, &head, sizeof(head));
head = lfs_fromle32(head);
@@ -2314,7 +2314,7 @@ static int lfs_ctz_extend(lfs_t *lfs,
}
{
err = lfs_bd_erase(lfs, nblock);
err = lfs_cache_erase(lfs, nblock);
if (err) {
if (err == LFS_ERR_CORRUPT) {
goto relocate;
@@ -2336,14 +2336,14 @@ static int lfs_ctz_extend(lfs_t *lfs,
if (noff != LFS_CFG_BLOCK_SIZE(lfs)) {
for (lfs_off_t i = 0; i < noff; i++) {
uint8_t data;
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, rcache, noff-i,
head, i, &data, 1);
if (err) {
return err;
}
err = lfs_bd_prog(lfs,
err = lfs_cache_prog(lfs,
pcache, rcache, true,
nblock, i, &data, 1);
if (err) {
@@ -2365,7 +2365,7 @@ static int lfs_ctz_extend(lfs_t *lfs,
lfs_block_t nhead = head;
for (lfs_off_t i = 0; i < skips; i++) {
nhead = lfs_tole32(nhead);
err = lfs_bd_prog(lfs, pcache, rcache, true,
err = lfs_cache_prog(lfs, pcache, rcache, true,
nblock, 4*i, &nhead, 4);
nhead = lfs_fromle32(nhead);
if (err) {
@@ -2376,7 +2376,7 @@ static int lfs_ctz_extend(lfs_t *lfs,
}
if (i != skips-1) {
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, rcache, sizeof(nhead),
nhead, 4*i, &nhead, sizeof(nhead));
nhead = lfs_fromle32(nhead);
@@ -2421,7 +2421,7 @@ static int lfs_ctz_traverse(lfs_t *lfs,
lfs_block_t heads[2];
int count = 2 - (index & 1);
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
pcache, rcache, count*sizeof(head),
head, 0, &heads, count*sizeof(head));
heads[0] = lfs_fromle32(heads[0]);
@@ -2654,7 +2654,7 @@ static int lfs_file_relocate(lfs_t *lfs, lfs_file_t *file) {
return err;
}
err = lfs_bd_erase(lfs, nblock);
err = lfs_cache_erase(lfs, nblock);
if (err) {
if (err == LFS_ERR_CORRUPT) {
goto relocate;
@@ -2676,7 +2676,7 @@ static int lfs_file_relocate(lfs_t *lfs, lfs_file_t *file) {
return err;
}
} else {
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
&file->cache, &lfs->rcache, file->off-i,
file->block, i, &data, 1);
if (err) {
@@ -2684,7 +2684,7 @@ static int lfs_file_relocate(lfs_t *lfs, lfs_file_t *file) {
}
}
err = lfs_bd_prog(lfs,
err = lfs_cache_prog(lfs,
&lfs->pcache, &lfs->rcache, true,
nblock, i, &data, 1);
if (err) {
@@ -2773,7 +2773,7 @@ static int lfs_file_flush(lfs_t *lfs, lfs_file_t *file) {
// write out what we have
while (true) {
int err = lfs_bd_flush(lfs, &file->cache, &lfs->rcache, true);
int err = lfs_cache_flush(lfs, &file->cache, &lfs->rcache, true);
if (err) {
if (err == LFS_ERR_CORRUPT) {
goto relocate;
@@ -2924,7 +2924,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
return err;
}
} else {
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
NULL, &file->cache, LFS_CFG_BLOCK_SIZE(lfs),
file->block, file->off, data, diff);
if (err) {
@@ -3040,7 +3040,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
// program as much as we can in current block
lfs_size_t diff = lfs_min(nsize, LFS_CFG_BLOCK_SIZE(lfs) - file->off);
while (true) {
int err = lfs_bd_prog(lfs, &file->cache, &lfs->rcache, true,
int err = lfs_cache_prog(lfs, &file->cache, &lfs->rcache, true,
file->block, file->off, data, diff);
if (err) {
if (err == LFS_ERR_CORRUPT) {
@@ -4069,7 +4069,7 @@ static int lfs_fs_parent_match(void *data,
(void)tag;
lfs_block_t child[2];
int err = lfs_bd_read(lfs,
int err = lfs_cache_read(lfs,
&lfs->pcache, &lfs->rcache, LFS_CFG_BLOCK_SIZE(lfs),
disk->block, disk->off, &child, sizeof(child));
if (err) {
@@ -4447,7 +4447,7 @@ static int lfs1_bd_read(lfs_t *lfs, lfs_block_t block,
lfs_off_t off, void *buffer, lfs_size_t size) {
// if we ever do more than writes to alternating pairs,
// this may need to consider pcache
return lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, size,
return lfs_cache_read(lfs, &lfs->pcache, &lfs->rcache, size,
block, off, buffer, size);
}
@@ -4910,7 +4910,7 @@ static int lfs_migratecommon(lfs_t *lfs) {
"-> {0x%"PRIx32", 0x%"PRIx32"}",
lfs->root[0], lfs->root[1], dir1.head[0], dir1.head[1]);
err = lfs_bd_erase(lfs, dir1.head[1]);
err = lfs_cache_erase(lfs, dir1.head[1]);
if (err) {
goto cleanup;
}
@@ -4922,14 +4922,14 @@ static int lfs_migratecommon(lfs_t *lfs) {
for (lfs_off_t i = 0; i < dir2.off; i++) {
uint8_t dat;
err = lfs_bd_read(lfs,
err = lfs_cache_read(lfs,
NULL, &lfs->rcache, dir2.off,
dir2.pair[0], i, &dat, 1);
if (err) {
goto cleanup;
}
err = lfs_bd_prog(lfs,
err = lfs_cache_prog(lfs,
&lfs->pcache, &lfs->rcache, true,
dir1.head[1], i, &dat, 1);
if (err) {
@@ -4937,7 +4937,7 @@ static int lfs_migratecommon(lfs_t *lfs) {
}
}
err = lfs_bd_flush(lfs, &lfs->pcache, &lfs->rcache, true);
err = lfs_cache_flush(lfs, &lfs->pcache, &lfs->rcache, true);
if (err) {
goto cleanup;
}

18
lfs.h
View File

@@ -130,28 +130,28 @@ enum lfs_whence_flags {
struct lfs_cfg {
// Opaque user provided context that can be used to pass
// information to the block device operations
void *ctx;
void *bd_ctx;
// Read a region in a block. Negative error codes are propogated
// to the user.
int (*read)(void *ctx, lfs_block_t block,
int (*bd_read)(void *ctx, lfs_block_t block,
lfs_off_t off, void *buffer, lfs_size_t size);
// Program a region in a block. The block must have previously
// been erased. Negative error codes are propogated to the user.
// May return LFS_ERR_CORRUPT if the block should be considered bad.
int (*prog)(void *ctx, lfs_block_t block,
int (*bd_prog)(void *ctx, 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. Negative error codes
// are propogated to the user.
// May return LFS_ERR_CORRUPT if the block should be considered bad.
int (*erase)(void *ctx, lfs_block_t block);
int (*bd_erase)(void *ctx, lfs_block_t block);
// Sync the state of the underlying block device. Negative error codes
// are propogated to the user.
int (*sync)(void *ctx);
int (*bd_sync)(void *ctx);
// Minimum size of a block read. All read operations will be a
// multiple of this value.
@@ -226,12 +226,12 @@ struct lfs_cfg {
// the lfs_cfg struct above.
// Block device operations
int lfs_read(lfs_block_t block,
int lfs_bd_read(lfs_block_t block,
lfs_off_t off, void *buffer, lfs_size_t size);
int lfs_prog(lfs_block_t block,
int lfs_bd_prog(lfs_block_t block,
lfs_off_t off, const void *buffer, lfs_size_t size);
int lfs_erase(lfs_block_t block);
int lfs_sync(void);
int lfs_bd_erase(lfs_block_t block);
int lfs_bd_sync(void);
// Required configuration
#ifndef LFS_READ_SIZE

10
scripts/test.py
View File

@@ -97,11 +97,11 @@ PROLOGUE = """
__attribute__((unused)) int err;
__attribute__((unused)) const struct lfs_cfg cfg = {
.ctx = &bd,
.read = lfs_testbd_readctx,
.prog = lfs_testbd_progctx,
.erase = lfs_testbd_erasectx,
.sync = lfs_testbd_syncctx,
.bd_ctx = &bd,
.bd_read = lfs_testbd_readctx,
.bd_prog = lfs_testbd_progctx,
.bd_erase = lfs_testbd_erasectx,
.bd_sync = lfs_testbd_syncctx,
.read_size = LFS_READ_SIZE,
.prog_size = LFS_PROG_SIZE,
.block_size = LFS_BLOCK_SIZE,