github-mirrors/thirdparty-littlefs
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-littlefs.git synced 2025-10-31 08:42:40 +01:00
Code Issues Packages Projects Releases Wiki Activity

Standardized error values

Browse Source 
Now matches the commonly used errno codes in name with the value
encoded as the negative errno code
This commit is contained in:
Christopher Haster
2017-04-23 22:10:16 -05:00
parent 5790ec2ce4
commit 287b54876e
5 changed files with 52 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
lfs.c
View File

@@ -208,7 +208,7 @@ static int lfs_alloc_scan(lfs_t *lfs, lfs_block_t *block) {
lfs->free.start += lfs->cfg->lookahead; lfs->free.start += lfs->cfg->lookahead;
lfs->free.off = 0; lfs->free.off = 0;
if (lfs_scmp(lfs->free.start, end) > 0) { if (lfs_scmp(lfs->free.start, end) > 0) {
return LFS_ERROR_NO_SPACE; return LFS_ERR_NOSPC;
} }
// find mask of free blocks from tree // find mask of free blocks from tree
@@ -223,7 +223,7 @@ static int lfs_alloc_scan(lfs_t *lfs, lfs_block_t *block) {
static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) { static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) {
// try to scan for free block // try to scan for free block
int err = lfs_alloc_scan(lfs, block); int err = lfs_alloc_scan(lfs, block);
if (err != LFS_ERROR_NO_SPACE) { if (err != LFS_ERR_NOSPC) {
return err; return err;
} }
@@ -329,7 +329,7 @@ static int lfs_dir_fetch(lfs_t *lfs,
if (!valid) { if (!valid) {
LFS_ERROR("Corrupted dir pair at %d %d", tpair[0], tpair[1]); LFS_ERROR("Corrupted dir pair at %d %d", tpair[0], tpair[1]);
return LFS_ERROR_CORRUPT; return LFS_ERR_CORRUPT;
} }
return 0; return 0;
@@ -549,7 +549,7 @@ static int lfs_dir_next(lfs_t *lfs, lfs_dir_t *dir, lfs_entry_t *entry) {
entry->pair[0] = dir->pair[0]; entry->pair[0] = dir->pair[0];
entry->pair[1] = dir->pair[1]; entry->pair[1] = dir->pair[1];
entry->off = dir->off; entry->off = dir->off;
return LFS_ERROR_NO_ENTRY; return LFS_ERR_NOENT;
} }
int err = lfs_dir_fetch(lfs, dir, dir->d.tail); int err = lfs_dir_fetch(lfs, dir, dir->d.tail);
@@ -653,7 +653,7 @@ static int lfs_dir_find(lfs_t *lfs, lfs_dir_t *dir,
// continue on if we hit a directory // continue on if we hit a directory
if (entry->d.type != LFS_TYPE_DIR) { if (entry->d.type != LFS_TYPE_DIR) {
return LFS_ERROR_NOT_DIR; return LFS_ERR_NOTDIR;
} }
int err = lfs_dir_fetch(lfs, dir, entry->d.u.dir); int err = lfs_dir_fetch(lfs, dir, entry->d.u.dir);
@@ -679,8 +679,8 @@ int lfs_mkdir(lfs_t *lfs, const char *path) {
lfs_entry_t entry; lfs_entry_t entry;
err = lfs_dir_find(lfs, &cwd, &entry, &path); err = lfs_dir_find(lfs, &cwd, &entry, &path);
if (err != LFS_ERROR_NO_ENTRY) { if (err != LFS_ERR_NOENT) {
return err ? err : LFS_ERROR_EXISTS; return err ? err : LFS_ERR_EXISTS;
} }
// Build up new directory // Build up new directory
@@ -731,7 +731,7 @@ int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
if (err) { if (err) {
return err; return err;
} else if (entry.d.type != LFS_TYPE_DIR) { } else if (entry.d.type != LFS_TYPE_DIR) {
return LFS_ERROR_NOT_DIR; return LFS_ERR_NOTDIR;
} }
err = lfs_dir_fetch(lfs, dir, entry.d.u.dir); err = lfs_dir_fetch(lfs, dir, entry.d.u.dir);
@@ -772,7 +772,7 @@ int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
lfs_entry_t entry; lfs_entry_t entry;
int err = lfs_dir_next(lfs, dir, &entry); int err = lfs_dir_next(lfs, dir, &entry);
if (err) { if (err) {
return (err == LFS_ERROR_NO_ENTRY) ? 0 : err; return (err == LFS_ERR_NOENT) ? 0 : err;
} }
info->type = entry.d.type & 0xff; info->type = entry.d.type & 0xff;
@@ -800,7 +800,7 @@ int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
while (off > (0x7fffffff & dir->d.size)) { while (off > (0x7fffffff & dir->d.size)) {
off -= 0x7fffffff & dir->d.size; off -= 0x7fffffff & dir->d.size;
if (!(0x80000000 & dir->d.size)) { if (!(0x80000000 & dir->d.size)) {
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
int err = lfs_dir_fetch(lfs, dir, dir->d.tail); int err = lfs_dir_fetch(lfs, dir, dir->d.tail);
@@ -983,13 +983,13 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
} }
err = lfs_dir_find(lfs, &cwd, &file->entry, &path); err = lfs_dir_find(lfs, &cwd, &file->entry, &path);
if (err && err != LFS_ERROR_NO_ENTRY) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
if (err == LFS_ERROR_NO_ENTRY) { if (err == LFS_ERR_NOENT) {
if (!(flags & LFS_O_CREAT)) { if (!(flags & LFS_O_CREAT)) {
return LFS_ERROR_NO_ENTRY; return LFS_ERR_NOENT;
} }
// create entry to remember name // create entry to remember name
@@ -1002,9 +1002,9 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
return err; return err;
} }
} else if (file->entry.d.type == LFS_TYPE_DIR) { } else if (file->entry.d.type == LFS_TYPE_DIR) {
return LFS_ERROR_IS_DIR; return LFS_ERR_ISDIR;
} else if (flags & LFS_O_EXCL) { } else if (flags & LFS_O_EXCL) {
return LFS_ERROR_EXISTS; return LFS_ERR_EXISTS;
} }
file->wpos = 0; file->wpos = 0;
@@ -1092,7 +1092,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
lfs_size_t nsize = size; lfs_size_t nsize = size;
if ((file->flags & 3) == LFS_O_WRONLY) { if ((file->flags & 3) == LFS_O_WRONLY) {
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
while (nsize > 0) { while (nsize > 0) {
@@ -1128,7 +1128,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
lfs_size_t nsize = size; lfs_size_t nsize = size;
if ((file->flags & 3) == LFS_O_RDONLY) { if ((file->flags & 3) == LFS_O_RDONLY) {
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
while (nsize > 0) { while (nsize > 0) {
@@ -1284,7 +1284,7 @@ int lfs_remove(lfs_t *lfs, const char *path) {
if (err) { if (err) {
return err; return err;
} else if (dir.d.size != sizeof(dir.d)) { } else if (dir.d.size != sizeof(dir.d)) {
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
} }
@@ -1329,14 +1329,14 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
lfs_entry_t preventry; lfs_entry_t preventry;
err = lfs_dir_find(lfs, &newcwd, &preventry, &newpath); err = lfs_dir_find(lfs, &newcwd, &preventry, &newpath);
if (err && err != LFS_ERROR_NO_ENTRY) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
bool prevexists = (err != LFS_ERROR_NO_ENTRY); bool prevexists = (err != LFS_ERR_NOENT);
// must have same type // must have same type
if (prevexists && preventry.d.type != oldentry.d.type) { if (prevexists && preventry.d.type != oldentry.d.type) {
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
lfs_dir_t dir; lfs_dir_t dir;
@@ -1348,7 +1348,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
if (err) { if (err) {
return err; return err;
} else if (dir.d.size != sizeof(dir.d)) { } else if (dir.d.size != sizeof(dir.d)) {
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
} }
@@ -1412,7 +1412,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
} else { } else {
lfs->rcache.buffer = malloc(lfs->cfg->read_size); lfs->rcache.buffer = malloc(lfs->cfg->read_size);
if (!lfs->rcache.buffer) { if (!lfs->rcache.buffer) {
return LFS_ERROR_NO_MEM; return LFS_ERR_NOMEM;
} }
} }
@@ -1423,7 +1423,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
} else { } else {
lfs->pcache.buffer = malloc(lfs->cfg->prog_size); lfs->pcache.buffer = malloc(lfs->cfg->prog_size);
if (!lfs->pcache.buffer) { if (!lfs->pcache.buffer) {
return LFS_ERROR_NO_MEM; return LFS_ERR_NOMEM;
} }
} }
@@ -1433,7 +1433,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) {
} else { } else {
lfs->free.lookahead = malloc(lfs->cfg->lookahead/8); lfs->free.lookahead = malloc(lfs->cfg->lookahead/8);
if (!lfs->free.lookahead) { if (!lfs->free.lookahead) {
return LFS_ERROR_NO_MEM; return LFS_ERR_NOMEM;
} }
} }
@@ -1544,17 +1544,17 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) {
lfs->root[1] = superblock.d.root[1]; lfs->root[1] = superblock.d.root[1];
} }
if (err == LFS_ERROR_CORRUPT || if (err == LFS_ERR_CORRUPT ||
memcmp(superblock.d.magic, "littlefs", 8) != 0) { memcmp(superblock.d.magic, "littlefs", 8) != 0) {
LFS_ERROR("Invalid superblock at %d %d", dir.pair[0], dir.pair[1]); LFS_ERROR("Invalid superblock at %d %d", dir.pair[0], dir.pair[1]);
return LFS_ERROR_CORRUPT; return LFS_ERR_CORRUPT;
} }
if (superblock.d.version > 0x0000ffff) { if (superblock.d.version > 0x0000ffff) {
LFS_ERROR("Invalid version %d.%d\n", LFS_ERROR("Invalid version %d.%d\n",
0xffff & (superblock.d.version >> 16), 0xffff & (superblock.d.version >> 16),
0xffff & (superblock.d.version >> 0)); 0xffff & (superblock.d.version >> 0));
return LFS_ERROR_INVALID; return LFS_ERR_INVAL;
} }
return err; return err;
@@ -1637,11 +1637,11 @@ static int lfs_parent(lfs_t *lfs, const lfs_block_t dir[2]) {
while (true) { while (true) {
int err = lfs_dir_next(lfs, &parent, &entry); int err = lfs_dir_next(lfs, &parent, &entry);
if (err && err != LFS_ERROR_NO_ENTRY) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
if (err == LFS_ERROR_NO_ENTRY) { if (err == LFS_ERR_NOENT) {
break; break;
} }

19
lfs.h
View File

@@ -28,15 +28,16 @@ typedef uint32_t lfs_block_t;
// The littefs constants // The littefs constants
enum lfs_error { enum lfs_error {
LFS_ERROR_OK = 0, LFS_ERR_OK = 0,
LFS_ERROR_CORRUPT = -3, LFS_ERR_IO = -5,
LFS_ERROR_NO_ENTRY = -4, LFS_ERR_CORRUPT = -77,
LFS_ERROR_EXISTS = -5, LFS_ERR_NOENT = -2,
LFS_ERROR_NOT_DIR = -6, LFS_ERR_EXISTS = -17,
LFS_ERROR_IS_DIR = -7, LFS_ERR_NOTDIR = -20,
LFS_ERROR_INVALID = -8, LFS_ERR_ISDIR = -21,
LFS_ERROR_NO_SPACE = -9, LFS_ERR_INVAL = -22,
LFS_ERROR_NO_MEM = -10, LFS_ERR_NOSPC = -28,
LFS_ERR_NOMEM = -12,
}; };
enum lfs_type { enum lfs_type {

16
tests/test_dirs.sh
View File

@@ -56,11 +56,11 @@ TEST
echo "--- Directory failures ---" echo "--- Directory failures ---"
tests/test.py << TEST tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "potato") => LFS_ERROR_EXISTS; lfs_mkdir(&lfs, "potato") => LFS_ERR_EXISTS;
lfs_dir_open(&lfs, &dir[0], "tomato") => LFS_ERROR_NO_ENTRY; lfs_dir_open(&lfs, &dir[0], "tomato") => LFS_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "burito") => LFS_ERROR_NOT_DIR; lfs_dir_open(&lfs, &dir[0], "burito") => LFS_ERR_NOTDIR;
lfs_file_open(&lfs, &file[0], "tomato", LFS_O_RDONLY) => LFS_ERROR_NO_ENTRY; lfs_file_open(&lfs, &file[0], "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT;
lfs_file_open(&lfs, &file[0], "potato", LFS_O_RDONLY) => LFS_ERROR_IS_DIR; lfs_file_open(&lfs, &file[0], "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR;
lfs_unmount(&lfs) => 0; lfs_unmount(&lfs) => 0;
TEST TEST
@@ -126,7 +126,7 @@ TEST
echo "--- Directory remove ---" echo "--- Directory remove ---"
tests/test.py << TEST tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "potato") => LFS_ERROR_INVALID; lfs_remove(&lfs, "potato") => LFS_ERR_INVAL;
lfs_remove(&lfs, "potato/sweet") => 0; lfs_remove(&lfs, "potato/sweet") => 0;
lfs_remove(&lfs, "potato/baked") => 0; lfs_remove(&lfs, "potato/baked") => 0;
lfs_remove(&lfs, "potato/fried") => 0; lfs_remove(&lfs, "potato/fried") => 0;
@@ -220,7 +220,7 @@ tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "warmpotato") => 0; lfs_mkdir(&lfs, "warmpotato") => 0;
lfs_mkdir(&lfs, "warmpotato/mushy") => 0; lfs_mkdir(&lfs, "warmpotato/mushy") => 0;
lfs_rename(&lfs, "hotpotato", "warmpotato") => LFS_ERROR_INVALID; lfs_rename(&lfs, "hotpotato", "warmpotato") => LFS_ERR_INVAL;
lfs_remove(&lfs, "warmpotato/mushy") => 0; lfs_remove(&lfs, "warmpotato/mushy") => 0;
lfs_rename(&lfs, "hotpotato", "warmpotato") => 0; lfs_rename(&lfs, "hotpotato", "warmpotato") => 0;
@@ -255,7 +255,7 @@ tests/test.py << TEST
lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0; lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0;
lfs_rename(&lfs, "warmpotato/sweet", "coldpotato/sweet") => 0; lfs_rename(&lfs, "warmpotato/sweet", "coldpotato/sweet") => 0;
lfs_rename(&lfs, "warmpotato/fried", "coldpotato/fried") => 0; lfs_rename(&lfs, "warmpotato/fried", "coldpotato/fried") => 0;
lfs_remove(&lfs, "coldpotato") => LFS_ERROR_INVALID; lfs_remove(&lfs, "coldpotato") => LFS_ERR_INVAL;
lfs_remove(&lfs, "warmpotato") => 0; lfs_remove(&lfs, "warmpotato") => 0;
lfs_unmount(&lfs) => 0; lfs_unmount(&lfs) => 0;
TEST TEST

4
tests/test_format.sh
View File

@@ -13,7 +13,7 @@ echo "--- Invalid superblocks ---"
ln -f -s /dev/null blocks/0 ln -f -s /dev/null blocks/0
ln -f -s /dev/null blocks/1 ln -f -s /dev/null blocks/1
tests/test.py << TEST tests/test.py << TEST
lfs_format(&lfs, &cfg) => LFS_ERROR_CORRUPT; lfs_format(&lfs, &cfg) => LFS_ERR_CORRUPT;
TEST TEST
rm blocks/0 blocks/1 rm blocks/0 blocks/1
@@ -32,7 +32,7 @@ tests/test.py << TEST
TEST TEST
rm blocks/0 blocks/1 rm blocks/0 blocks/1
tests/test.py << TEST tests/test.py << TEST
lfs_mount(&lfs, &cfg) => LFS_ERROR_CORRUPT; lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT;
TEST TEST
echo "--- Valid corrupt mount ---" echo "--- Valid corrupt mount ---"

4
tests/test_orphan.sh
View File

@@ -20,14 +20,14 @@ TEST
rm -v blocks/8 rm -v blocks/8
tests/test.py << TEST tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERROR_NO_ENTRY; lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT;
unsigned before = 0; unsigned before = 0;
lfs_traverse(&lfs, test_count, &before) => 0; lfs_traverse(&lfs, test_count, &before) => 0;
test_log("before", before); test_log("before", before);
lfs_deorphan(&lfs) => 0; lfs_deorphan(&lfs) => 0;
lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERROR_NO_ENTRY; lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT;
unsigned after = 0; unsigned after = 0;
lfs_traverse(&lfs, test_count, &after) => 0; lfs_traverse(&lfs, test_count, &after) => 0;
test_log("after", after); test_log("after", after);