@@ -323,6 +323,48 @@ static void lfs_alloc_ack(lfs_t *lfs) {
323
323
}
324
324
325
325
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
+
326
368
/// Metadata pair and directory operations ///
327
369
static inline void lfs_pairswap (lfs_block_t pair [2 ]) {
328
370
lfs_block_t t = pair [0 ];
@@ -364,6 +406,7 @@ static int lfs_dir_alloc(lfs_t *lfs, lfs_dir_t *dir) {
364
406
// rather than clobbering one of the blocks we just pretend
365
407
// the revision may be valid
366
408
int err = lfs_bd_read (lfs , dir -> pair [0 ], 0 , & dir -> d .rev , 4 );
409
+ dir -> d .rev = lfs_fromle32 (dir -> d .rev );
367
410
if (err ) {
368
411
return err ;
369
412
}
@@ -389,6 +432,7 @@ static int lfs_dir_fetch(lfs_t *lfs,
389
432
for (int i = 0 ; i < 2 ; i ++ ) {
390
433
struct lfs_disk_dir test ;
391
434
int err = lfs_bd_read (lfs , tpair [i ], 0 , & test , sizeof (test ));
435
+ lfs_dir_fromle32 (& test );
392
436
if (err ) {
393
437
return err ;
394
438
}
@@ -403,7 +447,9 @@ static int lfs_dir_fetch(lfs_t *lfs,
403
447
}
404
448
405
449
uint32_t crc = 0xffffffff ;
450
+ lfs_dir_tole32 (& test );
406
451
lfs_crc (& crc , & test , sizeof (test ));
452
+ lfs_dir_fromle32 (& test );
407
453
err = lfs_bd_crc (lfs , tpair [i ], sizeof (test ),
408
454
(0x7fffffff & test .size ) - sizeof (test ), & crc );
409
455
if (err ) {
@@ -463,8 +509,10 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
463
509
}
464
510
465
511
uint32_t crc = 0xffffffff ;
512
+ lfs_dir_tole32 (& dir -> d );
466
513
lfs_crc (& crc , & dir -> d , sizeof (dir -> d ));
467
514
err = lfs_bd_prog (lfs , dir -> pair [0 ], 0 , & dir -> d , sizeof (dir -> d ));
515
+ lfs_dir_fromle32 (& dir -> d );
468
516
if (err ) {
469
517
if (err == LFS_ERR_CORRUPT ) {
470
518
goto relocate ;
@@ -511,7 +559,9 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
511
559
}
512
560
}
513
561
562
+ crc = lfs_tole32 (crc );
514
563
err = lfs_bd_prog (lfs , dir -> pair [0 ], newoff , & crc , 4 );
564
+ crc = lfs_fromle32 (crc );
515
565
if (err ) {
516
566
if (err == LFS_ERR_CORRUPT ) {
517
567
goto relocate ;
@@ -584,11 +634,14 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
584
634
}
585
635
586
636
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 []){
589
640
{entry -> off , sizeof (entry -> d ), & entry -> d , sizeof (entry -> d )},
590
641
{entry -> off + sizeof (entry -> d ), entry -> d .nlen , data , entry -> d .nlen }
591
642
}, data ? 2 : 1 );
643
+ lfs_entry_fromle32 (& entry -> d );
644
+ return err ;
592
645
}
593
646
594
647
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,
597
650
while (true) {
598
651
if (dir -> d .size + lfs_entry_size (entry ) <= lfs -> cfg -> block_size ) {
599
652
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 []){
601
656
{entry -> off , 0 , & entry -> d , sizeof (entry -> d )},
602
657
{entry -> off , 0 , data , entry -> d .nlen }
603
658
}, 2 );
659
+ lfs_entry_fromle32 (& entry -> d );
660
+ return err ;
604
661
}
605
662
606
663
// we need to allocate a new dir block
@@ -614,10 +671,12 @@ static int lfs_dir_append(lfs_t *lfs, lfs_dir_t *dir,
614
671
newdir .d .tail [0 ] = dir -> d .tail [0 ];
615
672
newdir .d .tail [1 ] = dir -> d .tail [1 ];
616
673
entry -> off = newdir .d .size - 4 ;
674
+ lfs_entry_tole32 (& entry -> d );
617
675
err = lfs_dir_commit (lfs , & newdir , (struct lfs_region []){
618
676
{entry -> off , 0 , & entry -> d , sizeof (entry -> d )},
619
677
{entry -> off , 0 , data , entry -> d .nlen }
620
678
}, 2 );
679
+ lfs_entry_fromle32 (& entry -> d );
621
680
if (err ) {
622
681
return err ;
623
682
}
@@ -703,6 +762,7 @@ static int lfs_dir_next(lfs_t *lfs, lfs_dir_t *dir, lfs_entry_t *entry) {
703
762
704
763
int err = lfs_bd_read (lfs , dir -> pair [0 ], dir -> off ,
705
764
& entry -> d , sizeof (entry -> d ));
765
+ lfs_entry_fromle32 (& entry -> d );
706
766
if (err ) {
707
767
return err ;
708
768
}
@@ -1065,6 +1125,7 @@ static int lfs_ctz_find(lfs_t *lfs,
1065
1125
lfs_ctz (current ));
1066
1126
1067
1127
int err = lfs_cache_read (lfs , rcache , pcache , head , 4 * skip , & head , 4 );
1128
+ head = lfs_fromle32 (head );
1068
1129
if (err ) {
1069
1130
return err ;
1070
1131
}
@@ -1140,8 +1201,10 @@ static int lfs_ctz_extend(lfs_t *lfs,
1140
1201
lfs_size_t skips = lfs_ctz (index ) + 1 ;
1141
1202
1142
1203
for (lfs_off_t i = 0 ; i < skips ; i ++ ) {
1204
+ head = lfs_tole32 (head );
1143
1205
err = lfs_cache_prog (lfs , pcache , rcache ,
1144
1206
nblock , 4 * i , & head , 4 );
1207
+ head = lfs_fromle32 (head );
1145
1208
if (err ) {
1146
1209
if (err == LFS_ERR_CORRUPT ) {
1147
1210
goto relocate ;
@@ -1152,6 +1215,7 @@ static int lfs_ctz_extend(lfs_t *lfs,
1152
1215
if (i != skips - 1 ) {
1153
1216
err = lfs_cache_read (lfs , rcache , NULL ,
1154
1217
head , 4 * i , & head , 4 );
1218
+ head = lfs_fromle32 (head );
1155
1219
if (err ) {
1156
1220
return err ;
1157
1221
}
@@ -1196,6 +1260,8 @@ static int lfs_ctz_traverse(lfs_t *lfs,
1196
1260
lfs_block_t heads [2 ];
1197
1261
int count = 2 - (index & 1 );
1198
1262
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 ]);
1199
1265
if (err ) {
1200
1266
return err ;
1201
1267
}
@@ -1456,6 +1522,7 @@ int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) {
1456
1522
lfs_entry_t entry = {.off = file -> poff };
1457
1523
err = lfs_bd_read (lfs , cwd .pair [0 ], entry .off ,
1458
1524
& entry .d , sizeof (entry .d ));
1525
+ lfs_entry_fromle32 (& entry .d );
1459
1526
if (err ) {
1460
1527
return err ;
1461
1528
}
@@ -2075,6 +2142,7 @@ int lfs_format(lfs_t *lfs, const struct lfs_config *cfg) {
2075
2142
superdir .d .size = sizeof (superdir .d ) + sizeof (superblock .d ) + 4 ;
2076
2143
2077
2144
// write both pairs to be safe
2145
+ lfs_superblock_tole32 (& superblock .d );
2078
2146
bool valid = false;
2079
2147
for (int i = 0 ; i < 2 ; i ++ ) {
2080
2148
err = lfs_dir_commit (lfs , & superdir , (struct lfs_region []){
@@ -2125,6 +2193,7 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) {
2125
2193
if (!err ) {
2126
2194
err = lfs_bd_read (lfs , dir .pair [0 ], sizeof (dir .d ),
2127
2195
& superblock .d , sizeof (superblock .d ));
2196
+ lfs_superblock_fromle32 (& superblock .d );
2128
2197
if (err ) {
2129
2198
return err ;
2130
2199
}
@@ -2182,6 +2251,7 @@ int lfs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) {
2182
2251
while (dir .off + sizeof (entry .d ) <= (0x7fffffff & dir .d .size )- 4 ) {
2183
2252
err = lfs_bd_read (lfs , dir .pair [0 ], dir .off ,
2184
2253
& entry .d , sizeof (entry .d ));
2254
+ lfs_entry_fromle32 (& entry .d );
2185
2255
if (err ) {
2186
2256
return err ;
2187
2257
}
@@ -2222,7 +2292,7 @@ int lfs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) {
2222
2292
}
2223
2293
}
2224
2294
}
2225
-
2295
+
2226
2296
return 0 ;
2227
2297
}
2228
2298
@@ -2256,7 +2326,7 @@ static int lfs_parent(lfs_t *lfs, const lfs_block_t dir[2],
2256
2326
if (lfs_pairisnull (lfs -> root )) {
2257
2327
return 0 ;
2258
2328
}
2259
-
2329
+
2260
2330
parent -> d .tail [0 ] = 0 ;
2261
2331
parent -> d .tail [1 ] = 1 ;
2262
2332
@@ -2317,7 +2387,7 @@ static int lfs_moved(lfs_t *lfs, const void *e) {
2317
2387
break ;
2318
2388
}
2319
2389
2320
- if (!(0x80 & entry .d .type ) &&
2390
+ if (!(0x80 & entry .d .type ) &&
2321
2391
memcmp (& entry .d .u , e , sizeof (entry .d .u )) == 0 ) {
2322
2392
return true;
2323
2393
}
0 commit comments