Github/littlefs
1
Fork 0
Code Actions Activity

Folded lfsr_ck_t into lfsr_data_t

Browse Source 
This reduces lfsr_ck_t to just the cksize/cksum fields, and moves all of
the compile-time ifdef LFS_CKDATACKSUMS logic up into the relevant
lfsr_data_* functions.

This doesn't solve the lfsr_data_t/lfsr_bptr_t duplication problem,
unfortunately, but does simplify the code base a bit.

No significant code changes:

                        code          stack          ctx
  default before:      38128           2624          752
  default after:       38128 (+0.0%)   2624 (+0.0%)  752 (+0.0%)

  ckdatacksums before: 39240           3008          752
  ckdatacksums after:  39232 (-0.0%)   3008 (+0.0%)  752 (+0.0%)
This commit is contained in:
Christopher Haster
2025-01-04 13:45:03 -06:00
parent 1d21355707
commit 6307cba8bb
2 changed files with 166 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+161 -234
View File
@@ -702,29 +702,6 @@ static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
/// lfsr_ck_t stuff ///
#ifdef LFS_CKDATACKSUMS
#define LFSR_CK_NULL() \
((lfsr_ck_t){ \
.cksize=0})
#endif
#ifdef LFS_CKDATACKSUMS
#define LFSR_CK_CKSUM(_cksize, _cksum) \
((lfsr_ck_t){ \
.cksize=_cksize, \
.cksum=_cksum})
#endif
// ck helpers
#ifdef LFS_CKDATACKSUMS
static inline bool lfsr_ck_iscksum(lfsr_ck_t ck) {
return ck.cksize != 0;
}
#endif
// lfsr_tailp_t stuff // lfsr_tailp_t stuff
// //
// tailp tracks the most recent trunk's parity so we can parity-check // tailp tracks the most recent trunk's parity so we can parity-check
@@ -749,21 +726,18 @@ static inline lfs_size_t lfsr_tailp_off(const lfsr_tailp_t *tailp) {
// checked read helpers // checked read helpers
// needed in lfsr_bd_ckprefix/cksuffix
#ifdef LFS_CKDATACKSUMS
static inline bool lfsr_m_isckdatacksums(uint32_t flags);
#endif
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
static int lfsr_bd_ckprefix(lfs_t *lfs, static int lfsr_bd_ckprefix(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_size_t hint, lfs_block_t block, lfs_size_t off, lfs_size_t hint,
lfsr_ck_t ck, lfs_size_t cksize, uint32_t cksum,
lfs_size_t *hint_, lfs_size_t *hint_,
uint32_t *cksum) { uint32_t *cksum__) {
LFS_ASSERT(lfsr_ck_iscksum(ck)); (void)cksum;
// checked read with no cksum?
LFS_ASSERT(cksize != 0);
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->block_count); LFS_ASSERT(block < lfs->block_count);
LFS_ASSERT(ck.cksize <= lfs->cfg->block_size); LFS_ASSERT(cksize <= lfs->cfg->block_size);
// make sure hint includes our prefix/suffix // make sure hint includes our prefix/suffix
lfs_size_t hint__ = lfs_max( lfs_size_t hint__ = lfs_max(
@@ -771,13 +745,13 @@ static int lfsr_bd_ckprefix(lfs_t *lfs,
off + lfs_min( off + lfs_min(
hint, hint,
lfs->cfg->block_size - off), lfs->cfg->block_size - off),
ck.cksize); cksize);
// checksum any prefixed data // checksum any prefixed data
int err = lfsr_bd_cksum(lfs, int err = lfsr_bd_cksum(lfs,
block, 0, hint__, block, 0, hint__,
off, off,
cksum); cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -792,29 +766,30 @@ static int lfsr_bd_ckprefix(lfs_t *lfs,
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
static int lfsr_bd_cksuffix(lfs_t *lfs, static int lfsr_bd_cksuffix(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_size_t hint, lfs_block_t block, lfs_size_t off, lfs_size_t hint,
lfsr_ck_t ck, lfs_size_t cksize, uint32_t cksum,
uint32_t cksum) { uint32_t cksum__) {
LFS_ASSERT(lfsr_ck_iscksum(ck)); // checked read with no cksum?
LFS_ASSERT(cksize != 0);
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->block_count); LFS_ASSERT(block < lfs->block_count);
LFS_ASSERT(ck.cksize <= lfs->cfg->block_size); LFS_ASSERT(cksize <= lfs->cfg->block_size);
// checksum any suffixed data // checksum any suffixed data
int err = lfsr_bd_cksum(lfs, int err = lfsr_bd_cksum(lfs,
block, off, hint, block, off, hint,
ck.cksize - off, cksize - off,
&cksum); &cksum__);
if (err) { if (err) {
return err; return err;
} }
// do checksums match? // do checksums match?
if (cksum != ck.cksum) { if (cksum__ != cksum) {
LFS_ERROR("Found ckdatacksums mismatch " LFS_ERROR("Found ckdatacksums mismatch "
"0x%"PRIx32".%"PRIx32" %"PRId32", " "0x%"PRIx32".%"PRIx32" %"PRId32", "
"cksum %08"PRIx32" (!= %08"PRIx32")", "cksum %08"PRIx32" (!= %08"PRIx32")",
block, 0, ck.cksize, block, 0, cksize,
cksum, ck.cksum); cksum__, cksum);
return LFS_ERR_CORRUPT; return LFS_ERR_CORRUPT;
} }
@@ -832,23 +807,25 @@ static int lfsr_bd_cksuffix(lfs_t *lfs,
// contributes to the relevant parity/checksum, this may be // contributes to the relevant parity/checksum, this may be
// significantly more than the data we actually end up using // significantly more than the data we actually end up using
// //
static int lfsr_bd_readck_(lfs_t *lfs, static int lfsr_bd_readck(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_size_t hint, lfs_block_t block, lfs_size_t off, lfs_size_t hint,
void *buffer, lfs_size_t size, void *buffer, lfs_size_t size,
lfsr_ck_t ck) { lfs_size_t cksize, uint32_t cksum) {
LFS_ASSERT(lfsr_ck_iscksum(ck)); // checked read with no cksum?
LFS_ASSERT(cksize != 0);
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->block_count); LFS_ASSERT(block < lfs->block_count);
LFS_ASSERT(ck.cksize <= lfs->cfg->block_size); LFS_ASSERT(cksize <= lfs->cfg->block_size);
// read should fit in ck info // read should fit in ck info
LFS_ASSERT(off+size <= ck.cksize); LFS_ASSERT(off+size <= cksize);
// checksum any prefixed data // checksum any prefixed data
uint32_t cksum = 0; uint32_t cksum__ = 0;
lfs_size_t hint_; lfs_size_t hint_;
int err = lfsr_bd_ckprefix(lfs, block, off, hint, ck, int err = lfsr_bd_ckprefix(lfs, block, off, hint,
cksize, cksum,
&hint_, &hint_,
&cksum); &cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -861,11 +838,12 @@ static int lfsr_bd_readck_(lfs_t *lfs,
return err; return err;
} }
cksum = lfs_crc32c(cksum, buffer, size); cksum__ = lfs_crc32c(cksum__, buffer, size);
// checksum any suffixed data and validate // checksum any suffixed data and validate
err = lfsr_bd_cksuffix(lfs, block, off+size, hint_-size, ck, err = lfsr_bd_cksuffix(lfs, block, off+size, hint_-size,
cksum); cksize, cksum,
cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -874,34 +852,6 @@ static int lfsr_bd_readck_(lfs_t *lfs,
} }
#endif #endif
#ifdef LFS_CKDATACKSUMS
static int lfsr_bd_readck(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_size_t hint,
void *buffer, lfs_size_t size,
lfsr_ck_t ck) {
// check this read?
if (lfsr_m_isckdatacksums(lfs->flags) && lfsr_ck_iscksum(ck)) {
return lfsr_bd_readck_(lfs,
block, off, hint,
buffer, size,
ck);
} else {
return lfsr_bd_read(lfs,
block, off, hint,
buffer, size);
}
}
#endif
// redirect to lfsr_bd_read if not checking reads
#ifdef LFS_CKDATACKSUMS
#define LFSR_BD_READCK(_lfs, _block, _off, _hint, _buffer, _size, _ck) \
lfsr_bd_readck(_lfs, _block, _off, _hint, _buffer, _size, _ck)
#else
#define LFSR_BD_READCK(_lfs, _block, _off, _hint, _buffer, _size, _ck) \
lfsr_bd_read(_lfs, _block, _off, _hint, _buffer, _size)
#endif
// these could probably be a bit better deduplicated with their // these could probably be a bit better deduplicated with their
// unchecked counterparts, but we don't generally use both at the same // unchecked counterparts, but we don't generally use both at the same
// time // time
@@ -909,23 +859,25 @@ static int lfsr_bd_readck(lfs_t *lfs,
// we'd also need to worry about early termination in lfsr_bd_cmp/cmpck // we'd also need to worry about early termination in lfsr_bd_cmp/cmpck
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
static lfs_scmp_t lfsr_bd_cmpck_(lfs_t *lfs, static lfs_scmp_t lfsr_bd_cmpck(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_size_t hint, lfs_block_t block, lfs_size_t off, lfs_size_t hint,
const void *buffer, lfs_size_t size, const void *buffer, lfs_size_t size,
lfsr_ck_t ck) { lfs_size_t cksize, uint32_t cksum) {
LFS_ASSERT(lfsr_ck_iscksum(ck)); // checked read with no cksum?
LFS_ASSERT(cksize != 0);
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->block_count); LFS_ASSERT(block < lfs->block_count);
LFS_ASSERT(ck.cksize <= lfs->cfg->block_size); LFS_ASSERT(cksize <= lfs->cfg->block_size);
// read should fit in ck info // read should fit in ck info
LFS_ASSERT(off+size <= ck.cksize); LFS_ASSERT(off+size <= cksize);
// checksum any prefixed data // checksum any prefixed data
uint32_t cksum = 0; uint32_t cksum__ = 0;
lfs_size_t hint_; lfs_size_t hint_;
int err = lfsr_bd_ckprefix(lfs, block, off, hint, ck, int err = lfsr_bd_ckprefix(lfs, block, off, hint,
cksize, cksum,
&hint_, &hint_,
&cksum); &cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -945,7 +897,7 @@ static lfs_scmp_t lfsr_bd_cmpck_(lfs_t *lfs,
return err; return err;
} }
cksum = lfs_crc32c(cksum, buffer__, size__); cksum__ = lfs_crc32c(cksum__, buffer__, size__);
if (cmp == LFS_CMP_EQ) { if (cmp == LFS_CMP_EQ) {
int cmp_ = lfs_memcmp(buffer__, buffer_, size__); int cmp_ = lfs_memcmp(buffer__, buffer_, size__);
@@ -961,8 +913,9 @@ static lfs_scmp_t lfsr_bd_cmpck_(lfs_t *lfs,
} }
// checksum any suffixed data and validate // checksum any suffixed data and validate
err = lfsr_bd_cksuffix(lfs, block, off+size, hint_-size, ck, err = lfsr_bd_cksuffix(lfs, block, off+size, hint_-size,
cksum); cksize, cksum,
cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -972,55 +925,29 @@ static lfs_scmp_t lfsr_bd_cmpck_(lfs_t *lfs,
#endif #endif
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
static lfs_scmp_t lfsr_bd_cmpck(lfs_t *lfs, static int lfsr_bd_cpyck(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_size_t hint,
const void *buffer, lfs_size_t size,
lfsr_ck_t ck) {
// check this read?
if (lfsr_m_isckdatacksums(lfs->flags) && lfsr_ck_iscksum(ck)) {
return lfsr_bd_cmpck_(lfs,
block, off, hint,
buffer, size,
ck);
} else {
return lfsr_bd_cmp(lfs,
block, off, hint,
buffer, size);
}
}
#endif
// redirect to lfsr_bd_cmp if not checking reads
#ifdef LFS_CKDATACKSUMS
#define LFSR_BD_CMPCK(_lfs, _block, _off, _hint, _buffer, _size, _ck) \
lfsr_bd_cmpck(_lfs, _block, _off, _hint, _buffer, _size, _ck)
#else
#define LFSR_BD_CMPCK(_lfs, _block, _off, _hint, _buffer, _size, _ck) \
lfsr_bd_cmp(_lfs, _block, _off, _hint, _buffer, _size)
#endif
#ifdef LFS_CKDATACKSUMS
static int lfsr_bd_cpyck_(lfs_t *lfs,
lfs_block_t dst_block, lfs_size_t dst_off, lfs_block_t dst_block, lfs_size_t dst_off,
lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint, lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint,
lfs_size_t size, lfs_size_t size,
lfsr_ck_t ck, lfs_size_t src_cksize, uint32_t src_cksum,
uint32_t *cksum, bool align) { uint32_t *cksum, bool align) {
LFS_ASSERT(lfsr_ck_iscksum(ck)); // checked read with no cksum?
LFS_ASSERT(src_cksize != 0);
// must be in-bounds // must be in-bounds
LFS_ASSERT(dst_block < lfs->block_count); LFS_ASSERT(dst_block < lfs->block_count);
LFS_ASSERT(dst_off+size <= lfs->cfg->block_size); LFS_ASSERT(dst_off+size <= lfs->cfg->block_size);
LFS_ASSERT(src_block < lfs->block_count); LFS_ASSERT(src_block < lfs->block_count);
LFS_ASSERT(ck.cksize <= lfs->cfg->block_size); LFS_ASSERT(src_cksize <= lfs->cfg->block_size);
// read should fit in ck info // read should fit in ck info
LFS_ASSERT(src_off+size <= ck.cksize); LFS_ASSERT(src_off+size <= src_cksize);
// checksum any prefixed data // checksum any prefixed data
uint32_t src_cksum = 0; uint32_t cksum__ = 0;
lfs_size_t hint_; lfs_size_t hint_;
int err = lfsr_bd_ckprefix(lfs, src_block, src_off, hint, ck, int err = lfsr_bd_ckprefix(lfs, src_block, src_off, hint,
src_cksize, src_cksum,
&hint_, &hint_,
&src_cksum); &cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -1049,9 +976,10 @@ static int lfsr_bd_cpyck_(lfs_t *lfs,
return err; return err;
} }
src_cksum = lfs_crc32c(src_cksum, buffer__, size__); // validating checksum
cksum__ = lfs_crc32c(cksum__, buffer__, size__);
// optional checksum // optional prog checksum
if (cksum && !align) { if (cksum && !align) {
*cksum = lfs_crc32c(*cksum, buffer__, size__); *cksum = lfs_crc32c(*cksum, buffer__, size__);
} }
@@ -1063,8 +991,9 @@ static int lfsr_bd_cpyck_(lfs_t *lfs,
} }
// checksum any suffixed data and validate // checksum any suffixed data and validate
err = lfsr_bd_cksuffix(lfs, src_block, src_off+size, hint_-size, ck, err = lfsr_bd_cksuffix(lfs, src_block, src_off+size, hint_-size,
src_cksum); src_cksize, src_cksum,
cksum__);
if (err) { if (err) {
return err; return err;
} }
@@ -1073,59 +1002,6 @@ static int lfsr_bd_cpyck_(lfs_t *lfs,
} }
#endif #endif
#ifdef LFS_CKDATACKSUMS
static int lfsr_bd_cpyck(lfs_t *lfs,
lfs_block_t dst_block, lfs_size_t dst_off,
lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint,
lfs_size_t size,
lfsr_ck_t ck,
uint32_t *cksum, bool align) {
// check this read?
if (lfsr_m_isckdatacksums(lfs->flags) && lfsr_ck_iscksum(ck)) {
return lfsr_bd_cpyck_(lfs,
dst_block, dst_off,
src_block, src_off, hint,
size,
ck,
cksum, align);
} else {
return lfsr_bd_cpy(lfs,
dst_block, dst_off,
src_block, src_off, hint,
size,
cksum, align);
}
}
#endif
// redirect to lfsr_bd_cpy if not checking reads
#ifdef LFS_CKDATACKSUMS
#define LFSR_BD_CPYCK(_lfs, \
_dst_block, _dst_off, \
_src_block, _src_off, _hint, \
_size, \
_ck, \
_cksum, _align) \
lfsr_bd_cpyck(_lfs, \
_dst_block, _dst_off, \
_src_block, _src_off, _hint, \
_size, \
_ck, \
_cksum, _align)
#else
#define LFSR_BD_CPYCK(_lfs, \
_dst_block, _dst_off, \
_src_block, _src_off, _hint, \
_size, \
_ck, \
_cksum, _align) \
lfsr_bd_cpy(_lfs, \
_dst_block, _dst_off, \
_src_block, _src_off, _hint, \
_size, \
_cksum, _align)
#endif
@@ -1785,20 +1661,11 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs,
.size=_size, \ .size=_size, \
.u.buffer=(const void*)(_buffer)}) .u.buffer=(const void*)(_buffer)})
#ifdef LFS_CKDATACKSUMS
#define LFSR_DATA_DISK(_block, _off, _size) \
((lfsr_data_t){ \
.size=LFSR_DATA_ONDISK | (_size), \
.u.disk.block=_block, \
.u.disk.off=_off, \
.u.disk.ck=LFSR_CK_NULL()})
#else
#define LFSR_DATA_DISK(_block, _off, _size) \ #define LFSR_DATA_DISK(_block, _off, _size) \
((lfsr_data_t){ \ ((lfsr_data_t){ \
.size=LFSR_DATA_ONDISK | (_size), \ .size=LFSR_DATA_ONDISK | (_size), \
.u.disk.block=_block, \ .u.disk.block=_block, \
.u.disk.off=_off}) .u.disk.off=_off})
#endif
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
#define LFSR_DATA_DISKCKSUM(_block, _off, _size, _cksize, _cksum) \ #define LFSR_DATA_DISKCKSUM(_block, _off, _size, _cksize, _cksum) \
@@ -1806,7 +1673,8 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs,
.size=LFSR_DATA_ONDISK | (_size), \ .size=LFSR_DATA_ONDISK | (_size), \
.u.disk.block=_block, \ .u.disk.block=_block, \
.u.disk.off=_off, \ .u.disk.off=_off, \
.u.disk.ck=LFSR_CK_CKSUM(_cksize, _cksum)}) .u.disk.cksize=_cksize, \
.u.disk.cksum=_cksum})
#else #else
#define LFSR_DATA_DISKCKSUM(_block, _off, _size, _cksize, _cksum) \ #define LFSR_DATA_DISKCKSUM(_block, _off, _size, _cksize, _cksum) \
((lfsr_data_t){ \ ((lfsr_data_t){ \
@@ -1871,6 +1739,11 @@ static lfsr_data_t lfsr_data_fruncate(lfsr_data_t data, lfs_size_t size) {
// lfsr_data_read* operations update the lfsr_data_t, effectively // lfsr_data_read* operations update the lfsr_data_t, effectively
// consuming the data // consuming the data
// needed in lfsr_data_read and friends
#ifdef LFS_CKDATACKSUMS
static inline bool lfsr_m_isckdatacksums(uint32_t flags);
#endif
static lfs_ssize_t lfsr_data_read(lfs_t *lfs, lfsr_data_t *data, static lfs_ssize_t lfsr_data_read(lfs_t *lfs, lfsr_data_t *data,
void *buffer, lfs_size_t size) { void *buffer, lfs_size_t size) {
// limit our size to data range // limit our size to data range
@@ -1878,14 +1751,32 @@ static lfs_ssize_t lfsr_data_read(lfs_t *lfs, lfsr_data_t *data,
// on-disk? // on-disk?
if (lfsr_data_ondisk(*data)) { if (lfsr_data_ondisk(*data)) {
int err = LFSR_BD_READCK(lfs, // validating data cksums?
data->u.disk.block, data->u.disk.off, if (LFS_IFDEF_CKDATACKSUMS(
// note our hint includes the full data range lfsr_m_isckdatacksums(lfs->flags)
lfsr_data_size(*data), && data->u.disk.cksize != 0,
buffer, d, false)) {
data->u.disk.ck); #ifdef LFS_CKDATACKSUMS
if (err < 0) { int err = lfsr_bd_readck(lfs,
return err; data->u.disk.block, data->u.disk.off,
// note our hint includes the full data range
lfsr_data_size(*data),
buffer, d,
data->u.disk.cksize, data->u.disk.cksum);
if (err < 0) {
return err;
}
#endif
} else {
int err = lfsr_bd_read(lfs,
data->u.disk.block, data->u.disk.off,
// note our hint includes the full data range
lfsr_data_size(*data),
buffer, d);
if (err < 0) {
return err;
}
} }
// buffer? // buffer?
@@ -1967,13 +1858,32 @@ static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, lfsr_data_t data,
// on-disk? // on-disk?
if (lfsr_data_ondisk(data)) { if (lfsr_data_ondisk(data)) {
int cmp = LFSR_BD_CMPCK(lfs, // validating data cksums?
// note the 0 hint, we don't usually use any following data if (LFS_IFDEF_CKDATACKSUMS(
data.u.disk.block, data.u.disk.off, 0, lfsr_m_isckdatacksums(lfs->flags)
buffer, d, && data.u.disk.cksize != 0,
data.u.disk.ck); false)) {
if (cmp != LFS_CMP_EQ) { #ifdef LFS_CKDATACKSUMS
return cmp; int cmp = lfsr_bd_cmpck(lfs,
// note the 0 hint, we don't usually use any
// following data
data.u.disk.block, data.u.disk.off, 0,
buffer, d,
data.u.disk.cksize, data.u.disk.cksum);
if (cmp != LFS_CMP_EQ) {
return cmp;
}
#endif
} else {
int cmp = lfsr_bd_cmp(lfs,
// note the 0 hint, we don't usually use any
// following data
data.u.disk.block, data.u.disk.off, 0,
buffer, d);
if (cmp != LFS_CMP_EQ) {
return cmp;
}
} }
// buffer? // buffer?
@@ -2020,13 +1930,30 @@ static int lfsr_bd_progdata(lfs_t *lfs,
uint32_t *cksum, bool align) { uint32_t *cksum, bool align) {
// on-disk? // on-disk?
if (lfsr_data_ondisk(data)) { if (lfsr_data_ondisk(data)) {
int err = LFSR_BD_CPYCK(lfs, block, off, // validating data cksums?
data.u.disk.block, data.u.disk.off, lfsr_data_size(data), if (LFS_IFDEF_CKDATACKSUMS(
lfsr_data_size(data), lfsr_m_isckdatacksums(lfs->flags)
data.u.disk.ck, && data.u.disk.cksize != 0,
cksum, align); false)) {
if (err) { #ifdef LFS_CKDATACKSUMS
return err; int err = lfsr_bd_cpyck(lfs, block, off,
data.u.disk.block, data.u.disk.off, lfsr_data_size(data),
lfsr_data_size(data),
data.u.disk.cksize, data.u.disk.cksum,
cksum, align);
if (err) {
return err;
}
#endif
} else {
int err = lfsr_bd_cpy(lfs, block, off,
data.u.disk.block, data.u.disk.off, lfsr_data_size(data),
lfsr_data_size(data),
cksum, align);
if (err) {
return err;
}
} }
// buffer? // buffer?
@@ -2499,11 +2426,11 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data,
LFSR_DATA_BPTR_(_bptr, (uint8_t[LFSR_BPTR_DSIZE]){0}) LFSR_DATA_BPTR_(_bptr, (uint8_t[LFSR_BPTR_DSIZE]){0})
// checked reads adds ck info to lfsr_data_t that we don't want to // checked reads adds ck info to lfsr_data_t that we don't want to
// unnecessarily duplicate, long story short accessing ck info gets // unnecessarily duplicate, this makes accessing ck info annoyingly
// annoyingly messy... // messy...
static inline lfs_size_t lfsr_bptr_cksize(const lfsr_bptr_t *bptr) { static inline lfs_size_t lfsr_bptr_cksize(const lfsr_bptr_t *bptr) {
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
return bptr->data.u.disk.ck.cksize; return bptr->data.u.disk.cksize;
#else #else
return bptr->cksize; return bptr->cksize;
#endif #endif
@@ -2511,7 +2438,7 @@ static inline lfs_size_t lfsr_bptr_cksize(const lfsr_bptr_t *bptr) {
static inline uint32_t lfsr_bptr_cksum(const lfsr_bptr_t *bptr) { static inline uint32_t lfsr_bptr_cksum(const lfsr_bptr_t *bptr) {
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
return bptr->data.u.disk.ck.cksum; return bptr->data.u.disk.cksum;
#else #else
return bptr->cksum; return bptr->cksum;
#endif #endif
@@ -2582,7 +2509,7 @@ static int lfsr_data_readbptr(lfs_t *lfs, lfsr_data_t *data,
// read the cksize, cksum // read the cksize, cksum
err = lfsr_data_readlleb128(lfs, data, err = lfsr_data_readlleb128(lfs, data,
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
&bptr->data.u.disk.ck.cksize, &bptr->data.u.disk.cksize,
&bptr->cksize)); &bptr->cksize));
if (err) { if (err) {
return err; return err;
@@ -2590,7 +2517,7 @@ static int lfsr_data_readbptr(lfs_t *lfs, lfsr_data_t *data,
err = lfsr_data_readle32(lfs, data, err = lfsr_data_readle32(lfs, data,
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
&bptr->data.u.disk.ck.cksum, &bptr->data.u.disk.cksum,
&bptr->cksum)); &bptr->cksum));
if (err) { if (err) {
return err; return err;
@@ -11988,10 +11915,10 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
bptr.data = LFSR_DATA_DISKCKSUM(block, 0, 0, 0, 0); bptr.data = LFSR_DATA_DISKCKSUM(block, 0, 0, 0, 0);
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
bptr.data.u.disk.ck.cksize, bptr.data.u.disk.cksize,
bptr.cksize) = 0; bptr.cksize) = 0;
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
bptr.data.u.disk.ck.cksum, bptr.data.u.disk.cksum,
bptr.cksum) = 0; bptr.cksum) = 0;
compact:; compact:;
@@ -12024,7 +11951,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
lfsr_bptr_cksize(&bptr), lfsr_bptr_cksize(&bptr),
&buffer[pos_ - pos], d_, &buffer[pos_ - pos], d_,
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
&bptr.data.u.disk.ck.cksum, &bptr.data.u.disk.cksum,
&bptr.cksum), true); &bptr.cksum), true);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -12037,7 +11964,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
pos_ += d_; pos_ += d_;
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
bptr.data.u.disk.ck.cksize, bptr.data.u.disk.cksize,
bptr.cksize) += d_; bptr.cksize) += d_;
d -= d_; d -= d_;
} }
@@ -12099,7 +12026,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
pos_ - (bid_-(weight_-1)), pos_ - (bid_-(weight_-1)),
d_), d_),
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
&bptr.data.u.disk.ck.cksum, &bptr.data.u.disk.cksum,
&bptr.cksum), true); &bptr.cksum), true);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -12112,7 +12039,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
pos_ += d_; pos_ += d_;
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
bptr.data.u.disk.ck.cksize, bptr.data.u.disk.cksize,
bptr.cksize) += d_; bptr.cksize) += d_;
d -= d_; d -= d_;
} }
@@ -12126,7 +12053,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
bptr.data.u.disk.block, lfsr_bptr_cksize(&bptr), bptr.data.u.disk.block, lfsr_bptr_cksize(&bptr),
0, d, 0, d,
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
&bptr.data.u.disk.ck.cksum, &bptr.data.u.disk.cksum,
&bptr.cksum), true); &bptr.cksum), true);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
@@ -12139,7 +12066,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
pos_ += d; pos_ += d;
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
bptr.data.u.disk.ck.cksize, bptr.data.u.disk.cksize,
bptr.cksize) += d; bptr.cksize) += d;
} }
@@ -12150,13 +12077,13 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
lfs_ssize_t d = lfsr_bptr_cksize(&bptr) % lfs->cfg->prog_size; lfs_ssize_t d = lfsr_bptr_cksize(&bptr) % lfs->cfg->prog_size;
lfs->pcache.size -= d; lfs->pcache.size -= d;
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
bptr.data.u.disk.ck.cksize, bptr.data.u.disk.cksize,
bptr.cksize) -= d; bptr.cksize) -= d;
// finalize our write // finalize our write
int err = lfsr_bd_flush(lfs, int err = lfsr_bd_flush(lfs,
LFS_IFDEF_CKDATACKSUMS( LFS_IFDEF_CKDATACKSUMS(
&bptr.data.u.disk.ck.cksum, &bptr.data.u.disk.cksum,
&bptr.cksum), true); &bptr.cksum), true);
if (err) { if (err) {
// bad prog? try another block // bad prog? try another block
lfs.h
+5 -11
View File
@@ -612,16 +612,6 @@ typedef struct lfsr_omdir {
// lfs_block_t tail[2]; // lfs_block_t tail[2];
//} lfs_mdir_t; //} lfs_mdir_t;
#ifdef LFS_CKDATACKSUMS
// context for validating data
typedef struct lfsr_ck {
// cksize=0 => no checksum
// cksize>0 => yes checksum
lfs_size_t cksize;
uint32_t cksum;
} lfsr_ck_t;
#endif
// either an on-disk or in-device data pointer // either an on-disk or in-device data pointer
typedef struct lfsr_data { typedef struct lfsr_data {
// sign(size)=0 => in-RAM buffer // sign(size)=0 => in-RAM buffer
@@ -632,8 +622,12 @@ typedef struct lfsr_data {
struct { struct {
lfs_block_t block; lfs_block_t block;
lfs_size_t off; lfs_size_t off;
// optional context for validating data
#ifdef LFS_CKDATACKSUMS #ifdef LFS_CKDATACKSUMS
lfsr_ck_t ck; // cksize==0 => no checksum
// cksize!=0 => yes checksum
lfs_size_t cksize;
uint32_t cksum;
#endif #endif
} disk; } disk;
} u; } u;