Skip to content

Commit a0a55fb

Browse files
committed
Added conversion to/from little-endian on disk
Required to support big-endian processors, with the most notable being the PowerPC architecture. On little-endian architectures, these conversions can be optimized out and have no code impact. Initial patch provided by gmouchard
1 parent 4f08424 commit a0a55fb

File tree

2 files changed

+99
-6
lines changed

2 files changed

+99
-6
lines changed

lfs.c

Lines changed: 76 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -323,6 +323,48 @@ static void lfs_alloc_ack(lfs_t *lfs) {
323323
}
324324

325325

326+
/// Endian swapping functions ///
327+
static void lfs_dir_fromle32(struct lfs_disk_dir *d) {
328+
d->rev = lfs_fromle32(d->rev);
329+
d->size = lfs_fromle32(d->size);
330+
d->tail[0] = lfs_fromle32(d->tail[0]);
331+
d->tail[1] = lfs_fromle32(d->tail[1]);
332+
}
333+
334+
static void lfs_dir_tole32(struct lfs_disk_dir *d) {
335+
d->rev = lfs_tole32(d->rev);
336+
d->size = lfs_tole32(d->size);
337+
d->tail[0] = lfs_tole32(d->tail[0]);
338+
d->tail[1] = lfs_tole32(d->tail[1]);
339+
}
340+
341+
static void lfs_entry_fromle32(struct lfs_disk_entry *d) {
342+
d->u.dir[0] = lfs_fromle32(d->u.dir[0]);
343+
d->u.dir[1] = lfs_fromle32(d->u.dir[1]);
344+
}
345+
346+
static void lfs_entry_tole32(struct lfs_disk_entry *d) {
347+
d->u.dir[0] = lfs_tole32(d->u.dir[0]);
348+
d->u.dir[1] = lfs_tole32(d->u.dir[1]);
349+
}
350+
351+
static void lfs_superblock_fromle32(struct lfs_disk_superblock *d) {
352+
d->root[0] = lfs_fromle32(d->root[0]);
353+
d->root[1] = lfs_fromle32(d->root[1]);
354+
d->block_size = lfs_fromle32(d->block_size);
355+
d->block_count = lfs_fromle32(d->block_count);
356+
d->version = lfs_fromle32(d->version);
357+
}
358+
359+
static void lfs_superblock_tole32(struct lfs_disk_superblock *d) {
360+
d->root[0] = lfs_tole32(d->root[0]);
361+
d->root[1] = lfs_tole32(d->root[1]);
362+
d->block_size = lfs_tole32(d->block_size);
363+
d->block_count = lfs_tole32(d->block_count);
364+
d->version = lfs_tole32(d->version);
365+
}
366+
367+
326368
/// Metadata pair and directory operations ///
327369
static inline void lfs_pairswap(lfs_block_t pair[2]) {
328370
lfs_block_t t = pair[0];
@@ -364,6 +406,7 @@ static int lfs_dir_alloc(lfs_t *lfs, lfs_dir_t *dir) {
364406
// rather than clobbering one of the blocks we just pretend
365407
// the revision may be valid
366408
int err = lfs_bd_read(lfs, dir->pair[0], 0, &dir->d.rev, 4);
409+
dir->d.rev = lfs_fromle32(dir->d.rev);
367410
if (err) {
368411
return err;
369412
}
@@ -389,6 +432,7 @@ static int lfs_dir_fetch(lfs_t *lfs,
389432
for (int i = 0; i < 2; i++) {
390433
struct lfs_disk_dir test;
391434
int err = lfs_bd_read(lfs, tpair[i], 0, &test, sizeof(test));
435+
lfs_dir_fromle32(&test);
392436
if (err) {
393437
return err;
394438
}
@@ -403,7 +447,9 @@ static int lfs_dir_fetch(lfs_t *lfs,
403447
}
404448

405449
uint32_t crc = 0xffffffff;
450+
lfs_dir_tole32(&test);
406451
lfs_crc(&crc, &test, sizeof(test));
452+
lfs_dir_fromle32(&test);
407453
err = lfs_bd_crc(lfs, tpair[i], sizeof(test),
408454
(0x7fffffff & test.size) - sizeof(test), &crc);
409455
if (err) {
@@ -463,8 +509,10 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
463509
}
464510

465511
uint32_t crc = 0xffffffff;
512+
lfs_dir_tole32(&dir->d);
466513
lfs_crc(&crc, &dir->d, sizeof(dir->d));
467514
err = lfs_bd_prog(lfs, dir->pair[0], 0, &dir->d, sizeof(dir->d));
515+
lfs_dir_fromle32(&dir->d);
468516
if (err) {
469517
if (err == LFS_ERR_CORRUPT) {
470518
goto relocate;
@@ -511,7 +559,9 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
511559
}
512560
}
513561

562+
crc = lfs_tole32(crc);
514563
err = lfs_bd_prog(lfs, dir->pair[0], newoff, &crc, 4);
564+
crc = lfs_fromle32(crc);
515565
if (err) {
516566
if (err == LFS_ERR_CORRUPT) {
517567
goto relocate;
@@ -584,11 +634,14 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
584634
}
585635

586636
static int lfs_dir_update(lfs_t *lfs, lfs_dir_t *dir,
587-
const lfs_entry_t *entry, const void *data) {
588-
return lfs_dir_commit(lfs, dir, (struct lfs_region[]){
637+
lfs_entry_t *entry, const void *data) {
638+
lfs_entry_tole32(&entry->d);
639+
int err = lfs_dir_commit(lfs, dir, (struct lfs_region[]){
589640
{entry->off, sizeof(entry->d), &entry->d, sizeof(entry->d)},
590641
{entry->off+sizeof(entry->d), entry->d.nlen, data, entry->d.nlen}
591642
}, data ? 2 : 1);
643+
lfs_entry_fromle32(&entry->d);
644+
return err;
592645
}
593646

594647
static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
@@ -597,10 +650,14 @@ static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
597650
while (true) {
598651
if (dir->d.size + lfs_entry_size(entry) <= lfs->cfg->block_size) {
599652
entry->off = dir->d.size - 4;
600-
return lfs_dir_commit(lfs, dir, (struct lfs_region[]){
653+
654+
lfs_entry_tole32(&entry->d);
655+
int err = lfs_dir_commit(lfs, dir, (struct lfs_region[]){
601656
{entry->off, 0, &entry->d, sizeof(entry->d)},
602657
{entry->off, 0, data, entry->d.nlen}
603658
}, 2);
659+
lfs_entry_fromle32(&entry->d);
660+
return err;
604661
}
605662

606663
// we need to allocate a new dir block
@@ -614,10 +671,12 @@ static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
614671
newdir.d.tail[0] = dir->d.tail[0];
615672
newdir.d.tail[1] = dir->d.tail[1];
616673
entry->off = newdir.d.size - 4;
674+
lfs_entry_tole32(&entry->d);
617675
err = lfs_dir_commit(lfs, &newdir, (struct lfs_region[]){
618676
{entry->off, 0, &entry->d, sizeof(entry->d)},
619677
{entry->off, 0, data, entry->d.nlen}
620678
}, 2);
679+
lfs_entry_fromle32(&entry->d);
621680
if (err) {
622681
return err;
623682
}
@@ -703,6 +762,7 @@ static int lfs_dir_next(lfs_t *lfs, lfs_dir_t *dir, lfs_entry_t *entry) {
703762

704763
int err = lfs_bd_read(lfs, dir->pair[0], dir->off,
705764
&entry->d, sizeof(entry->d));
765+
lfs_entry_fromle32(&entry->d);
706766
if (err) {
707767
return err;
708768
}
@@ -1065,6 +1125,7 @@ static int lfs_ctz_find(lfs_t *lfs,
10651125
lfs_ctz(current));
10661126

10671127
int err = lfs_cache_read(lfs, rcache, pcache, head, 4*skip, &head, 4);
1128+
head = lfs_fromle32(head);
10681129
if (err) {
10691130
return err;
10701131
}
@@ -1140,8 +1201,10 @@ static int lfs_ctz_extend(lfs_t *lfs,
11401201
lfs_size_t skips = lfs_ctz(index) + 1;
11411202

11421203
for (lfs_off_t i = 0; i < skips; i++) {
1204+
head = lfs_tole32(head);
11431205
err = lfs_cache_prog(lfs, pcache, rcache,
11441206
nblock, 4*i, &head, 4);
1207+
head = lfs_fromle32(head);
11451208
if (err) {
11461209
if (err == LFS_ERR_CORRUPT) {
11471210
goto relocate;
@@ -1152,6 +1215,7 @@ static int lfs_ctz_extend(lfs_t *lfs,
11521215
if (i != skips-1) {
11531216
err = lfs_cache_read(lfs, rcache, NULL,
11541217
head, 4*i, &head, 4);
1218+
head = lfs_fromle32(head);
11551219
if (err) {
11561220
return err;
11571221
}
@@ -1196,6 +1260,8 @@ static int lfs_ctz_traverse(lfs_t *lfs,
11961260
lfs_block_t heads[2];
11971261
int count = 2 - (index & 1);
11981262
err = lfs_cache_read(lfs, rcache, pcache, head, 0, &heads, count*4);
1263+
heads[0] = lfs_fromle32(heads[0]);
1264+
heads[1] = lfs_fromle32(heads[1]);
11991265
if (err) {
12001266
return err;
12011267
}
@@ -1456,6 +1522,7 @@ int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) {
14561522
lfs_entry_t entry = {.off = file->poff};
14571523
err = lfs_bd_read(lfs, cwd.pair[0], entry.off,
14581524
&entry.d, sizeof(entry.d));
1525+
lfs_entry_fromle32(&entry.d);
14591526
if (err) {
14601527
return err;
14611528
}
@@ -2075,6 +2142,7 @@ int lfs_format(lfs_t *lfs, const struct lfs_config *cfg) {
20752142
superdir.d.size = sizeof(superdir.d) + sizeof(superblock.d) + 4;
20762143

20772144
// write both pairs to be safe
2145+
lfs_superblock_tole32(&superblock.d);
20782146
bool valid = false;
20792147
for (int i = 0; i < 2; i++) {
20802148
err = lfs_dir_commit(lfs, &superdir, (struct lfs_region[]){
@@ -2125,6 +2193,7 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) {
21252193
if (!err) {
21262194
err = lfs_bd_read(lfs, dir.pair[0], sizeof(dir.d),
21272195
&superblock.d, sizeof(superblock.d));
2196+
lfs_superblock_fromle32(&superblock.d);
21282197
if (err) {
21292198
return err;
21302199
}
@@ -2182,6 +2251,7 @@ int lfs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) {
21822251
while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
21832252
err = lfs_bd_read(lfs, dir.pair[0], dir.off,
21842253
&entry.d, sizeof(entry.d));
2254+
lfs_entry_fromle32(&entry.d);
21852255
if (err) {
21862256
return err;
21872257
}
@@ -2222,7 +2292,7 @@ int lfs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) {
22222292
}
22232293
}
22242294
}
2225-
2295+
22262296
return 0;
22272297
}
22282298

@@ -2256,7 +2326,7 @@ static int lfs_parent(lfs_t *lfs, const lfs_block_t dir[2],
22562326
if (lfs_pairisnull(lfs->root)) {
22572327
return 0;
22582328
}
2259-
2329+
22602330
parent->d.tail[0] = 0;
22612331
parent->d.tail[1] = 1;
22622332

@@ -2317,7 +2387,7 @@ static int lfs_moved(lfs_t *lfs, const void *e) {
23172387
break;
23182388
}
23192389

2320-
if (!(0x80 & entry.d.type) &&
2390+
if (!(0x80 & entry.d.type) &&
23212391
memcmp(&entry.d.u, e, sizeof(entry.d.u)) == 0) {
23222392
return true;
23232393
}

lfs_util.h

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,29 @@ static inline int lfs_scmp(uint32_t a, uint32_t b) {
7070
return (int)(unsigned)(a - b);
7171
}
7272

73+
static inline uint32_t lfs_fromle32(uint32_t a) {
74+
#if ( \
75+
(defined( BYTE_ORDER ) && BYTE_ORDER == ORDER_LITTLE_ENDIAN ) || \
76+
(defined(__BYTE_ORDER ) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN ) || \
77+
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
78+
return a;
79+
#elif ( \
80+
(defined( BYTE_ORDER ) && BYTE_ORDER == ORDER_BIG_ENDIAN ) || \
81+
(defined(__BYTE_ORDER ) && __BYTE_ORDER == __ORDER_BIG_ENDIAN ) || \
82+
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
83+
return __builtin_bswap32(a);
84+
#else
85+
return (((uint8_t*)&a)[0] << 0) |
86+
(((uint8_t*)&a)[1] << 8) |
87+
(((uint8_t*)&a)[2] << 16) |
88+
(((uint8_t*)&a)[3] << 24);
89+
#endif
90+
}
91+
92+
static inline uint32_t lfs_tole32(uint32_t a) {
93+
return lfs_fromle32(a);
94+
}
95+
7396
// CRC-32 with polynomial = 0x04c11db7
7497
void lfs_crc(uint32_t *crc, const void *buffer, size_t size);
7598

0 commit comments

Comments
 (0)