github-mirrors/thirdparty-littlefs
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-littlefs.git synced 2025-11-01 00:38:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

WIP Consolidated get functions into one

Browse Source
This commit is contained in:
Christopher Haster
2018-07-11 05:52:50 -05:00
parent 5152b973f0
commit 92d957ab40
1 changed files with 62 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
lfs.c
View File

@@ -644,7 +644,8 @@ static int lfs_dir_traverse(lfs_t *lfs, lfs_mdir_t *dir,
int (*cb)(lfs_t *lfs, void *data, lfs_mattr_t attr), int (*cb)(lfs_t *lfs, void *data, lfs_mattr_t attr),
void *data); void *data);
static int lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir, static int lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir,
uint32_t mask, lfs_mattr_t *attr); uint32_t getmask, lfs_tag_t gettag,
lfs_tag_t *gottag, void *getbuffer);
static int lfs_commit_movescan(lfs_t *lfs, void *p, lfs_mattr_t attr) { static int lfs_commit_movescan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
struct lfs_commit_move *move = p; struct lfs_commit_move *move = p;
@@ -669,9 +670,9 @@ static int lfs_commit_movescan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
.etag=move->commit->ptag, .etag=move->commit->ptag,
.stop_at_commit=true}, .stop_at_commit=true},
lfs_tag_isuser(attr.tag) ? 0x7ffff000 : 0x7c3ff000, lfs_tag_isuser(attr.tag) ? 0x7ffff000 : 0x7c3ff000,
&(lfs_mattr_t){ lfs_mktag(lfs_tag_type(attr.tag),
lfs_mktag(lfs_tag_type(attr.tag), move->id.to - move->commit->filter.begin, 0), // TODO can all these filter adjustments be consolidated?
move->id.to - move->commit->filter.begin, 0)}); // TODO can all these filter adjustments be consolidated? NULL, NULL);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -1337,10 +1338,13 @@ static int lfs_dir_getscan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
} }
static int lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir, static int lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir,
uint32_t mask, lfs_mattr_t *attr) { uint32_t getmask, lfs_tag_t gettag,
uint16_t id = lfs_tag_id(attr->tag); lfs_tag_t *foundtag, void *buffer) {
uint16_t id = lfs_tag_id(gettag);
lfs_size_t size = lfs_tag_size(gettag);
lfs_mattr_t attr;
int res = lfs_dir_traverse(lfs, dir, lfs_dir_getscan, int res = lfs_dir_traverse(lfs, dir, lfs_dir_getscan,
&(struct lfs_dir_get){mask, attr->tag, attr}); &(struct lfs_dir_get){getmask, gettag, &attr});
if (res < 0) { if (res < 0) {
return res; return res;
} }
@@ -1349,40 +1353,18 @@ static int lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir,
return LFS_ERR_NOENT; return LFS_ERR_NOENT;
} }
attr->tag = lfs_mktag(0, id, 0) | (attr->tag & 0xffc00fff); if (foundtag) {
return 0; *foundtag = lfs_mktag(0, id, 0) | (attr.tag & 0xffc00fff);
}
static int lfs_dir_getbuffer(lfs_t *lfs, lfs_mdir_t *dir,
uint32_t mask, lfs_mattr_t *attr) {
void *buffer = attr->u.buffer;
lfs_size_t size = lfs_tag_size(attr->tag);
int err = lfs_dir_get(lfs, dir, mask, attr);
if (err) {
return err;
} }
lfs_size_t diff = lfs_min(size, lfs_tag_size(attr->tag)); if (buffer) {
memset((uint8_t*)buffer + diff, 0, size - diff); lfs_size_t diff = lfs_min(size, lfs_tag_size(attr.tag));
err = lfs_bd_read(lfs, attr->u.d.block, attr->u.d.off, buffer, diff); memset((uint8_t*)buffer + diff, 0, size - diff);
if (err) { int err = lfs_bd_read(lfs, attr.u.d.block, attr.u.d.off,
return err; buffer, diff);
} if (err) {
return err;
if (lfs_tag_size(attr->tag) > size) { }
return LFS_ERR_RANGE;
}
return 0;
}
static int lfs_dir_getentry(lfs_t *lfs, lfs_mdir_t *dir,
uint32_t mask, lfs_tag_t tag, lfs_mattr_t *attr) {
attr->tag = tag | sizeof(attr->u);
attr->u.buffer = &attr->u;
int err = lfs_dir_getbuffer(lfs, dir, mask, attr);
if (err && err != LFS_ERR_RANGE) {
return err;
} }
return 0; return 0;
@@ -1390,20 +1372,22 @@ static int lfs_dir_getentry(lfs_t *lfs, lfs_mdir_t *dir,
static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir, static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir,
int16_t id, struct lfs_info *info) { int16_t id, struct lfs_info *info) {
lfs_mattr_t attr = { lfs_mattr_t attr;
lfs_mktag(LFS_TYPE_NAME, id, lfs->name_size+1), int err = lfs_dir_get(lfs, dir, 0x7c3ff000,
.u.buffer=info->name, lfs_mktag(LFS_TYPE_NAME, id, lfs->name_size+1),
}; &attr.tag, info->name);
int err = lfs_dir_getbuffer(lfs, dir, 0x7c3ff000, &attr);
if (err) { if (err) {
return err; return err;
} }
info->type = lfs_tag_type(attr.tag); info->type = lfs_tag_type(attr.tag);
if (lfs_tag_size(attr.tag) > lfs->name_size) {
return LFS_ERR_RANGE;
}
err = lfs_dir_getentry(lfs, dir, 0x7c3ff000, err = lfs_dir_get(lfs, dir, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 8),
&attr.tag, &attr.u);
if (err) { if (err) {
return err; return err;
} }
@@ -1517,8 +1501,9 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
// TODO optimize grab for inline files and like? // TODO optimize grab for inline files and like?
// TODO would this mean more code? // TODO would this mean more code?
// grab the entry data // grab the entry data
int err = lfs_dir_getentry(lfs, dir, 0x7c3ff000, int err = lfs_dir_get(lfs, dir, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, *id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, *id, 8),
&attr.tag, &attr.u);
if (err) { if (err) {
return err; return err;
} }
@@ -1605,8 +1590,9 @@ int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
attr.u.pair[1] = lfs->root[1]; attr.u.pair[1] = lfs->root[1];
} else { } else {
// get dir pair from parent // get dir pair from parent
err = lfs_dir_getentry(lfs, &dir->m, 0x7c3ff000, err = lfs_dir_get(lfs, &dir->m, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 8),
&attr.tag, &attr.u);
if (err) { if (err) {
return err; return err;
} }
@@ -1991,8 +1977,11 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
return LFS_ERR_EXIST; return LFS_ERR_EXIST;
} }
attr.tag = lfs_mktag(LFS_TYPE_STRUCT, id, 0); // TODO allow no entry?
err = lfs_dir_get(lfs, &cwd, 0x7c3ff000, &attr); // TODO move this into one load? If cache >= 8 would work
err = lfs_dir_get(lfs, &cwd, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, id, 8),
&attr.tag, &file->head);
if (err) { if (err) {
return err; return err;
} }
@@ -2023,6 +2012,8 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
} }
if (lfs_tag_type(attr.tag) == LFS_STRUCT_INLINE) { if (lfs_tag_type(attr.tag) == LFS_STRUCT_INLINE) {
// TODO make inline the better path?
// TODO can inline and trunc be combined?
// load inline files // load inline files
file->head = 0xfffffffe; file->head = 0xfffffffe;
file->size = lfs_tag_size(attr.tag); file->size = lfs_tag_size(attr.tag);
@@ -2038,10 +2029,6 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
return err; return err;
} }
} }
} else {
// use ctz list from entry
err = lfs_bd_read(lfs, attr.u.d.block, attr.u.d.off,
&file->head, 2*sizeof(uint32_t));
} }
// truncate if requested // truncate if requested
@@ -2053,7 +2040,7 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
file->head = 0xfffffffe; file->head = 0xfffffffe;
file->size = 0; file->size = 0;
file->flags |= LFS_F_INLINE; file->flags |= LFS_F_INLINE;
file->cache.block = file->head; file->cache.block = 0xfffffffe;
file->cache.off = 0; file->cache.off = 0;
} }
@@ -2659,8 +2646,9 @@ int lfs_remove(lfs_t *lfs, const char *path) {
if (type == LFS_TYPE_DIR) { if (type == LFS_TYPE_DIR) {
// must be empty before removal // must be empty before removal
lfs_mattr_t attr; lfs_mattr_t attr;
err = lfs_dir_getentry(lfs, &cwd, 0x7c3ff000, err = lfs_dir_get(lfs, &cwd, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 8),
&attr.tag, &attr.u);
if (err) { if (err) {
return err; return err;
} }
@@ -2739,8 +2727,9 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
if (prevtype == LFS_TYPE_DIR) { if (prevtype == LFS_TYPE_DIR) {
// must be empty before removal // must be empty before removal
lfs_mattr_t prevattr; lfs_mattr_t prevattr;
err = lfs_dir_getentry(lfs, &newcwd, 0x7c3ff000, err = lfs_dir_get(lfs, &newcwd, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, newid, 0), &prevattr); lfs_mktag(LFS_TYPE_STRUCT, newid, 8),
&prevattr.tag, &prevattr.u);
if (err) { if (err) {
return err; return err;
} }
@@ -3069,10 +3058,10 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) {
} }
lfs_superblock_t superblock; lfs_superblock_t superblock;
err = lfs_dir_getbuffer(lfs, &dir, 0x7ffff000, &(lfs_mattr_t){ err = lfs_dir_get(lfs, &dir, 0x7ffff000,
lfs_mktag(LFS_TYPE_SUPERBLOCK, 0, sizeof(superblock)), lfs_mktag(LFS_TYPE_SUPERBLOCK, 0, sizeof(superblock)),
.u.buffer=&superblock}); NULL, &superblock);
if (err && err != LFS_ERR_RANGE) { if (err) {
return err; return err;
} }
@@ -3089,9 +3078,9 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) {
return LFS_ERR_INVAL; return LFS_ERR_INVAL;
} }
err = lfs_dir_getbuffer(lfs, &dir, 0x7ffff000, &(lfs_mattr_t){ err = lfs_dir_get(lfs, &dir, 0x7ffff000,
lfs_mktag(LFS_STRUCT_DIR, 0, sizeof(lfs->root)), lfs_mktag(LFS_STRUCT_DIR, 0, sizeof(lfs->root)),
.u.buffer=lfs->root}); NULL, &lfs->root);
if (err) { if (err) {
return err; return err;
} }
@@ -3164,8 +3153,9 @@ int lfs_fs_traverse(lfs_t *lfs,
for (uint16_t id = 0; id < dir.count; id++) { for (uint16_t id = 0; id < dir.count; id++) {
lfs_mattr_t attr; lfs_mattr_t attr;
int err = lfs_dir_getentry(lfs, &dir, 0x7c3ff000, int err = lfs_dir_get(lfs, &dir, 0x7c3ff000,
lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 8),
&attr.tag, &attr.u);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
continue; continue;
@@ -3315,8 +3305,9 @@ static int lfs_parent(lfs_t *lfs, const lfs_block_t pair[2],
if (err != LFS_ERR_NOENT) { if (err != LFS_ERR_NOENT) {
// found our parent // found our parent
int err = lfs_dir_getentry(lfs, parent, int err = lfs_dir_get(lfs, parent,
0x7ffff000, foundtag, attr); 0x7ffff000, foundtag,
&attr->tag, &attr->u);
if (err) { if (err) {
return err; return err;
} }