Github/littlefs
1
Fork 0
Code Actions Activity

util: Cleaned up lfs_util.h

Browse Source 
This one was a bit more involved.

Removes utils that are no longer useful, and made sure some of the
name/API changes over time are adopted consistently:

- lfs_npw2 -> lfs_nlog2
- lfs_tole32_ -> lfs_tole32
- lfs_fromle32_ -> lfs_fromle32

Also did another pass for lfs_ prefixes on mem/str functions. The habit
to use the naked variants of these is hard to break!
This commit is contained in:
Christopher Haster
2025-05-27 21:34:12 -05:00
parent 31aafe0f99
commit 6d4248c685
5 changed files with 21 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+14 -14
View File
@@ -1723,7 +1723,7 @@ static int lfsr_data_readle32(lfs_t *lfs, lfsr_data_t *data,
return LFS_ERR_CORRUPT;
}
*word = lfs_fromle32_(buf);
*word = lfs_fromle32(buf);
return 0;
}
@@ -1904,7 +1904,7 @@ static int lfsr_bd_progdata(lfs_t *lfs,
static inline lfsr_data_t lfsr_data_fromle32(uint32_t word,
uint8_t buffer[static LFSR_LE32_DSIZE]) {
lfs_tole32_(word, buffer);
lfs_tole32(word, buffer);
return LFSR_DATA_BUF(buffer, LFSR_LE32_DSIZE);
}
@@ -2329,7 +2329,7 @@ static lfsr_data_t lfsr_data_fromecksum(const lfsr_ecksum_t *ecksum,
}
d += d_;
lfs_tole32_(ecksum->cksum, &buffer[d]);
lfs_tole32(ecksum->cksum, &buffer[d]);
d += 4;
return LFSR_DATA_BUF(buffer, d);
@@ -2473,7 +2473,7 @@ static lfsr_data_t lfsr_data_frombptr(const lfsr_bptr_t *bptr,
}
d += d_;
lfs_tole32_(lfsr_bptr_cksum(bptr), &buffer[d]);
lfs_tole32(lfsr_bptr_cksum(bptr), &buffer[d]);
d += 4;
return LFSR_DATA_BUF(buffer, d);
@@ -2779,7 +2779,7 @@ static int lfsr_rbyd_fetch_(lfs_t *lfs,
}
return err;
}
cksum__ = lfs_fromle32_(&cksum__);
cksum__ = lfs_fromle32(&cksum__);
if (cksum_ != cksum__) {
// uh oh, checksums don't match
@@ -3140,7 +3140,7 @@ static int lfsr_rbyd_appendrev(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) {
// revision count stored as le32, we don't use a leb128 encoding as we
// intentionally allow the revision count to overflow
uint8_t rev_buf[sizeof(uint32_t)];
lfs_tole32_(rev, &rev_buf);
lfs_tole32(rev, &rev_buf);
int err = lfsr_bd_prog(lfs,
rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
@@ -4264,7 +4264,7 @@ static int lfsr_rbyd_appendcksum_(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// note the odd-parity zero preserves our position in the crc32c
// ring while only changing the parity
cksum_ ^= (lfsr_rbyd_isperturb(rbyd)) ? LFS_CRC32C_ODDZERO : 0;
lfs_tole32_(cksum_, &cksum_buf[2+1+4]);
lfs_tole32(cksum_, &cksum_buf[2+1+4]);
// prog, when this lands on disk commit is committed
int err = lfsr_bd_prog(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
@@ -4847,7 +4847,7 @@ static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch,
}
d += d_;
lfs_tole32_(branch->cksum, &buffer[d]);
lfs_tole32(branch->cksum, &buffer[d]);
d += 4;
return LFSR_DATA_BUF(buffer, d);
@@ -7284,7 +7284,7 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir,
if (err && err != LFS_ERR_CORRUPT) {
return err;
}
revs[i] = lfs_fromle32_(&revs[i]);
revs[i] = lfs_fromle32(&revs[i]);
if (i == 0
|| err == LFS_ERR_CORRUPT
@@ -7539,7 +7539,7 @@ static int lfsr_mdir_alloc__(lfs_t *lfs, lfsr_mdir_t *mdir,
return err;
}
// note we allow corrupt errors here, as long as they are consistent
rev = (err != LFS_ERR_CORRUPT) ? lfs_fromle32_(&rev) : 0;
rev = (err != LFS_ERR_CORRUPT) ? lfs_fromle32(&rev) : 0;
// reset recycle bits in revision count and increment
rev = lfsr_rev_init(lfs, mdir, rev);
@@ -7583,7 +7583,7 @@ static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_,
return err;
}
// note we allow corrupt errors here, as long as they are consistent
rev = (err != LFS_ERR_CORRUPT) ? lfs_fromle32_(&rev) : 0;
rev = (err != LFS_ERR_CORRUPT) ? lfs_fromle32(&rev) : 0;
// increment our revision count
rev = lfsr_rev_inc(lfs, rev);
@@ -10889,7 +10889,7 @@ int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type,
}
lfs_size_t d = lfs_min(size, file->cfg->attrs[i].buffer_size);
memcpy(file->cfg->attrs[i].buffer, buffer, d);
lfs_memcpy(file->cfg->attrs[i].buffer, buffer, d);
if (file->cfg->attrs[i].size) {
*file->cfg->attrs[i].size = d;
}
@@ -13018,7 +13018,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
lfs_size_t d = lfs_min(
lfsr_attr_size(&file->cfg->attrs[i]),
file_->cfg->attrs[j].buffer_size);
memcpy(file_->cfg->attrs[j].buffer,
lfs_memcpy(file_->cfg->attrs[j].buffer,
file->cfg->attrs[i].buffer,
d);
if (file_->cfg->attrs[j].size) {
@@ -13825,7 +13825,7 @@ static int lfsr_data_readcompat(lfs_t *lfs, lfsr_data_t *data,
if (d < 0) {
return d;
}
*compat = lfs_fromle32_(buf);
*compat = lfs_fromle32(buf);
// if any out-of-range flags are set, set the internal overflow bit,
// this is a compromise in correctness and and compat-flag complexity
lfs_util.c
+1 -20
View File
@@ -57,26 +57,6 @@ ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size) {
}
//// Software CRC implementation with small lookup table
//uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
// static const uint32_t rtable[16] = {
// 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
// 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
// 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
// 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
// };
//
// const uint8_t *data = buffer;
//
// for (size_t i = 0; i < size; i++) {
// crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 0)) & 0xf];
// crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 4)) & 0xf];
// }
//
// return crc;
//}
// crc32c tables (see lfs_crc32c for more info)
#if !defined(LFS_SMALLER_CRC32C) \
&& !defined(LFS_FASTER_CRC32C) \
@@ -301,4 +281,5 @@ uint32_t lfs_crc32c_mul(uint32_t a, uint32_t b) {
return (uint32_t)r;
}
#endif
lfs_util.h
+4 -86
View File
@@ -189,31 +189,6 @@
#endif
#endif
// We need to know the endianness of the system for some struct packing
#if (defined(BYTE_ORDER) \
&& defined(ORDER_LITTLE_ENDIAN) \
&& BYTE_ORDER == ORDER_LITTLE_ENDIAN) \
|| (defined(__BYTE_ORDER) \
&& defined(__ORDER_LITTLE_ENDIAN) \
&& __BYTE_ORDER == __ORDER_LITTLE_ENDIAN) \
|| (defined(__BYTE_ORDER__) \
&& defined(__ORDER_LITTLE_ENDIAN__) \
&& __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
#define LFS_LITTLE_ENDIAN
#elif (defined(BYTE_ORDER) \
&& defined(ORDER_BIG_ENDIAN) \
&& BYTE_ORDER == ORDER_BIG_ENDIAN) \
|| (defined(__BYTE_ORDER) \
&& defined(__ORDER_BIG_ENDIAN) \
&& __BYTE_ORDER == __ORDER_BIG_ENDIAN) \
|| (defined(__BYTE_ORDER__) \
&& defined(__ORDER_BIG_ENDIAN__) \
&& __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#define LFS_BIG_ENDIAN
#else
#error "lfs: Unknown endianness?"
#endif
// Some ifdef conveniences
#ifdef LFS_REVDBG
@@ -331,7 +306,7 @@ static inline uint32_t lfs_alignup(uint32_t a, uint32_t alignment) {
}
// Find the smallest power of 2 greater than or equal to a
static inline uint32_t lfs_npw2(uint32_t a) {
static inline uint32_t lfs_nlog2(uint32_t a) {
// __builtin_clz of zero is undefined, so treat both 0 and 1 specially
if (a <= 1) {
return a;
@@ -351,19 +326,13 @@ static inline uint32_t lfs_npw2(uint32_t a) {
#endif
}
// TODO we should eventually adopt this as the new name for npw2
// Find the ceiling of log base 2 of the given number
static inline uint32_t lfs_nlog2(uint32_t a) {
return lfs_npw2(a);
}
// Count the number of trailing binary zeros in a
// lfs_ctz(0) may be undefined
static inline uint32_t lfs_ctz(uint32_t a) {
#if !defined(LFS_NO_BUILTINS) && defined(__GNUC__)
return __builtin_ctz(a);
#else
return lfs_npw2((a & -a) + 1) - 1;
return lfs_nlog2((a & -a) + 1) - 1;
#endif
}
@@ -416,62 +385,15 @@ static inline uint64_t lfs_pmul(uint32_t a, uint32_t b) {
}
// Convert between 32-bit little-endian and native order
static inline uint32_t lfs_fromle32(uint32_t a) {
#if !defined(LFS_NO_BUILTINS) && defined(LFS_LITTLE_ENDIAN)
return a;
#elif !defined(LFS_NO_BUILTINS)
return __builtin_bswap32(a);
#else
return (((uint8_t*)&a)[0] << 0) |
(((uint8_t*)&a)[1] << 8) |
(((uint8_t*)&a)[2] << 16) |
(((uint8_t*)&a)[3] << 24);
#endif
}
static inline uint32_t lfs_tole32(uint32_t a) {
return lfs_fromle32(a);
}
// Convert between 32-bit big-endian and native order
static inline uint32_t lfs_frombe32(uint32_t a) {
#if !defined(LFS_NO_BUILTINS) && defined(LFS_LITTLE_ENDIAN)
return __builtin_bswap32(a);
#elif !defined(LFS_NO_BUILTINS)
return a;
#else
return (((uint8_t*)&a)[0] << 24) |
(((uint8_t*)&a)[1] << 16) |
(((uint8_t*)&a)[2] << 8) |
(((uint8_t*)&a)[3] << 0);
#endif
}
static inline uint32_t lfs_tobe32(uint32_t a) {
return lfs_frombe32(a);
}
// Convert to/from 16-bit little-endian
static inline void lfs_tole16_(uint16_t word, void *buffer) {
((uint8_t*)buffer)[0] = word >> 0;
((uint8_t*)buffer)[1] = word >> 8;
}
static inline uint16_t lfs_fromle16_(const void *buffer) {
return (((uint8_t*)buffer)[0] << 0)
| (((uint8_t*)buffer)[1] << 8);
}
// Convert to/from 32-bit little-endian
static inline void lfs_tole32_(uint32_t word, void *buffer) {
static inline void lfs_tole32(uint32_t word, void *buffer) {
((uint8_t*)buffer)[0] = word >> 0;
((uint8_t*)buffer)[1] = word >> 8;
((uint8_t*)buffer)[2] = word >> 16;
((uint8_t*)buffer)[3] = word >> 24;
}
static inline uint32_t lfs_fromle32_(const void *buffer) {
static inline uint32_t lfs_fromle32(const void *buffer) {
return (((uint8_t*)buffer)[0] << 0)
| (((uint8_t*)buffer)[1] << 8)
| (((uint8_t*)buffer)[2] << 16)
@@ -733,9 +655,6 @@ static inline size_t lfs_strcspn(const char *a, const char *cs) {
#endif
//// Calculate CRC-32 with polynomial = 0x04c11db7
//uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size);
// Odd-parity and even-parity zeros in our crc32c ring
#define LFS_CRC32C_ODDZERO 0xfca42daf
#define LFS_CRC32C_EVENZERO 0x00000000
@@ -758,7 +677,6 @@ static inline uint32_t lfs_crc32c_cube(uint32_t a) {
// Allocate memory, only used if buffers are not provided to littlefs
// Note, memory must be 64-bit aligned
#ifndef LFS_NO_MALLOC
#define lfs_malloc malloc
#else
runners/bench_runner.c
+1 -1
View File
@@ -1920,7 +1920,7 @@ getopt_done: ;
if (d >= define_count) {
// align to power of two to avoid any superlinear growth
size_t ncount = 1 << lfs_npw2(d+1);
size_t ncount = 1 << lfs_nlog2(d+1);
defines = realloc(defines,
ncount*sizeof(bench_define_t));
memset(defines+define_count, 0,
runners/test_runner.c
+1 -1
View File
@@ -2538,7 +2538,7 @@ getopt_done:;
if (d >= define_count) {
// align to power of two to avoid any superlinear growth
size_t ncount = 1 << lfs_npw2(d+1);
size_t ncount = 1 << lfs_nlog2(d+1);
defines = realloc(defines,
ncount*sizeof(test_define_t));
memset(defines+define_count, 0,