Skip to content

Commit 11440f6

Browse files
gekygeky
committed
Removed toolchain specific warnings
- Comparisons with differently signed integer types - Incorrectly signed constant - Unreachable default returns - Leaked uninitialized variables in relocate goto statements
1 parent 6fc33f4 commit 11440f6

File tree

1 file changed

+135
-131
lines changed

1 file changed

+135
-131
lines changed

‎littlefs/lfs.c

Lines changed: 135 additions & 131 deletions
Original file line numberDiff line numberDiff line change
@@ -373,8 +373,8 @@ static int lfs_dir_alloc(lfs_t *lfs, lfs_dir_t *dir) {
373373
// set defaults
374374
dir->d.rev += 1;
375375
dir->d.size = sizeof(dir->d)+4;
376-
dir->d.tail[0] = -1;
377-
dir->d.tail[1] = -1;
376+
dir->d.tail[0] = 0xffffffff;
377+
dir->d.tail[1] = 0xffffffff;
378378
dir->off = sizeof(dir->d);
379379

380380
// don't write out yet, let caller take care of that
@@ -455,88 +455,91 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
455455
bool relocated = false;
456456

457457
while (true) {
458-
int err = lfs_bd_erase(lfs, dir->pair[0]);
459-
if (err) {
460-
if (err == LFS_ERR_CORRUPT) {
461-
goto relocate;
458+
if (true) {
459+
int err = lfs_bd_erase(lfs, dir->pair[0]);
460+
if (err) {
461+
if (err == LFS_ERR_CORRUPT) {
462+
goto relocate;
463+
}
464+
return err;
462465
}
463-
return err;
464-
}
465466

466-
uint32_t crc = 0xffffffff;
467-
lfs_crc(&crc, &dir->d, sizeof(dir->d));
468-
err = lfs_bd_prog(lfs, dir->pair[0], 0, &dir->d, sizeof(dir->d));
469-
if (err) {
470-
if (err == LFS_ERR_CORRUPT) {
471-
goto relocate;
467+
uint32_t crc = 0xffffffff;
468+
lfs_crc(&crc, &dir->d, sizeof(dir->d));
469+
err = lfs_bd_prog(lfs, dir->pair[0], 0, &dir->d, sizeof(dir->d));
470+
if (err) {
471+
if (err == LFS_ERR_CORRUPT) {
472+
goto relocate;
473+
}
474+
return err;
472475
}
473-
return err;
474-
}
475476

476-
int i = 0;
477-
lfs_off_t oldoff = sizeof(dir->d);
478-
lfs_off_t newoff = sizeof(dir->d);
479-
while (newoff < (0x7fffffff & dir->d.size)-4) {
480-
if (i < count && regions[i].oldoff == oldoff) {
481-
lfs_crc(&crc, regions[i].newdata, regions[i].newlen);
482-
int err = lfs_bd_prog(lfs, dir->pair[0],
483-
newoff, regions[i].newdata, regions[i].newlen);
484-
if (err) {
485-
if (err == LFS_ERR_CORRUPT) {
486-
goto relocate;
477+
int i = 0;
478+
lfs_off_t oldoff = sizeof(dir->d);
479+
lfs_off_t newoff = sizeof(dir->d);
480+
while (newoff < (0x7fffffff & dir->d.size)-4) {
481+
if (i < count && regions[i].oldoff == oldoff) {
482+
lfs_crc(&crc, regions[i].newdata, regions[i].newlen);
483+
int err = lfs_bd_prog(lfs, dir->pair[0],
484+
newoff, regions[i].newdata, regions[i].newlen);
485+
if (err) {
486+
if (err == LFS_ERR_CORRUPT) {
487+
goto relocate;
488+
}
489+
return err;
487490
}
488-
return err;
489-
}
490491

491-
oldoff += regions[i].oldlen;
492-
newoff += regions[i].newlen;
493-
i += 1;
494-
} else {
495-
uint8_t data;
496-
int err = lfs_bd_read(lfs, oldpair[1], oldoff, &data, 1);
497-
if (err) {
498-
return err;
499-
}
492+
oldoff += regions[i].oldlen;
493+
newoff += regions[i].newlen;
494+
i += 1;
495+
} else {
496+
uint8_t data;
497+
int err = lfs_bd_read(lfs, oldpair[1], oldoff, &data, 1);
498+
if (err) {
499+
return err;
500+
}
500501

501-
lfs_crc(&crc, &data, 1);
502-
err = lfs_bd_prog(lfs, dir->pair[0], newoff, &data, 1);
503-
if (err) {
504-
if (err == LFS_ERR_CORRUPT) {
505-
goto relocate;
502+
lfs_crc(&crc, &data, 1);
503+
err = lfs_bd_prog(lfs, dir->pair[0], newoff, &data, 1);
504+
if (err) {
505+
if (err == LFS_ERR_CORRUPT) {
506+
goto relocate;
507+
}
508+
return err;
506509
}
507-
return err;
508-
}
509510

510-
oldoff += 1;
511-
newoff += 1;
511+
oldoff += 1;
512+
newoff += 1;
513+
}
512514
}
513-
}
514515

515-
err = lfs_bd_prog(lfs, dir->pair[0], newoff, &crc, 4);
516-
if (err) {
517-
if (err == LFS_ERR_CORRUPT) {
518-
goto relocate;
516+
err = lfs_bd_prog(lfs, dir->pair[0], newoff, &crc, 4);
517+
if (err) {
518+
if (err == LFS_ERR_CORRUPT) {
519+
goto relocate;
520+
}
521+
return err;
519522
}
520-
return err;
521-
}
522523

523-
err = lfs_bd_sync(lfs);
524-
if (err) {
525-
if (err == LFS_ERR_CORRUPT) {
526-
goto relocate;
524+
err = lfs_bd_sync(lfs);
525+
if (err) {
526+
if (err == LFS_ERR_CORRUPT) {
527+
goto relocate;
528+
}
529+
return err;
527530
}
528-
return err;
529-
}
530531

531-
// successful commit, check checksum to make sure
532-
crc = 0xffffffff;
533-
err = lfs_bd_crc(lfs, dir->pair[0], 0, 0x7fffffff & dir->d.size, &crc);
534-
if (err) {
535-
return err;
536-
}
532+
// successful commit, check checksum to make sure
533+
crc = 0xffffffff;
534+
err = lfs_bd_crc(lfs, dir->pair[0], 0,
535+
0x7fffffff & dir->d.size, &crc);
536+
if (err) {
537+
return err;
538+
}
537539

538-
if (crc == 0) {
539-
break;
540+
if (crc == 0) {
541+
break;
542+
}
540543
}
541544

542545
relocate:
@@ -554,7 +557,7 @@ static int lfs_dir_commit(lfs_t *lfs, lfs_dir_t *dir,
554557
}
555558

556559
// relocate half of pair
557-
err = lfs_alloc(lfs, &dir->pair[0]);
560+
int err = lfs_alloc(lfs, &dir->pair[0]);
558561
if (err) {
559562
return err;
560563
}
@@ -791,8 +794,6 @@ static int lfs_dir_find(lfs_t *lfs, lfs_dir_t *dir,
791794
return err;
792795
}
793796
}
794-
795-
return 0;
796797
}
797798

798799

@@ -1020,7 +1021,7 @@ static int lfs_index_find(lfs_t *lfs,
10201021
lfs_block_t head, lfs_size_t size,
10211022
lfs_size_t pos, lfs_block_t *block, lfs_off_t *off) {
10221023
if (size == 0) {
1023-
*block = -1;
1024+
*block = 0xffffffff;
10241025
*off = 0;
10251026
return 0;
10261027
}
@@ -1052,79 +1053,84 @@ static int lfs_index_extend(lfs_t *lfs,
10521053
lfs_block_t head, lfs_size_t size,
10531054
lfs_off_t *block, lfs_block_t *off) {
10541055
while (true) {
1055-
// go ahead and grab a block
1056-
int err = lfs_alloc(lfs, block);
1057-
if (err) {
1058-
return err;
1059-
}
1060-
assert(*block >= 2 && *block <= lfs->cfg->block_count);
1056+
if (true) {
1057+
// go ahead and grab a block
1058+
int err = lfs_alloc(lfs, block);
1059+
if (err) {
1060+
return err;
1061+
}
1062+
assert(*block >= 2 && *block <= lfs->cfg->block_count);
10611063

1062-
err = lfs_bd_erase(lfs, *block);
1063-
if (err) {
1064-
if (err == LFS_ERR_CORRUPT) {
1065-
goto relocate;
1064+
err = lfs_bd_erase(lfs, *block);
1065+
if (err) {
1066+
if (err == LFS_ERR_CORRUPT) {
1067+
goto relocate;
1068+
}
1069+
return err;
10661070
}
1067-
return err;
1068-
}
10691071

1070-
if (size == 0) {
1071-
*off = 0;
1072-
return 0;
1073-
}
1072+
if (size == 0) {
1073+
*off = 0;
1074+
return 0;
1075+
}
10741076

1075-
size -= 1;
1076-
lfs_off_t index = lfs_index(lfs, &size);
1077-
size += 1;
1077+
size -= 1;
1078+
lfs_off_t index = lfs_index(lfs, &size);
1079+
size += 1;
10781080

1079-
// just copy out the last block if it is incomplete
1080-
if (size != lfs->cfg->block_size) {
1081-
for (lfs_off_t i = 0; i < size; i++) {
1082-
uint8_t data;
1083-
int err = lfs_cache_read(lfs, rcache, NULL, head, i, &data, 1);
1084-
if (err) {
1085-
return err;
1081+
// just copy out the last block if it is incomplete
1082+
if (size != lfs->cfg->block_size) {
1083+
for (lfs_off_t i = 0; i < size; i++) {
1084+
uint8_t data;
1085+
int err = lfs_cache_read(lfs, rcache, NULL,
1086+
head, i, &data, 1);
1087+
if (err) {
1088+
return err;
1089+
}
1090+
1091+
err = lfs_cache_prog(lfs, pcache, rcache,
1092+
*block, i, &data, 1);
1093+
if (err) {
1094+
if (err == LFS_ERR_CORRUPT) {
1095+
goto relocate;
1096+
}
1097+
return err;
1098+
}
10861099
}
10871100

1088-
err = lfs_cache_prog(lfs, pcache, rcache, *block, i, &data, 1);
1101+
*off = size;
1102+
return 0;
1103+
}
1104+
1105+
// append block
1106+
index += 1;
1107+
lfs_size_t skips = lfs_ctz(index) + 1;
1108+
1109+
for (lfs_off_t i = 0; i < skips; i++) {
1110+
int err = lfs_cache_prog(lfs, pcache, rcache,
1111+
*block, 4*i, &head, 4);
10891112
if (err) {
10901113
if (err == LFS_ERR_CORRUPT) {
10911114
goto relocate;
10921115
}
10931116
return err;
10941117
}
1095-
}
1096-
1097-
*off = size;
1098-
return 0;
1099-
}
1100-
1101-
// append block
1102-
index += 1;
1103-
lfs_size_t skips = lfs_ctz(index) + 1;
11041118

1105-
for (lfs_off_t i = 0; i < skips; i++) {
1106-
int err = lfs_cache_prog(lfs, pcache, rcache,
1107-
*block, 4*i, &head, 4);
1108-
if (err) {
1109-
if (err == LFS_ERR_CORRUPT) {
1110-
goto relocate;
1119+
if (i != skips-1) {
1120+
err = lfs_cache_read(lfs, rcache, NULL,
1121+
head, 4*i, &head, 4);
1122+
if (err) {
1123+
return err;
1124+
}
11111125
}
1112-
return err;
1113-
}
11141126

1115-
if (i != skips-1) {
1116-
err = lfs_cache_read(lfs, rcache, NULL, head, 4*i, &head, 4);
1117-
if (err) {
1118-
return err;
1119-
}
1127+
assert(head >= 2 && head <= lfs->cfg->block_count);
11201128
}
11211129

1122-
assert(head >= 2 && head <= lfs->cfg->block_count);
1130+
*off = 4*skips;
1131+
return 0;
11231132
}
11241133

1125-
*off = 4*skips;
1126-
return 0;
1127-
11281134
relocate:
11291135
LFS_DEBUG("Bad block at %ld", *block);
11301136

@@ -1160,8 +1166,6 @@ static int lfs_index_traverse(lfs_t *lfs,
11601166

11611167
index -= 1;
11621168
}
1163-
1164-
return 0;
11651169
}
11661170

11671171

@@ -1199,7 +1203,7 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
11991203
entry.d.elen = sizeof(entry.d) - 4;
12001204
entry.d.alen = 0;
12011205
entry.d.nlen = strlen(path);
1202-
entry.d.u.file.head = -1;
1206+
entry.d.u.file.head = 0xffffffff;
12031207
entry.d.u.file.size = 0;
12041208
err = lfs_dir_append(lfs, &cwd, &entry, path);
12051209
if (err) {
@@ -1221,7 +1225,7 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
12211225
file->pos = 0;
12221226

12231227
if (flags & LFS_O_TRUNC) {
1224-
file->head = -1;
1228+
file->head = 0xffffffff;
12251229
file->size = 0;
12261230
}
12271231

@@ -1588,13 +1592,13 @@ lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
15881592
if (whence == LFS_SEEK_SET) {
15891593
file->pos = off;
15901594
} else if (whence == LFS_SEEK_CUR) {
1591-
if (-off > file->pos) {
1595+
if ((lfs_off_t)-off > file->pos) {
15921596
return LFS_ERR_INVAL;
15931597
}
15941598

15951599
file->pos = file->pos + off;
15961600
} else if (whence == LFS_SEEK_END) {
1597-
if (-off > file->size) {
1601+
if ((lfs_off_t)-off > file->size) {
15981602
return LFS_ERR_INVAL;
15991603
}
16001604

0 commit comments

Comments
 (0)