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

Restructured types to use a more flexible bit encoding

Browse Source 
Recall that the 32-bit tag structure contains a 9-bit type. The type
structure then decomposes into a bit more information:
[---   9   ---]
[1|- 4 -|- 4 -]
 ^   ^     ^- specific type
 |   \------- subtype
 \----------- user bit

The main change is an observation from moving type info to the name tag
from the struct tag. Since we don't need the type info in the struct
tag, we can significantly simplify the type structure.
This commit is contained in:
Christopher Haster
2018-07-09 14:13:31 -05:00
parent c1103efb53
commit b7bd34f461
2 changed files with 77 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
lfs.c
View File

@@ -431,24 +431,24 @@ static inline lfs_tag_t lfs_mktag(
return (type << 22) | (id << 12) | size; return (type << 22) | (id << 12) | size;
} }
static inline bool lfs_tag_valid(lfs_tag_t tag) { static inline bool lfs_tag_isvalid(lfs_tag_t tag) {
return !(tag & 0x80000000); return !(tag & 0x80000000);
} }
static inline bool lfs_tag_isuser(lfs_tag_t tag) {
return (tag & 0x40000000);
}
static inline bool lfs_tag_hasid(lfs_tag_t tag) {
return (tag & 0x60000000) != 0x20000000;
}
static inline uint16_t lfs_tag_type(lfs_tag_t tag) { static inline uint16_t lfs_tag_type(lfs_tag_t tag) {
return (tag & 0x7fc00000) >> 22; return (tag & 0x7fc00000) >> 22;
} }
static inline uint16_t lfs_tag_scope(lfs_tag_t tag) {
return (tag & 0x70000000) >> 22;
}
static inline uint16_t lfs_tag_subtype(lfs_tag_t tag) { static inline uint16_t lfs_tag_subtype(lfs_tag_t tag) {
return (tag & 0x7e000000) >> 22; return (tag & 0x7c000000) >> 22;
}
static inline uint16_t lfs_tag_struct(lfs_tag_t tag) {
return (tag & 0x71c00000) >> 22;
} }
static inline uint16_t lfs_tag_id(lfs_tag_t tag) { static inline uint16_t lfs_tag_id(lfs_tag_t tag) {
@@ -498,7 +498,7 @@ static int lfs_commit_move(lfs_t *lfs, struct lfs_commit *commit,
static int lfs_commit_commit(lfs_t *lfs, static int lfs_commit_commit(lfs_t *lfs,
struct lfs_commit *commit, lfs_mattr_t attr) { struct lfs_commit *commit, lfs_mattr_t attr) {
// filter out ids // filter out ids
if (lfs_tag_scope(attr.tag) <= LFS_SCOPE_ENTRY && ( if (lfs_tag_hasid(attr.tag) && (
lfs_tag_id(attr.tag) < commit->filter.begin || lfs_tag_id(attr.tag) < commit->filter.begin ||
lfs_tag_id(attr.tag) >= commit->filter.end)) { lfs_tag_id(attr.tag) >= commit->filter.end)) {
return 0; return 0;
@@ -650,21 +650,15 @@ static int lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir,
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;
if (lfs_tag_struct(attr.tag) == LFS_STRUCT_DELETE && if (lfs_tag_type(attr.tag) == LFS_TYPE_DELETE &&
lfs_tag_id(attr.tag) <= move->id.from) { lfs_tag_id(attr.tag) <= move->id.from) {
// something was deleted, we need to move around it // something was deleted, we need to move around it
move->id.from += 1; move->id.from += 1;
return 0; return 0;
} }
// TODO AHHHH, scopes, what about user scope above? // TODO need this if 0x3ff is required?
if (lfs_tag_scope(attr.tag) == LFS_SCOPE_FS || if (!lfs_tag_hasid(attr.tag) || lfs_tag_id(attr.tag) != move->id.from) {
lfs_tag_scope(attr.tag) == LFS_SCOPE_DIR) {
// ignore non-matching ids
return 0;
}
if (lfs_tag_id(attr.tag) != move->id.from) {
// ignore non-matching ids // ignore non-matching ids
return 0; return 0;
} }
@@ -676,8 +670,7 @@ static int lfs_commit_movescan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
.off=move->commit->off, .off=move->commit->off,
.etag=move->commit->ptag, .etag=move->commit->ptag,
.stop_at_commit=true}, .stop_at_commit=true},
(lfs_tag_scope(attr.tag) == LFS_SCOPE_STRUCT) ? // TODO also entry? lfs_tag_isuser(attr.tag) ? 0x7ffff000 : 0x7c3ff000,
0x7e3ff000 : 0x7ffff000,
&(lfs_mattr_t){ &(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?
@@ -728,7 +721,7 @@ static int lfs_commit_globals(lfs_t *lfs, struct lfs_commit *commit,
// TODO check performance/complexity of different strategies here // TODO check performance/complexity of different strategies here
lfs_globals_t res = lfs_globals_xor(source, diff); lfs_globals_t res = lfs_globals_xor(source, diff);
int err = lfs_commit_commit(lfs, commit, (lfs_mattr_t){ int err = lfs_commit_commit(lfs, commit, (lfs_mattr_t){
lfs_mktag(LFS_TYPE_IDELETE, lfs_mktag(LFS_TYPE_GLOBALS,
res.move.id, sizeof(res.move.pair)), res.move.id, sizeof(res.move.pair)),
.u.buffer=res.move.pair}); .u.buffer=res.move.pair});
if (err) { if (err) {
@@ -821,12 +814,12 @@ static int lfs_dir_fetchwith(lfs_t *lfs,
tag = lfs_fromle32(tag) ^ ptag; tag = lfs_fromle32(tag) ^ ptag;
// next commit not yet programmed // next commit not yet programmed
if (lfs_tag_type(ptag) == LFS_TYPE_CRC && !lfs_tag_valid(tag)) { if (lfs_tag_type(ptag) == LFS_TYPE_CRC && !lfs_tag_isvalid(tag)) {
// synthetic move // synthetic move
if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0 if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0
&& cb) { && cb) {
int err = cb(lfs, data, (lfs_mattr_t){ int err = cb(lfs, data, (lfs_mattr_t){
lfs_mktag(LFS_STRUCT_DELETE, lfs_mktag(LFS_TYPE_DELETE,
lfs->globals.move.id, 0)}); lfs->globals.move.id, 0)});
if (err) { if (err) {
return err; return err;
@@ -862,7 +855,7 @@ static int lfs_dir_fetchwith(lfs_t *lfs,
if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0 if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0
&& cb) { && cb) {
int err = cb(lfs, data, (lfs_mattr_t){ int err = cb(lfs, data, (lfs_mattr_t){
lfs_mktag(LFS_STRUCT_DELETE, lfs_mktag(LFS_TYPE_DELETE,
lfs->globals.move.id, 0)}); lfs->globals.move.id, 0)});
if (err) { if (err) {
return err; return err;
@@ -898,14 +891,14 @@ static int lfs_dir_fetchwith(lfs_t *lfs,
return err; return err;
} }
if (lfs_tag_struct(tag) == LFS_STRUCT_TAIL) { if (lfs_tag_subtype(tag) == LFS_TYPE_TAIL) {
temp.split = lfs_tag_type(tag) == LFS_TYPE_HARDTAIL; temp.split = (lfs_tag_type(tag) & 1);
err = lfs_bd_read(lfs, temp.pair[0], off+sizeof(tag), err = lfs_bd_read(lfs, temp.pair[0], off+sizeof(tag),
temp.tail, sizeof(temp.tail)); temp.tail, sizeof(temp.tail));
if (err) { if (err) {
return err; return err;
} }
} else if (lfs_tag_type(tag) == LFS_TYPE_IDELETE) { } else if (lfs_tag_type(tag) == LFS_TYPE_GLOBALS) {
temp.globals.move.id = lfs_tag_id(tag); temp.globals.move.id = lfs_tag_id(tag);
err = lfs_bd_read(lfs, temp.pair[0], off+sizeof(tag), err = lfs_bd_read(lfs, temp.pair[0], off+sizeof(tag),
&temp.globals.move.pair, &temp.globals.move.pair,
@@ -914,12 +907,11 @@ static int lfs_dir_fetchwith(lfs_t *lfs,
return err; return err;
} }
} else { } else {
if (lfs_tag_scope(tag) <= LFS_SCOPE_ENTRY && if (lfs_tag_hasid(tag) && lfs_tag_id(tag) >= temp.count) {
lfs_tag_id(tag) >= temp.count) {
temp.count = lfs_tag_id(tag)+1; temp.count = lfs_tag_id(tag)+1;
} }
if (lfs_tag_struct(tag) == LFS_STRUCT_DELETE) { if (lfs_tag_type(tag) == LFS_TYPE_DELETE) {
temp.count -= 1; temp.count -= 1;
} }
@@ -963,7 +955,7 @@ static int lfs_dir_traverse(lfs_t *lfs, lfs_mdir_t *dir,
// synthetic move // synthetic move
if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0) { if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0) {
int err = cb(lfs, data, (lfs_mattr_t){ int err = cb(lfs, data, (lfs_mattr_t){
lfs_mktag(LFS_STRUCT_DELETE, lfs->globals.move.id, 0)}); lfs_mktag(LFS_TYPE_DELETE, lfs->globals.move.id, 0)});
if (err) { if (err) {
return err; return err;
} }
@@ -1102,7 +1094,7 @@ static int lfs_dir_compact(lfs_t *lfs, lfs_mdir_t *dir, lfs_mattrlist_t *list,
// commit tail, which may be new after last size check // commit tail, which may be new after last size check
// TODO le32 // TODO le32
err = lfs_commit_commit(lfs, &commit, (lfs_mattr_t){ err = lfs_commit_commit(lfs, &commit, (lfs_mattr_t){
lfs_mktag(LFS_STRUCT_TAIL + dir->split*0x8, lfs_mktag(LFS_TYPE_TAIL + dir->split,
0x3ff, sizeof(dir->tail)), 0x3ff, sizeof(dir->tail)),
.u.buffer=dir->tail}); .u.buffer=dir->tail});
if (err) { if (err) {
@@ -1290,7 +1282,7 @@ static int lfs_dir_delete(lfs_t *lfs, lfs_mdir_t *dir, uint16_t id) {
lfs->globals = lfs_globals_xor(&lfs->globals, &dir->globals); lfs->globals = lfs_globals_xor(&lfs->globals, &dir->globals);
int err = lfs_dir_commit(lfs, &pdir, &(lfs_mattrlist_t){ int err = lfs_dir_commit(lfs, &pdir, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_TAIL + pdir.split*0x8, {lfs_mktag(LFS_TYPE_TAIL + pdir.split,
0x3ff, sizeof(pdir.tail)), 0x3ff, sizeof(pdir.tail)),
.u.buffer=pdir.tail}}); .u.buffer=pdir.tail}});
return err; return err;
@@ -1298,7 +1290,7 @@ static int lfs_dir_delete(lfs_t *lfs, lfs_mdir_t *dir, uint16_t id) {
} }
int err = lfs_dir_commit(lfs, dir, &(lfs_mattrlist_t){ int err = lfs_dir_commit(lfs, dir, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_DELETE, id, 0)}}); {lfs_mktag(LFS_TYPE_DELETE, id, 0)}});
if (err) { if (err) {
return err; return err;
} }
@@ -1339,7 +1331,7 @@ static int lfs_dir_getscan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
if ((attr.tag & get->mask) == (get->tag & get->mask)) { if ((attr.tag & get->mask) == (get->tag & get->mask)) {
*get->attr = attr; *get->attr = attr;
return true; return true;
} else if (lfs_tag_type(attr.tag) == LFS_STRUCT_DELETE) { } else if (lfs_tag_type(attr.tag) == LFS_TYPE_DELETE) {
if (lfs_tag_id(attr.tag) <= lfs_tag_id(get->tag)) { if (lfs_tag_id(attr.tag) <= lfs_tag_id(get->tag)) {
get->tag += lfs_mktag(0, 1, 0); get->tag += lfs_mktag(0, 1, 0);
} }
@@ -1403,26 +1395,26 @@ 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_STRUCT_NAME, id, lfs->name_size+1), lfs_mktag(LFS_TYPE_NAME, id, lfs->name_size+1),
.u.buffer=info->name, .u.buffer=info->name,
}; };
int err = lfs_dir_getbuffer(lfs, dir, 0x71fff000, &attr); int err = lfs_dir_getbuffer(lfs, dir, 0x7c3ff000, &attr);
if (err) { if (err) {
return err; return err;
} }
info->type = 0x38 & lfs_tag_subtype(attr.tag); info->type = lfs_tag_type(attr.tag);
err = lfs_dir_getentry(lfs, dir, 0x703ff000, err = lfs_dir_getentry(lfs, dir, 0x7c3ff000,
lfs_mktag(LFS_SCOPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr);
if (err) { if (err) {
return err; return err;
} }
if (lfs_tag_struct(attr.tag) == LFS_STRUCT_CTZ) { if (lfs_tag_type(attr.tag) == LFS_STRUCT_CTZ) {
info->size = attr.u.ctz.size; info->size = attr.u.ctz.size;
} else if (lfs_tag_struct(attr.tag) == LFS_STRUCT_INLINE) { } else if (lfs_tag_type(attr.tag) == LFS_STRUCT_INLINE) {
info->size = lfs_tag_size(attr.tag); info->size = lfs_tag_size(attr.tag);
} }
@@ -1441,7 +1433,7 @@ struct lfs_dir_find {
static int lfs_dir_findscan(lfs_t *lfs, void *p, lfs_mattr_t attr) { static int lfs_dir_findscan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
struct lfs_dir_find *find = p; struct lfs_dir_find *find = p;
if (lfs_tag_struct(attr.tag) == LFS_STRUCT_NAME && if (lfs_tag_subtype(attr.tag) == LFS_TYPE_NAME &&
lfs_tag_size(attr.tag) == find->len) { lfs_tag_size(attr.tag) == find->len) {
int res = lfs_bd_cmp(lfs, attr.u.d.block, attr.u.d.off, int res = lfs_bd_cmp(lfs, attr.u.d.block, attr.u.d.off,
find->name, find->len); find->name, find->len);
@@ -1452,9 +1444,9 @@ static int lfs_dir_findscan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
if (res) { if (res) {
// found a match // found a match
find->tempid = lfs_tag_id(attr.tag); find->tempid = lfs_tag_id(attr.tag);
find->tempfindtype = 0x38 & lfs_tag_subtype(attr.tag); find->tempfindtype = lfs_tag_type(attr.tag);
} }
} else if (lfs_tag_type(attr.tag) == LFS_STRUCT_DELETE) { } else if (lfs_tag_type(attr.tag) == LFS_TYPE_DELETE) {
if (lfs_tag_id(attr.tag) == find->tempid) { if (lfs_tag_id(attr.tag) == find->tempid) {
find->tempid = -1; find->tempid = -1;
} else if (lfs_tag_id(attr.tag) < find->tempid) { } else if (lfs_tag_id(attr.tag) < find->tempid) {
@@ -1569,8 +1561,8 @@ static int lfs_dir_find(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, 0x703ff000, int err = lfs_dir_getentry(lfs, dir, 0x7c3ff000,
lfs_mktag(LFS_SCOPE_STRUCT, find.id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, find.id, 0), &attr);
if (err) { if (err) {
return err; return err;
} }
@@ -1626,7 +1618,7 @@ int lfs_mkdir(lfs_t *lfs, const char *path) {
cwd.tail[0] = dir.pair[0]; cwd.tail[0] = dir.pair[0];
cwd.tail[1] = dir.pair[1]; cwd.tail[1] = dir.pair[1];
err = lfs_dir_commit(lfs, &cwd, &(lfs_mattrlist_t){ err = lfs_dir_commit(lfs, &cwd, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_NAME | LFS_TYPE_DIR, id, nlen), {lfs_mktag(LFS_TYPE_DIR, id, nlen),
.u.buffer=(void*)path}, &(lfs_mattrlist_t){ .u.buffer=(void*)path}, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_DIR, id, sizeof(dir.pair)), {lfs_mktag(LFS_STRUCT_DIR, id, sizeof(dir.pair)),
.u.buffer=dir.pair}, &(lfs_mattrlist_t){ .u.buffer=dir.pair}, &(lfs_mattrlist_t){
@@ -1657,8 +1649,8 @@ 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, 0x703ff000, err = lfs_dir_getentry(lfs, &dir->m, 0x7c3ff000,
lfs_mktag(LFS_SCOPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr);
if (err) { if (err) {
return err; return err;
} }
@@ -2020,7 +2012,7 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
// TODO do we need to make file registered to list to catch updates from this commit? ie if id/cwd change // TODO do we need to make file registered to list to catch updates from this commit? ie if id/cwd change
err = lfs_dir_commit(lfs, &cwd, &(lfs_mattrlist_t){ err = lfs_dir_commit(lfs, &cwd, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_NAME | LFS_TYPE_REG, id, nlen), {lfs_mktag(LFS_TYPE_REG, id, nlen),
.u.buffer=(void*)path}, &(lfs_mattrlist_t){ .u.buffer=(void*)path}, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_INLINE, id, 0)}}}); {lfs_mktag(LFS_STRUCT_INLINE, id, 0)}}});
if (err) { if (err) {
@@ -2043,8 +2035,8 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
return LFS_ERR_EXIST; return LFS_ERR_EXIST;
} }
attr.tag = lfs_mktag(LFS_SCOPE_STRUCT, id, 0); attr.tag = lfs_mktag(LFS_TYPE_STRUCT, id, 0);
err = lfs_dir_get(lfs, &cwd, 0x703ff000, &attr); err = lfs_dir_get(lfs, &cwd, 0x7c3ff000, &attr);
if (err) { if (err) {
return err; return err;
} }
@@ -2074,7 +2066,7 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
} }
} }
if (lfs_tag_struct(attr.tag) == LFS_STRUCT_INLINE) { if (lfs_tag_type(attr.tag) == LFS_STRUCT_INLINE) {
// 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);
@@ -2711,8 +2703,8 @@ 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, 0x703ff000, err = lfs_dir_getentry(lfs, &cwd, 0x7c3ff000,
lfs_mktag(LFS_SCOPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr);
if (err) { if (err) {
return err; return err;
} }
@@ -2791,8 +2783,8 @@ 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, 0x703ff000, err = lfs_dir_getentry(lfs, &newcwd, 0x7c3ff000,
lfs_mktag(LFS_SCOPE_STRUCT, newid, 0), &prevattr); lfs_mktag(LFS_TYPE_STRUCT, newid, 0), &prevattr);
if (err) { if (err) {
return err; return err;
} }
@@ -2828,7 +2820,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
// move over all attributes // move over all attributes
err = lfs_dir_commit(lfs, &newcwd, &(lfs_mattrlist_t){ err = lfs_dir_commit(lfs, &newcwd, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_NAME | oldtype, newid, strlen(newpath)), {lfs_mktag(oldtype, newid, strlen(newpath)),
.u.buffer=(void*)newpath}, &(lfs_mattrlist_t){ .u.buffer=(void*)newpath}, &(lfs_mattrlist_t){
{lfs_mktag(LFS_FROM_MOVE, newid, oldid), {lfs_mktag(LFS_FROM_MOVE, newid, oldid),
.u.dir=&oldcwd}}}); .u.dir=&oldcwd}}});
@@ -3216,8 +3208,8 @@ 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, 0x703ff000, int err = lfs_dir_getentry(lfs, &dir, 0x7c3ff000,
lfs_mktag(LFS_SCOPE_STRUCT, id, 0), &attr); lfs_mktag(LFS_TYPE_STRUCT, id, 0), &attr);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
continue; continue;
@@ -3225,7 +3217,7 @@ int lfs_fs_traverse(lfs_t *lfs,
return err; return err;
} }
if (lfs_tag_struct(attr.tag) == LFS_STRUCT_CTZ) { if (lfs_tag_type(attr.tag) == LFS_STRUCT_CTZ) {
err = lfs_ctz_traverse(lfs, &lfs->rcache, NULL, err = lfs_ctz_traverse(lfs, &lfs->rcache, NULL,
attr.u.ctz.head, attr.u.ctz.size, cb, data); attr.u.ctz.head, attr.u.ctz.size, cb, data);
if (err) { if (err) {
@@ -3384,7 +3376,7 @@ struct lfs_dir_parentscan {
static int lfs_parentscan(lfs_t *lfs, void *p, lfs_mattr_t attr) { static int lfs_parentscan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
struct lfs_dir_parentscan *parentscan = p; struct lfs_dir_parentscan *parentscan = p;
if (lfs_tag_struct(attr.tag) == LFS_STRUCT_DIR) { if (lfs_tag_type(attr.tag) == LFS_STRUCT_DIR) {
int err = lfs_bd_read(lfs, attr.u.d.block, attr.u.d.off, int err = lfs_bd_read(lfs, attr.u.d.block, attr.u.d.off,
&attr.u, sizeof(attr.u)); &attr.u, sizeof(attr.u));
if (err) { if (err) {
@@ -3395,7 +3387,7 @@ static int lfs_parentscan(lfs_t *lfs, void *p, lfs_mattr_t attr) {
// found a match // found a match
parentscan->tempid = lfs_tag_id(attr.tag); parentscan->tempid = lfs_tag_id(attr.tag);
} }
} else if (lfs_tag_struct(attr.tag) == LFS_STRUCT_DELETE) { } else if (lfs_tag_type(attr.tag) == LFS_TYPE_DELETE) {
if (lfs_tag_id(attr.tag) == parentscan->tempid) { if (lfs_tag_id(attr.tag) == parentscan->tempid) {
parentscan->tempid = -1; parentscan->tempid = -1;
} else if (lfs_tag_id(attr.tag) < parentscan->tempid) { } else if (lfs_tag_id(attr.tag) < parentscan->tempid) {
@@ -3428,7 +3420,7 @@ static int lfs_parent(lfs_t *lfs, const lfs_block_t pair[2],
} }
if (parentscan.id != -1) { if (parentscan.id != -1) {
int err = lfs_dir_getentry(lfs, parent, 0x71fff000, int err = lfs_dir_getentry(lfs, parent, 0x7ffff000,
lfs_mktag(LFS_STRUCT_DIR, parentscan.id, 0), attr); lfs_mktag(LFS_STRUCT_DIR, parentscan.id, 0), attr);
if (err) { if (err) {
return err; return err;
@@ -3553,7 +3545,7 @@ static int lfs_relocate(lfs_t *lfs,
parent.tail[0] = newpair[0]; parent.tail[0] = newpair[0];
parent.tail[1] = newpair[1]; parent.tail[1] = newpair[1];
int err = lfs_dir_commit(lfs, &parent, &(lfs_mattrlist_t){ int err = lfs_dir_commit(lfs, &parent, &(lfs_mattrlist_t){
{lfs_mktag(LFS_STRUCT_TAIL + parent.split*0x8, // TODO hm {lfs_mktag(LFS_TYPE_TAIL + parent.split, // TODO hm
0x3ff, sizeof(lfs_block_t[2])), 0x3ff, sizeof(lfs_block_t[2])),
.u.pair[0]=newpair[0], .u.pair[1]=newpair[1]}}); .u.pair[0]=newpair[0], .u.pair[1]=newpair[1]}});
if (err) { if (err) {

44
lfs.h
View File

@@ -96,39 +96,29 @@ enum lfs_error {
// File types // File types
enum lfs_type { enum lfs_type {
// file types // file types
LFS_TYPE_REG = 0x008, LFS_TYPE_REG = 0x001,
LFS_TYPE_DIR = 0x010, LFS_TYPE_DIR = 0x002,
LFS_TYPE_SUPERBLOCK = 0x042,
// internally used entry structures
LFS_STRUCT_CTZ = 0x001,
LFS_STRUCT_DIR = 0x002,
LFS_STRUCT_INLINE = 0x003,
LFS_STRUCT_NAME = 0x041,
LFS_STRUCT_DELETE = 0x047,
LFS_STRUCT_TAIL = 0x081,
LFS_STRUCT_CRC = 0x087,
LFS_STRUCT_IDELETE = 0x0c1,
// internally used types // internally used types
LFS_TYPE_SOFTTAIL = 0x081, LFS_TYPE_USER = 0x100,
LFS_TYPE_HARDTAIL = 0x089, LFS_TYPE_SUPERBLOCK = 0x010,
LFS_TYPE_CRC = 0x087, LFS_TYPE_NAME = 0x000,
LFS_TYPE_IDELETE = 0x0c1, LFS_TYPE_DELETE = 0x03f,
LFS_TYPE_STRUCT = 0x040,
LFS_TYPE_GLOBALS = 0x080,
LFS_TYPE_TAIL = 0x0c0,
LFS_TYPE_SOFTTAIL = 0x0c0,
LFS_TYPE_HARDTAIL = 0x0c1,
LFS_TYPE_CRC = 0x0ff,
// internally used scopes LFS_STRUCT_INLINE = 0x040,
LFS_SCOPE_STRUCT = 0x000, LFS_STRUCT_CTZ = 0x041,
LFS_SCOPE_ENTRY = 0x040, LFS_STRUCT_DIR = 0x042,
LFS_SCOPE_DIR = 0x080,
LFS_SCOPE_FS = 0x0c0,
LFS_SCOPE_USER = 0x100,
// internal sources // internal chip sources
LFS_FROM_REGION = 0x000, LFS_FROM_REGION = 0x000,
LFS_FROM_DISK = 0x200, LFS_FROM_DISK = 0x200,
LFS_FROM_MOVE = 0x03f, LFS_FROM_MOVE = 0x030,
}; };
// File open flags // File open flags