Github/littlefs
1
Fork 0
Code Actions Activity
Files
95fddd3c189a062eca4caf18a627a9e7fd1715c3
littlefs/bd/lfs3_emubd.c
T
Christopher Haster 10e77d9177 runners: bench: Added BENCH_SIMTIME/SIMRESET/PAUSE/RESUME/etc 
- BENCH_SIMTIME()   => lfs3_kiwibd_simtime()
- BENCH_SIMRESET()  => lfs3_kiwibd_simreset()
- BENCH_SIMPAUSE()  => lfs3_kiwibd_simpause()
- BENCH_SIMRESUME() => lfs3_kiwibd_simresume()
- BENCH_RESET()     => lfs3_kiwibd_simreset() + BENCH_STACK/HEAP_RESET()
- BENCH_PAUSE()     => lfs3_kiwibd_simpause() + BENCH_STACK/HEAP_PAUSE()
- BENCH_RESUME()    => lfs3_kiwibd_simresume() + BENCH_STACK/HEAP_RESUME()

This does two things:

1. Adds pause/resume counters to bd counters to make it easier to
   exclude operations from the current bench (potentially useful for
   seq+disk usage).

2. Exposes bd simtime operations as BENCH_* macros, to make it a bit
   easier to interact with simtime without tying all the benches to
   kiwibd. (Not that we'll ever probably not use kiwibd, but still).

Also adopted 32-bit counters for stack/heap pause state instead of a
32-bit stack. Not that either are at a risk of overflowing, but better
safe than sorry.
2026-03-09 22:54:49 -05:00

1569 lines
51 KiB
C
Raw Blame History

/*
* emubd - High-level emulating block device with many bells and
* whistles for testing powerloss, wear, etc.
*
* Note emubd always backs the block device in RAM. Consider using
* kiwibd if you need a block device larger than the available RAM on
* the system.
*
* Copyright (c) 2022, The littlefs authors.
* Copyright (c) 2017, Arm Limited. All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 199309L
#endif
#include "bd/lfs3_emubd.h"
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#ifdef _WIN32
#include <windows.h>
#endif
// low-level flash memory emulation
// read data
static inline void lfs3_emubd_memread(const struct lfs3_cfg *cfg,
void *restrict dst, const void *restrict src, size_t size) {
(void)cfg;
memcpy(dst, src, size);
}
static inline void lfs3_emubd_memprog(const struct lfs3_cfg *cfg,
void *restrict dst, const void *restrict src, size_t size) {
lfs3_emubd_t *bd = cfg->context;
// emulating nor-masking?
if (bd->cfg->erase_value == -2) {
uint8_t *dst_ = dst;
const uint8_t *src_ = src;
for (size_t i = 0; i < size; i++) {
dst_[i] &= src_[i];
}
} else {
memcpy(dst, src, size);
}
}
static inline void lfs3_emubd_memerase(const struct lfs3_cfg *cfg,
void *restrict dst, size_t size) {
lfs3_emubd_t *bd = cfg->context;
// emulating erase value?
if (bd->cfg->erase_value != -1) {
memset(dst,
(bd->cfg->erase_value >= 0)
? bd->cfg->erase_value
: 0xff,
size);
}
}
// this is slightly different from lfs3_emubd_memerase in that we use
// lfs3_emubd_memzero when we need to unconditionally zero memory
static inline void lfs3_emubd_memzero(const struct lfs3_cfg *cfg,
void *restrict dst, size_t size) {
lfs3_emubd_t *bd = cfg->context;
memset(dst,
(bd->cfg->erase_value == -1) ? 0
: (bd->cfg->erase_value >= 0) ? bd->cfg->erase_value
: (bd->cfg->erase_value == -2) ? 0xff
: 0,
size);
}
// access to lazily-allocated/copy-on-write blocks
//
// note we can only modify a block if we have exclusive access to
// it (rc == 1)
//
static lfs3_emubd_block_t *lfs3_emubd_incblock(lfs3_emubd_block_t *block) {
if (block) {
block->rc += 1;
}
return block;
}
static void lfs3_emubd_decblock(lfs3_emubd_block_t *block) {
if (block) {
block->rc -= 1;
if (block->rc == 0) {
free(block);
}
}
}
static lfs3_emubd_block_t *lfs3_emubd_mutblock(
const struct lfs3_cfg *cfg,
lfs3_emubd_block_t *block) {
if (block && block->rc == 1) {
// rc == 1? can modify
return block;
} else if (block) {
// rc > 1? need to create a copy
lfs3_emubd_block_t *block_ = malloc(
sizeof(lfs3_emubd_block_t) + cfg->block_size);
if (!block_) {
return NULL;
}
memcpy(block_, block,
sizeof(lfs3_emubd_block_t) + cfg->block_size);
block_->rc = 1;
lfs3_emubd_decblock(block);
return block_;
} else {
// no block? need to allocate
lfs3_emubd_block_t *block_ = malloc(
sizeof(lfs3_emubd_block_t) + cfg->block_size);
if (!block_) {
return NULL;
}
block_->rc = 1;
block_->wear = 0;
block_->metastable = false;
block_->bad_bit = 0;
// zero for consistency
lfs3_emubd_memzero(cfg, block_->data, cfg->block_size);
return block_;
}
}
// prng used for some emulation things
static uint32_t lfs3_emubd_prng_(uint32_t *state) {
// A simple xorshift32 generator, easily reproducible. Keep in mind
// determinism is much more important than actual randomness here.
uint32_t x = *state;
// must be non-zero, use uintmax here so that seed=0 is different
// from seed=1 and seed=range(0,n) makes a bit more sense
if (x == 0) {
x = -1;
}
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
*state = x;
return x;
}
// emubd create/destroy
int lfs3_emubd_createcfg(const struct lfs3_cfg *cfg, const char *path,
const struct lfs3_emubd_cfg *bdcfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_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", "
".powerloss_behavior=%"PRIu8", "
".powerloss_cb=%p, "
".powerloss_data=%p, "
".seed=%"PRIu32", "
".read_sleep=%"PRIu64", "
".prog_sleep=%"PRIu64", "
".erase_sleep=%"PRIu64"})",
(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->powerloss_behavior,
(void*)(uintptr_t)bdcfg->powerloss_cb,
bdcfg->powerloss_data,
bdcfg->seed,
bdcfg->read_sleep,
bdcfg->prog_sleep,
bdcfg->erase_sleep);
lfs3_emubd_t *bd = cfg->context;
bd->cfg = bdcfg;
// setup testing things
bd->blocks = NULL;
bd->paused = false;
bd->reads = 0;
bd->progs = 0;
bd->erases = 0;
bd->readed = 0;
bd->progged = 0;
bd->erased = 0;
bd->prng = bd->cfg->seed;
bd->power_cycles = bd->cfg->power_cycles;
bd->ooo_before = NULL;
bd->ooo_after = NULL;
bd->disk = NULL;
// allocate our block array, all blocks start as uninitialized
bd->blocks = malloc(
cfg->block_count * sizeof(lfs3_emubd_block_t*));
int err;
if (!bd->blocks) {
err = LFS3_ERR_NOMEM;
goto failed;
}
memset(bd->blocks, 0,
cfg->block_count * sizeof(lfs3_emubd_block_t*));
// allocate extra block arrays to hold our ooo snapshots
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
bd->ooo_before = malloc(
cfg->block_count * sizeof(lfs3_emubd_block_t*));
if (!bd->ooo_before) {
err = LFS3_ERR_NOMEM;
goto failed;
}
memset(bd->ooo_before, 0,
cfg->block_count * sizeof(lfs3_emubd_block_t*));
bd->ooo_after = malloc(
cfg->block_count * sizeof(lfs3_emubd_block_t*));
if (!bd->ooo_after) {
err = LFS3_ERR_NOMEM;
goto failed;
}
memset(bd->ooo_after, 0,
cfg->block_count * sizeof(lfs3_emubd_block_t*));
}
if (path) {
bd->disk = malloc(sizeof(lfs3_emubd_disk_t));
if (!bd->disk) {
err = LFS3_ERR_NOMEM;
goto failed;
}
bd->disk->rc = 1;
bd->disk->fd = -1;
bd->disk->scratch = NULL;
#ifdef _WIN32
bd->disk->fd = open(path, O_RDWR | O_CREAT | O_BINARY, 0666);
#else
bd->disk->fd = open(path, O_RDWR | O_CREAT, 0666);
#endif
if (bd->disk->fd < 0) {
err = -errno;
goto failed;
}
bd->disk->scratch = malloc(cfg->block_size);
if (!bd->disk->scratch) {
err = LFS3_ERR_NOMEM;
goto failed;
}
lfs3_emubd_memzero(cfg, bd->disk->scratch, cfg->block_size);
// go ahead and erase all of the disk, otherwise the file will not
// match our internal representation
for (size_t i = 0; i < cfg->block_count; i++) {
ssize_t res = write(bd->disk->fd,
bd->disk->scratch,
cfg->block_size);
if (res < 0) {
err = -errno;
goto failed;
}
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_createcfg -> %d", 0);
return 0;
failed:;
LFS3_EMUBD_TRACE("lfs3_emubd_createcfg -> %d", err);
// clean up memory
free(bd->blocks);
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
free(bd->ooo_before);
free(bd->ooo_after);
}
if (bd->disk) {
if (bd->disk->fd != -1) {
close(bd->disk->fd);
}
free(bd->disk->scratch);
free(bd->disk);
}
return err;
}
int lfs3_emubd_create(const struct lfs3_cfg *cfg, const char *path) {
LFS3_EMUBD_TRACE("lfs3_emubd_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 lfs3_emubd_cfg defaults = {.erase_value=-1};
int err = lfs3_emubd_createcfg(cfg, path, &defaults);
LFS3_EMUBD_TRACE("lfs3_emubd_create -> %d", err);
return err;
}
int lfs3_emubd_destroy(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_destroy(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
// decrement reference counts
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
lfs3_emubd_decblock(bd->blocks[i]);
}
free(bd->blocks);
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
lfs3_emubd_decblock(bd->ooo_before[i]);
}
free(bd->ooo_before);
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
lfs3_emubd_decblock(bd->ooo_after[i]);
}
free(bd->ooo_after);
}
// clean up other resources
if (bd->disk) {
bd->disk->rc -= 1;
if (bd->disk->rc == 0) {
close(bd->disk->fd);
free(bd->disk->scratch);
free(bd->disk);
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_destroy -> %d", 0);
return 0;
}
// block device API
int lfs3_emubd_read(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, void *buffer, lfs3_size_t size) {
LFS3_EMUBD_TRACE("lfs3_emubd_read(%p, "
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
(void*)cfg, block, off, buffer, size);
lfs3_emubd_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);
// get the block
const lfs3_emubd_block_t *b = bd->blocks[block];
if (b) {
// block bad?
if (b->wear > bd->cfg->erase_cycles) {
// erroring reads? error
if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_READERROR) {
LFS3_EMUBD_TRACE("lfs3_emubd_read -> %d", LFS3_ERR_CORRUPT);
return LFS3_ERR_CORRUPT;
}
}
// read data
lfs3_emubd_memread(cfg, buffer, &b->data[off], size);
// metastable? randomly decide if our bad bit flips
if (b->metastable) {
lfs3_size_t bit = b->bad_bit & 0x7fffffff;
if (bit/8 >= off
&& bit/8 < off+size
&& (lfs3_emubd_prng_(&bd->prng) & 1)) {
((uint8_t*)buffer)[(bit/8) - off] ^= 1 << (bit%8);
}
}
// no block yet
} else {
// zero for consistency
lfs3_emubd_memzero(cfg, buffer, size);
}
// track reads
if (!bd->paused) {
bd->reads += (lfs3_alignup(off + size,
lfs3_max(bd->cfg->read_width, 1))
- lfs3_aligndown(off,
lfs3_max(bd->cfg->read_width, 1)))
/ lfs3_max(bd->cfg->read_width, 1);
bd->readed += size;
}
if (bd->cfg->read_sleep) {
int err = nanosleep(&(struct timespec){
.tv_sec=bd->cfg->read_sleep/1000000000,
.tv_nsec=bd->cfg->read_sleep%1000000000},
NULL);
if (err) {
err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_read -> %d", err);
return err;
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_read -> %d", 0);
return 0;
}
int lfs3_emubd_prog(const struct lfs3_cfg *cfg, lfs3_block_t block,
lfs3_off_t off, const void *buffer, lfs3_size_t size) {
LFS3_EMUBD_TRACE("lfs3_emubd_prog(%p, "
"0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
(void*)cfg, block, off, buffer, size);
lfs3_emubd_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);
// were we erased properly?
LFS3_ASSERT(bd->blocks[block]);
if (bd->cfg->erase_value >= 0
&& bd->blocks[block]->wear <= bd->cfg->erase_cycles) {
for (lfs3_off_t i = 0; i < size; i++) {
LFS3_ASSERT(bd->blocks[block]->data[off+i] == bd->cfg->erase_value);
}
}
// losing power?
if (bd->power_cycles > 0) {
bd->power_cycles -= 1;
if (bd->power_cycles == 0) {
// emulating some bits? choose a random bit to flip
if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_SOMEBITS) {
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg,
bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// flip bit
lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->prog_size*8);
b->data[off + (bit/8)] ^= 1 << (bit%8);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size + (off_t)off,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd, &b->data[off], size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
// emulating most bits? prog data and choose a random bit
// to flip
} else if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_MOSTBITS) {
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg,
bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// prog data
lfs3_emubd_memprog(cfg, &b->data[off], buffer, size);
// flip bit
lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->prog_size*8);
b->data[off + (bit/8)] ^= 1 << (bit%8);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size + (off_t)off,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd, &b->data[off], size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
// emulating out-of-order writes? revert everything unsynced
// except for our current block
} else if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_OOO) {
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
lfs3_emubd_decblock(bd->ooo_after[i]);
bd->ooo_after[i] = lfs3_emubd_incblock(bd->blocks[i]);
if (i != block && bd->blocks[i] != bd->ooo_before[i]) {
lfs3_emubd_decblock(bd->blocks[i]);
bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_before[i]);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)i*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
(bd->blocks[i])
? bd->blocks[i]->data
: bd->disk->scratch,
cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
}
}
// emulating metastability? prog data, choose a random bad bit,
// and mark as metastable
} else if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_METASTABLE) {
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg,
bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// prog data
lfs3_emubd_memprog(cfg, &b->data[off], buffer, size);
// choose a new bad bit unless overridden
if (!(0x80000000 & b->bad_bit)) {
b->bad_bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->block_size*8);
}
// mark as metastable
b->metastable = true;
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size + (off_t)off,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd, &b->data[off], size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
}
// powerloss!
bd->cfg->powerloss_cb(bd->cfg->powerloss_data);
// oh, continuing? undo out-of-order write emulation
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
if (bd->blocks[i] != bd->ooo_after[i]) {
lfs3_emubd_decblock(bd->blocks[i]);
bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_after[i]);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)i*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
(bd->blocks[i])
? bd->blocks[i]->data
: bd->disk->scratch,
cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
}
}
}
}
}
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// block bad?
if (b->wear > bd->cfg->erase_cycles) {
// erroring progs? error
if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_PROGERROR) {
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", LFS3_ERR_CORRUPT);
return LFS3_ERR_CORRUPT;
// noop progs? skip
} else if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_PROGNOOP
|| bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_ERASENOOP) {
goto progged;
// progs flipping bits? flip our bad bit, exactly which bit
// is chosen during erase
} else if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_PROGFLIP) {
lfs3_size_t bit = b->bad_bit & 0x7fffffff;
if (bit/8 >= off && bit/8 < off+size) {
// prog data
lfs3_emubd_memprog(cfg, &b->data[off], buffer, size);
b->data[bit/8] ^= 1 << (bit%8);
goto progged;
}
// reads flipping bits? prog as normal but mark as metastable
} else if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_READFLIP) {
// prog data
lfs3_emubd_memprog(cfg, &b->data[off], buffer, size);
b->metastable = true;
goto progged;
}
}
// prog data
lfs3_emubd_memprog(cfg, &b->data[off], buffer, size);
// clear any metastability
b->metastable = false;
progged:;
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size + (off_t)off,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd, &b->data[off], size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
// track progs
if (!bd->paused) {
bd->progs += (lfs3_alignup(off + size,
lfs3_max(bd->cfg->prog_width, 1))
- lfs3_aligndown(off,
lfs3_max(bd->cfg->prog_width, 1)))
/ lfs3_max(bd->cfg->prog_width, 1);
bd->progged += size;
}
if (bd->cfg->prog_sleep) {
int err = nanosleep(&(struct timespec){
.tv_sec=bd->cfg->prog_sleep/1000000000,
.tv_nsec=bd->cfg->prog_sleep%1000000000},
NULL);
if (err) {
err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", err);
return err;
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_prog -> %d", 0);
return 0;
}
int lfs3_emubd_erase(const struct lfs3_cfg *cfg, lfs3_block_t block) {
LFS3_EMUBD_TRACE("lfs3_emubd_erase(%p, 0x%"PRIx32" (%"PRIu32"))",
(void*)cfg, block, cfg->block_size);
lfs3_emubd_t *bd = cfg->context;
// check if erase is valid
LFS3_ASSERT(block < cfg->block_count);
// losing power?
if (bd->power_cycles > 0) {
bd->power_cycles -= 1;
if (bd->power_cycles == 0) {
// emulating some bits? choose a random bit to flip
if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_SOMEBITS) {
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg,
bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// flip bit
lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->block_size*8);
b->data[(bit/8)] ^= 1 << (bit%8);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
b->data, cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
// emulating most bits? erase data and choose a random bit
// to flip
} else if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_MOSTBITS) {
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg,
bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// emulate an erase value?
if (bd->cfg->erase_value != -1) {
lfs3_emubd_memerase(cfg, b->data, cfg->block_size);
}
// flip bit
lfs3_size_t bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->block_size*8);
b->data[(bit/8)] ^= 1 << (bit%8);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
b->data, cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
// emulating out-of-order writes? revert everything unsynced
// except for our current block
} else if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_OOO) {
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
if (i != block && bd->blocks[i] != bd->ooo_before[i]) {
lfs3_emubd_decblock(bd->blocks[i]);
bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_before[i]);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)i*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
(bd->blocks[i])
? bd->blocks[i]->data
: bd->disk->scratch,
cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
}
}
// emulating metastability? erase data, choose a random bad bit,
// and mark as metastable
} else if (bd->cfg->powerloss_behavior
== LFS3_EMUBD_POWERLOSS_METASTABLE) {
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg,
bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// emulate an erase value?
if (bd->cfg->erase_value != -1) {
lfs3_emubd_memerase(cfg, b->data, cfg->block_size);
}
// choose a new bad bit unless overridden
if (!(0x80000000 & b->bad_bit)) {
b->bad_bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->block_size*8);
}
// mark as metastable
b->metastable = true;
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
b->data, cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
}
// powerloss!
bd->cfg->powerloss_cb(bd->cfg->powerloss_data);
// oh, continuing? undo out-of-order write emulation
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
if (bd->blocks[i] != bd->ooo_after[i]) {
lfs3_emubd_decblock(bd->blocks[i]);
bd->blocks[i] = lfs3_emubd_incblock(bd->ooo_after[i]);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)i*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd,
(bd->blocks[i])
? bd->blocks[i]->data
: bd->disk->scratch,
cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
}
}
}
}
}
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// keep track of wear
if (bd->cfg->erase_cycles && b->wear <= bd->cfg->erase_cycles) {
b->wear += 1;
}
// block bad?
if (b->wear > bd->cfg->erase_cycles) {
// erroring erases? error
if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_ERASEERROR) {
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", LFS3_ERR_CORRUPT);
return LFS3_ERR_CORRUPT;
// noop erases? skip
} else if (bd->cfg->badblock_behavior
== LFS3_EMUBD_BADBLOCK_ERASENOOP) {
goto erased;
// flipping bits? if we're not manually overridden, choose a
// new bad bit on erase, this makes it more likely to
// eventually cause problems
} else {
if (!(0x80000000 & b->bad_bit)) {
b->bad_bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->block_size*8);
}
}
}
// emulate an erase value?
if (bd->cfg->erase_value != -1) {
lfs3_emubd_memerase(cfg, b->data, cfg->block_size);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size,
SEEK_SET);
if (res1 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
ssize_t res2 = write(bd->disk->fd, b->data, cfg->block_size);
if (res2 < 0) {
int err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
}
// clear any metastability
b->metastable = false;
erased:;
// track erases
if (!bd->paused) {
bd->erases += lfs3_alignup(cfg->block_size,
lfs3_max(bd->cfg->erase_width, 1))
/ lfs3_max(bd->cfg->erase_width, 1);
bd->erased += cfg->block_size;
}
if (bd->cfg->erase_sleep) {
int err = nanosleep(&(struct timespec){
.tv_sec=bd->cfg->erase_sleep/1000000000,
.tv_nsec=bd->cfg->erase_sleep%1000000000},
NULL);
if (err) {
err = -errno;
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", err);
return err;
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_erase -> %d", 0);
return 0;
}
int lfs3_emubd_sync(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_sync(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
// emulate out-of-order writes? save a snapshot on sync
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
for (size_t i = 0; i < cfg->block_count; i++) {
lfs3_emubd_decblock(bd->ooo_before[i]);
bd->ooo_before[i] = lfs3_emubd_incblock(bd->blocks[i]);
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_sync -> %d", 0);
return 0;
}
/// Additional emubd features for testing ///
lfs3_emubd_sns_t lfs3_emubd_simtime(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_simtime(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
// error if all possible timings are zero
if (bd->cfg->read_timing == 0
&& bd->cfg->prog_timing == 0
&& bd->cfg->erase_timing == 0
&& bd->cfg->readed_timing == 0
&& bd->cfg->progged_timing == 0
&& bd->cfg->erased_timing == 0) {
LFS3_EMUBD_TRACE("lfs3_emubd_simtime -> %d", LFS3_ERR_NOTSUP);
return LFS3_ERR_NOTSUP;
}
lfs3_emubd_ns_t ns
= (bd->cfg->read_timing * bd->reads*bd->cfg->read_width)
+ (bd->cfg->prog_timing * bd->progs*bd->cfg->prog_width)
+ (bd->cfg->erase_timing * bd->erases*bd->cfg->erase_width)
+ (bd->cfg->readed_timing * bd->readed)
+ (bd->cfg->progged_timing * bd->progged)
+ (bd->cfg->erased_timing * bd->erased);
LFS3_EMUBD_TRACE("lfs3_emubd_simtime -> %"PRIu64, ns);
return ns;
}
int lfs3_emubd_simreset(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_simreset(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
bd->reads = 0;
bd->progs = 0;
bd->erases = 0;
bd->readed = 0;
bd->progged = 0;
bd->erased = 0;
LFS3_EMUBD_TRACE("lfs3_emubd_simreset -> %d", 0);
return 0;
}
int lfs3_emubd_simpause(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_simpause(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
bd->paused += 1;
LFS3_EMUBD_TRACE("lfs3_emubd_simpause -> %d", 0);
return 0;
}
int lfs3_emubd_simresume(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_simresume(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_ASSERT(bd->paused);
bd->paused -= 1;
LFS3_EMUBD_TRACE("lfs3_emubd_simresume -> %d", 0);
return 0;
}
lfs3_emubd_sio_t lfs3_emubd_reads(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_reads(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_reads -> %"PRIu64, bd->reads);
return bd->reads;
}
lfs3_emubd_sio_t lfs3_emubd_progs(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_progs(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_progs -> %"PRIu64, bd->progs);
return bd->progs;
}
lfs3_emubd_sio_t lfs3_emubd_erases(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_erases(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_erases -> %"PRIu64, bd->erases);
return bd->erases;
}
lfs3_emubd_sio_t lfs3_emubd_readed(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_readed(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_readed -> %"PRIu64, bd->readed);
return bd->readed;
}
lfs3_emubd_sio_t lfs3_emubd_progged(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_progged(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_progged -> %"PRIu64, bd->progged);
return bd->progged;
}
lfs3_emubd_sio_t lfs3_emubd_erased(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_erased(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_erased -> %"PRIu64, bd->erased);
return bd->erased;
}
lfs3_emubd_swear_t lfs3_emubd_wear(const struct lfs3_cfg *cfg,
lfs3_block_t block) {
LFS3_EMUBD_TRACE("lfs3_emubd_wear(%p, %"PRIu32")", (void*)cfg, block);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// get the wear
lfs3_emubd_wear_t wear;
const lfs3_emubd_block_t *b = bd->blocks[block];
if (b) {
wear = b->wear;
} else {
wear = 0;
}
LFS3_EMUBD_TRACE("lfs3_emubd_wear -> %"PRIi32, wear);
return wear;
}
int lfs3_emubd_setwear(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_emubd_wear_t wear) {
LFS3_EMUBD_TRACE("lfs3_emubd_setwear(%p, %"PRIu32", %"PRIi32")",
(void*)cfg, block, wear);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_setwear -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// set the wear
b->wear = wear;
LFS3_EMUBD_TRACE("lfs3_emubd_setwear -> %d", 0);
return 0;
}
int lfs3_emubd_mkbad(const struct lfs3_cfg *cfg,
lfs3_block_t block) {
LFS3_EMUBD_TRACE("lfs3_emubd_mkbad(%p, %"PRIu32")",
(void*)cfg, block);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_mkbad -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// set the wear
b->wear = -1;
// choose a bad bit now in case this block is never erased
if (!(0x80000000 & b->bad_bit)) {
b->bad_bit = lfs3_emubd_prng_(&bd->prng)
% (cfg->block_size*8);
}
LFS3_EMUBD_TRACE("lfs3_emubd_mkbad -> %d", 0);
return 0;
}
int lfs3_emubd_mkgood(const struct lfs3_cfg *cfg,
lfs3_block_t block) {
LFS3_EMUBD_TRACE("lfs3_emubd_mkgood(%p, %"PRIu32")",
(void*)cfg, block);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_mkgood -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// set the wear
b->wear = 0;
LFS3_EMUBD_TRACE("lfs3_emubd_mkgood -> %d", 0);
return 0;
}
lfs3_ssize_t lfs3_emubd_badbit(const struct lfs3_cfg *cfg,
lfs3_block_t block) {
LFS3_EMUBD_TRACE("lfs3_emubd_badbit(%p, %"PRIu32")", (void*)cfg, block);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// get the bad bit
lfs3_size_t bad_bit;
const lfs3_emubd_block_t *b = bd->blocks[block];
if (b) {
bad_bit = 0x7fffffff & b->bad_bit;
} else {
bad_bit = 0;
}
LFS3_EMUBD_TRACE("lfs3_emubd_badbit -> %"PRIi32, bad_bit);
return bad_bit;
}
int lfs3_emubd_setbadbit(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_size_t bit) {
LFS3_EMUBD_TRACE("lfs3_emubd_setbadbit(%p, %"PRIu32", %"PRIu32")",
(void*)cfg, block, bit);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_setbadbit -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// set the bad bit and mark as fixed
b->bad_bit = 0x80000000 | bit;
LFS3_EMUBD_TRACE("lfs3_emubd_setbadbit -> %d", 0);
return 0;
}
int lfs3_emubd_randomizebadbit(const struct lfs3_cfg *cfg,
lfs3_block_t block) {
LFS3_EMUBD_TRACE("lfs3_emubd_randomizebadbit(%p, %"PRIu32")",
(void*)cfg, block);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_randomizebadbit -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// mark the bad bit as randomized
b->bad_bit &= ~0x80000000;
LFS3_EMUBD_TRACE("lfs3_emubd_randomizebadbit -> %d", 0);
return 0;
}
int lfs3_emubd_mkbadbit(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_size_t bit) {
LFS3_EMUBD_TRACE("lfs3_emubd_mkbadbit(%p, %"PRIu32", %"PRIu32")",
(void*)cfg, block, bit);
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
LFS3_EMUBD_TRACE("lfs3_emubd_mkbadbit -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// set the wear
b->wear = -1;
// set the bad bit and mark as fixed
b->bad_bit = 0x80000000 | bit;
LFS3_EMUBD_TRACE("lfs3_emubd_mkbadbit -> %d", 0);
return 0;
}
int lfs3_emubd_flipbit_(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_size_t bit) {
lfs3_emubd_t *bd = cfg->context;
// check if block is valid
LFS3_ASSERT(block < cfg->block_count);
// mutate the block
lfs3_emubd_block_t *b = lfs3_emubd_mutblock(cfg, bd->blocks[block]);
if (!b) {
return LFS3_ERR_NOMEM;
}
bd->blocks[block] = b;
// flip the bit
b->data[bit/8] ^= 1 << (bit%8);
// mirror to disk file?
if (bd->disk) {
off_t res1 = lseek(bd->disk->fd,
(off_t)block*cfg->block_size + (off_t)(bit/8),
SEEK_SET);
if (res1 < 0) {
int err = -errno;
return err;
}
ssize_t res2 = write(bd->disk->fd, &b->data[bit/8], 1);
if (res2 < 0) {
int err = -errno;
return err;
}
}
return 0;
}
int lfs3_emubd_flipbit(const struct lfs3_cfg *cfg,
lfs3_block_t block, lfs3_size_t bit) {
LFS3_EMUBD_TRACE("lfs3_emubd_flipbit(%p, %"PRIu32", %"PRIu32")",
(void*)cfg, block, bit);
// flip the bit
int err = lfs3_emubd_flipbit_(cfg, block, bit);
if (err) {
LFS3_EMUBD_TRACE("lfs3_emubd_flipbit -> %d", err);
return err;
}
LFS3_EMUBD_TRACE("lfs3_emubd_flipbit -> %d", 0);
return 0;
}
int lfs3_emubd_flip(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_flip(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
// flip all bits in bad blocks, make sure not to allocate blocks we
// don't need
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
const lfs3_emubd_block_t *b = bd->blocks[i];
if (b && b->wear > bd->cfg->erase_cycles) {
int err = lfs3_emubd_flipbit_(cfg, i, b->bad_bit & 0x7fffffff);
if (err) {
LFS3_EMUBD_TRACE("lfs3_emubd_flip -> %d", err);
return err;
}
}
}
LFS3_EMUBD_TRACE("lfs3_emubd_flip -> %d", 0);
return 0;
}
lfs3_emubd_spowercycles_t lfs3_emubd_powercycles(
const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_powercycles(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
LFS3_EMUBD_TRACE("lfs3_emubd_powercycles -> %"PRIi32, bd->power_cycles);
return bd->power_cycles;
}
int lfs3_emubd_setpowercycles(const struct lfs3_cfg *cfg,
lfs3_emubd_powercycles_t power_cycles) {
LFS3_EMUBD_TRACE("lfs3_emubd_setpowercycles(%p, %"PRIi32")",
(void*)cfg, power_cycles);
lfs3_emubd_t *bd = cfg->context;
bd->power_cycles = power_cycles;
LFS3_EMUBD_TRACE("lfs3_emubd_powercycles -> %d", 0);
return 0;
}
void lfs3_emubd_seed(const struct lfs3_cfg *cfg, uint32_t seed) {
LFS3_EMUBD_TRACE("lfs3_emubd_seed(%p, 0x%08"PRIx32")",
(void*)cfg, seed);
lfs3_emubd_t *bd = cfg->context;
bd->prng = seed;
LFS3_EMUBD_TRACE("lfs3_emubd_seed -> _");
}
uint32_t lfs3_emubd_prng(const struct lfs3_cfg *cfg) {
LFS3_EMUBD_TRACE("lfs3_emubd_prng(%p)", (void*)cfg);
lfs3_emubd_t *bd = cfg->context;
uint32_t x = lfs3_emubd_prng_(&bd->prng);
LFS3_EMUBD_TRACE("lfs3_emubd_prng -> 0x%08"PRIx32, x);
return x;
}
int lfs3_emubd_cpy(const struct lfs3_cfg *cfg, lfs3_emubd_t *copy) {
LFS3_EMUBD_TRACE("lfs3_emubd_cpy(%p, %p)", (void*)cfg, (void*)copy);
lfs3_emubd_t *bd = cfg->context;
// lazily copy over our block array
copy->blocks = malloc(
cfg->block_count * sizeof(lfs3_emubd_block_t*));
if (!copy->blocks) {
LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
copy->blocks[i] = lfs3_emubd_incblock(bd->blocks[i]);
}
if (bd->cfg->powerloss_behavior == LFS3_EMUBD_POWERLOSS_OOO) {
copy->ooo_before = malloc(
cfg->block_count * sizeof(lfs3_emubd_block_t*));
if (!copy->ooo_before) {
LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
copy->ooo_before[i] = lfs3_emubd_incblock(bd->ooo_before[i]);
}
copy->ooo_after = malloc(
cfg->block_count * sizeof(lfs3_emubd_block_t*));
if (!copy->ooo_after) {
LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", LFS3_ERR_NOMEM);
return LFS3_ERR_NOMEM;
}
for (lfs3_block_t i = 0; i < cfg->block_count; i++) {
copy->ooo_after[i] = lfs3_emubd_incblock(bd->ooo_after[i]);
}
}
// other state
copy->paused = bd->paused;
copy->reads = bd->reads;
copy->progs = bd->progs;
copy->erases = bd->erases;
copy->readed = bd->readed;
copy->progged = bd->progged;
copy->erased = bd->erased;
copy->prng = bd->prng;
copy->power_cycles = bd->power_cycles;
copy->disk = bd->disk;
if (copy->disk) {
copy->disk->rc += 1;
}
copy->cfg = bd->cfg;
LFS3_EMUBD_TRACE("lfs3_emubd_cpy -> %d", 0);
return 0;
}
View Git Blame Copy Permalink