Github/littlefs
1
Fork 0
Code Actions Activity
Files
bc9562c64e9ff2d8e7209edbc65fcdbc645d2139
littlefs/bd/lfs3_emubd.c
T
Christopher Haster d3dd927de3 runners: emubd/kiwibd: Adopted emulated simtime API 
This is based on some work in external benchmarks. What's worked well
there is emulating a global simtime based on per-byte estimates.

This moves the emulated simtime into emubd/kiwibd, and extends the idea
with both per-byte and per-op timing estimates for hopefully more
realistic results.

---

The problem is how NAND flash reads work.

Per-byte timing estimates are surprisingly accurate for NOR flash. There
is some overhead for sending the address, but it's mostly dominated by
bus cost (~20ns/B [1]).

NAND flash, on the otherhand, technically does support byte-level reads,
but first needs to read into 2KiB buffer. Surprisingly, these are pretty
close in cost (~19ns/B bus [2] vs ~12ns/B buffer [2]).

This close-ness makes modeling NAND flash difficult. If we set
read_size=1, we risk hiding the cost of small reads, which littlefs3 is
full of (rbyd lookups). If we set read_size=2048, we unfairly penalize
littlefs3 for the same reason.

---

The solution here is to expose both per-byte and per-op timing
estimates. This lets you model NAND reads using two data points:

  ^
  |                                realtime --> ...............o
  |                                             :    .....'''' :
  |                              ...............:''''  ^       :
  |                              :....'''''            |       :
  |               ..........::::::                  simtime    :
  |          .....:''''                                        :
  |o....:::::.....:                                            :
  |:                                                           :
  |:                                                           :
  +:-----------------------------------------------------------:>
   min read                                              max read

Where:

  bus_timing = 19ns
  buffer_timing = 25us
  buffer_size = 2KiB
  erase_size = 128KiB

  min_read = buffer_timing
  max_read = (erase_size/buffer_size)*buffer_timing - buffer_timing
  read_timing = min_read
  readed_timing = ((max_read - min_read)/erase_size) + bus_timing

  simtime = reads*read_timing + readed*readed_timing
            (per-op)            (per-byte)

This should correctly penalize small reads without complicating
emubd/kiwibd too much.

That's the idea anyways! It will take some use to understand if this is
a reasonable approach.

As a plus, this is a superset of the per-byte model, so both can be used
for realistic vs idealistic simulations (and to test the bus+buffer
model itself).

1: https://www.winbond.com/resource-files/W25Q256JV%20SPI%20RevQ%2002072025%20Plus.pdf
2: https://www.winbond.com/resource-files/W25N01GV%20Rev%20R%20070323.pdf
2026-02-10 15:28:32 -06:00

1534 lines
49 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->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
bd->reads += 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
bd->progs += 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
bd->erases += 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->reads_timing == 0
&& bd->cfg->progs_timing == 0
&& bd->cfg->erases_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->reads_timing * bd->reads)
+ (bd->cfg->progs_timing * bd->progs)
+ (bd->cfg->erases_timing * bd->erases)
+ (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;
}
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->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