Modified results from find-like functions to use tags

Tags offer all of the necessary info from the find functions (which
makes sense, this is the structure that stores the info on disk).
Passing around a single tag instead of separate id and type fields
simplifies the internal functions while leverages the tag's compactness.

lfs.c

@@ -263,7 +263,7 @@ int lfs_fs_traverse(lfs_t *lfs,
         int (*cb)(lfs_t*, void*, lfs_block_t), void *data);
 static int lfs_pred(lfs_t *lfs, const lfs_block_t dir[2], lfs_mdir_t *pdir);
 static int lfs_parent(lfs_t *lfs, const lfs_block_t dir[2],
-        lfs_mdir_t *parent, lfs_mattr_t *attr);
+        lfs_mdir_t *parent, lfs_tag_t *foundtag);
 static int lfs_relocate(lfs_t *lfs,
         const lfs_block_t oldpair[2], const lfs_block_t newpair[2]);
 int lfs_scan(lfs_t *lfs);
@@ -768,7 +768,7 @@ static int lfs_dir_find(lfs_t *lfs,
     dir->pair[0] = pair[0];
     dir->pair[1] = pair[1];
     dir->stop_at_commit = false;
-    *foundtag = 0xffffffff;
+    lfs_tag_t localfoundtag = 0xffffffff;
 
     // find the block with the most recent revision
     uint32_t rev[2];
@@ -801,7 +801,7 @@ static int lfs_dir_find(lfs_t *lfs,
         dir->rev = lfs_fromle32(dir->rev);
 
         lfs_mdir_t tempdir = *dir;
-        lfs_tag_t tempfoundtag = *foundtag;
+        lfs_tag_t tempfoundtag = localfoundtag;
 
         while (true) {
             // extract next tag
@@ -850,7 +850,7 @@ static int lfs_dir_find(lfs_t *lfs,
                 tempdir.etag = tag;
                 crc = 0xffffffff;
                 *dir = tempdir;
-                *foundtag = tempfoundtag;
+                localfoundtag = tempfoundtag;
             } else {
                 err = lfs_bd_crc(lfs, tempdir.pair[0],
                         off+sizeof(tag), lfs_tag_size(tag), &crc);
@@ -914,25 +914,29 @@ static int lfs_dir_find(lfs_t *lfs,
 done:
     // synthetic move
     if (lfs_paircmp(dir->pair, lfs->globals.move.pair) == 0) {
-        if (lfs->globals.move.id == lfs_tag_id(*foundtag)) {
+        if (lfs->globals.move.id == lfs_tag_id(localfoundtag)) {
-            *foundtag = 0xffffffff;
+            localfoundtag = 0xffffffff;
-        } else if (lfs_tag_id(*foundtag) < 0x3ff &&
+        } else if (lfs_tag_id(localfoundtag) < 0x3ff &&
-                lfs->globals.move.id < lfs_tag_id(*foundtag)) {
+                lfs->globals.move.id < lfs_tag_id(localfoundtag)) {
-            *foundtag -= lfs_mktag(0, 1, 0);
+            localfoundtag -= lfs_mktag(0, 1, 0);
         }
     }
 
-    if (*foundtag == 0xffffffff) {
+    if (localfoundtag == 0xffffffff) {
         return LFS_ERR_NOENT;
     }
 
+    if (foundtag) {
+        *foundtag = localfoundtag;
+    }
+
     return 0;
 }
 
 static int lfs_dir_fetch(lfs_t *lfs,
         lfs_mdir_t *dir, const lfs_block_t pair[2]) {
     int err = lfs_dir_find(lfs, dir, pair,
-            0xffffffff, 0xffffffff, NULL, &(lfs_tag_t){0});
+            0xffffffff, 0xffffffff, NULL, NULL);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
@@ -1402,9 +1406,8 @@ static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir,
 }
 
 
-// TODO drop others, make this only return id, also make get take in only entry to populate (with embedded tag)
 static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
-        const char **path, uint16_t *id, uint8_t *type) {
+        const char **path, lfs_tag_t *foundtag) {
     lfs_mattr_t attr = {
         .u.pair[0] = lfs->root[0],
         .u.pair[1] = lfs->root[1],
@@ -1412,6 +1415,7 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
 
     const char *name = *path;
     lfs_size_t namelen;
+    lfs_tag_t localfoundtag;
 
     while (true) {
     nextname:
@@ -1423,7 +1427,9 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
         if (name[0] == '\0') {
             // Return ISDIR when we hit root
             // TODO change this to -1 or 0x3ff?
-            *type = LFS_TYPE_DIR;
+            if (foundtag) {
+                *foundtag = lfs_mktag(LFS_TYPE_DIR, 0, 0);
+            }
             return LFS_ERR_ISDIR;
         }
 
@@ -1463,18 +1469,15 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
 
         // find path
         while (true) {
-            lfs_tag_t foundtag = -1;
             int err = lfs_dir_find(lfs, dir, attr.u.pair,
                     0x7c000fff, lfs_mktag(LFS_TYPE_NAME, 0, namelen),
-                    name, &foundtag);
+                    name, &localfoundtag);
             if (err && err != LFS_ERR_NOENT) {
                 return err;
             }
 
             if (err != LFS_ERR_NOENT) {
                 // found it
-                *id = lfs_tag_id(foundtag);
-                *type = lfs_tag_type(foundtag);
                 break;
             }
 
@@ -1486,6 +1489,10 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
             attr.u.pair[1] = dir->tail[1];
         }
 
+        if (foundtag) {
+            *foundtag = localfoundtag;
+        }
+
         name += namelen;
         name += strspn(name, "/");
         if (name[0] == '\0') {
@@ -1494,7 +1501,7 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
 
         // don't continue on if we didn't hit a directory
         // TODO update with what's on master?
-        if (*type != LFS_TYPE_DIR) {
+        if (lfs_tag_type(localfoundtag) != LFS_TYPE_DIR) {
             return LFS_ERR_NOTDIR;
         }
 
@@ -1502,7 +1509,7 @@ static int lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir,
         // TODO would this mean more code?
         // grab the entry data
         int err = lfs_dir_get(lfs, dir, 0x7c3ff000,
-                lfs_mktag(LFS_TYPE_STRUCT, *id, 8),
+                lfs_mktag(LFS_TYPE_STRUCT, lfs_tag_id(localfoundtag), 8),
                 &attr.tag, &attr.u);
         if (err) {
             return err;
@@ -1521,7 +1528,7 @@ int lfs_mkdir(lfs_t *lfs, const char *path) {
     }
 
     lfs_mdir_t cwd;
-    int err = lfs_dir_lookup(lfs, &cwd, &path, &(uint16_t){0}, &(uint8_t){0});
+    int err = lfs_dir_lookup(lfs, &cwd, &path, NULL);
     if (err != LFS_ERR_NOENT || strchr(path, '/') != NULL) {
         if (!err || err == LFS_ERR_ISDIR) {
             return LFS_ERR_EXIST;
@@ -1572,14 +1579,13 @@ int lfs_mkdir(lfs_t *lfs, const char *path) {
 }
 
 int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
-    uint16_t id;
+    lfs_tag_t tag;
-    uint8_t type;
+    int err = lfs_dir_lookup(lfs, &dir->m, &path, &tag);
-    int err = lfs_dir_lookup(lfs, &dir->m, &path, &id, &type);
     if (err && err != LFS_ERR_ISDIR) {
         return err;
     }
 
-    if (type != LFS_TYPE_DIR) {
+    if (lfs_tag_type(tag) != LFS_TYPE_DIR) {
         return LFS_ERR_NOTDIR;
     }
 
@@ -1591,7 +1597,7 @@ int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) {
     } else {
         // get dir pair from parent
         err = lfs_dir_get(lfs, &dir->m, 0x7c3ff000,
-                lfs_mktag(LFS_TYPE_STRUCT, id, 8),
+                lfs_mktag(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8),
                 &attr.tag, &attr.u);
         if (err) {
             return err;
@@ -1926,15 +1932,16 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file,
 
     // allocate entry for file if it doesn't exist
     lfs_mdir_t cwd;
-    uint16_t id;
+    lfs_tag_t tag;
-    uint8_t type;
+    int err = lfs_dir_lookup(lfs, &cwd, &path, &tag);
-    int err = lfs_dir_lookup(lfs, &cwd, &path, &id, &type);
     if (err && (err != LFS_ERR_NOENT || strchr(path, '/') != NULL) &&
             err != LFS_ERR_ISDIR) {
         return err;
     }
+    uint16_t id = lfs_tag_id(tag);
+    uint8_t type = lfs_tag_type(tag);
 
-    lfs_mattr_t attr;
+    lfs_mattr_t attr; // TODO stop copying things (attr, id, type, tag)
     if (err == LFS_ERR_NOENT) {
         if (!(flags & LFS_O_CREAT)) {
             return LFS_ERR_NOENT;
@@ -2603,9 +2610,9 @@ lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file) {
 /// General fs operations ///
 int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info) {
     lfs_mdir_t cwd;
-    uint16_t id;
+    lfs_tag_t tag;
     // TODO pass to getinfo?
-    int err = lfs_dir_lookup(lfs, &cwd, &path, &id, &(uint8_t){0});
+    int err = lfs_dir_lookup(lfs, &cwd, &path, &tag);
     if (err && err != LFS_ERR_ISDIR) {
         return err;
     }
@@ -2617,7 +2624,7 @@ int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info) {
         return 0;
     }
 
-    return lfs_dir_getinfo(lfs, &cwd, id, info);
+    return lfs_dir_getinfo(lfs, &cwd, lfs_tag_id(tag), info);
 }
 
 int lfs_remove(lfs_t *lfs, const char *path) {
@@ -2635,19 +2642,18 @@ int lfs_remove(lfs_t *lfs, const char *path) {
         return err;
     }
 
-    uint16_t id;
+    lfs_tag_t tag;
-    uint8_t type;
+    err = lfs_dir_lookup(lfs, &cwd, &path, &tag);
-    err = lfs_dir_lookup(lfs, &cwd, &path, &id, &type);
     if (err) {
         return err;
     }
 
     lfs_mdir_t dir;
-    if (type == LFS_TYPE_DIR) {
+    if (lfs_tag_type(tag) == LFS_TYPE_DIR) {
         // must be empty before removal
         lfs_mattr_t attr;
         err = lfs_dir_get(lfs, &cwd, 0x7c3ff000,
-                lfs_mktag(LFS_TYPE_STRUCT, id, 8),
+                lfs_mktag(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8),
                 &attr.tag, &attr.u);
         if (err) {
             return err;
@@ -2665,12 +2671,12 @@ int lfs_remove(lfs_t *lfs, const char *path) {
     }
 
     // delete the entry
-    err = lfs_dir_delete(lfs, &cwd, id);
+    err = lfs_dir_delete(lfs, &cwd, lfs_tag_id(tag));
     if (err) {
         return err;
     }
 
-    if (type == LFS_TYPE_DIR) {
+    if (lfs_tag_type(tag) == LFS_TYPE_DIR) {
         int res = lfs_pred(lfs, dir.pair, &cwd);
         if (res < 0) {
             return res;
@@ -2698,33 +2704,32 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
 
     // find old entry
     lfs_mdir_t oldcwd;
-    uint16_t oldid;
+    lfs_tag_t oldtag;
-    uint8_t oldtype;
+    int err = lfs_dir_lookup(lfs, &oldcwd, &oldpath, &oldtag);
-    int err = lfs_dir_lookup(lfs, &oldcwd, &oldpath, &oldid, &oldtype);
     if (err) {
         return err;
     }
 
     // find new entry
     lfs_mdir_t newcwd;
-    uint16_t newid;
+    lfs_tag_t prevtag;
-    uint8_t prevtype;
+    err = lfs_dir_lookup(lfs, &newcwd, &newpath, &prevtag);
-    err = lfs_dir_lookup(lfs, &newcwd, &newpath, &newid, &prevtype);
     if (err && err != LFS_ERR_NOENT) {
         return err;
     }
 
+    uint16_t newid = lfs_tag_id(prevtag);
     bool prevexists = (err != LFS_ERR_NOENT);
     //bool samepair = (lfs_paircmp(oldcwd.pair, newcwd.pair) == 0);
 
     lfs_mdir_t prevdir;
     if (prevexists) {
         // check that we have same type
-        if (prevtype != oldtype) {
+        if (lfs_tag_type(prevtag) != lfs_tag_type(oldtag)) {
             return LFS_ERR_ISDIR;
         }
 
-        if (prevtype == LFS_TYPE_DIR) {
+        if (lfs_tag_type(prevtag) == LFS_TYPE_DIR) {
             // must be empty before removal
             lfs_mattr_t prevattr;
             err = lfs_dir_get(lfs, &newcwd, 0x7c3ff000,
@@ -2761,13 +2766,13 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
     // create move to fix later
     lfs->diff.move.pair[0] = oldcwd.pair[0]     ^ lfs->globals.move.pair[0];
     lfs->diff.move.pair[1] = oldcwd.pair[1]     ^ lfs->globals.move.pair[1];
-    lfs->diff.move.id      = oldid          ^ lfs->globals.move.id;
+    lfs->diff.move.id      = lfs_tag_id(oldtag) ^ lfs->globals.move.id;
 
     // move over all attributes
     err = lfs_dir_commit(lfs, &newcwd, &(lfs_mattrlist_t){
-            {lfs_mktag(oldtype, newid, strlen(newpath)),
+            {lfs_mktag(lfs_tag_type(oldtag), newid, strlen(newpath)),
                 .u.buffer=(void*)newpath}, &(lfs_mattrlist_t){
-            {lfs_mktag(LFS_FROM_DIR, newid, oldid),
+            {lfs_mktag(LFS_FROM_DIR, newid, lfs_tag_id(oldtag)),
                 .u.dir=&oldcwd}}});
     if (err) {
         return err;
@@ -2779,7 +2784,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) {
         return err;
     }
 
-    if (prevexists && prevtype == LFS_TYPE_DIR) {
+    if (prevexists && lfs_tag_type(prevtag) == LFS_TYPE_DIR) {
         int res = lfs_pred(lfs, prevdir.pair, &newcwd);
         if (res < 0) {
             return res;
@@ -3286,7 +3291,7 @@ static int lfs_pred(lfs_t *lfs, const lfs_block_t pair[2], lfs_mdir_t *pdir) {
 }
 
 static int lfs_parent(lfs_t *lfs, const lfs_block_t pair[2],
-        lfs_mdir_t *parent, lfs_mattr_t *attr) {
+        lfs_mdir_t *parent, lfs_tag_t *foundtag) {
     // search for both orderings so we can reuse the find function
     lfs_block_t child[2] = {pair[0], pair[1]};
 
@@ -3295,31 +3300,18 @@ static int lfs_parent(lfs_t *lfs, const lfs_block_t pair[2],
         parent->tail[0] = 0;
         parent->tail[1] = 1;
         while (!lfs_pairisnull(parent->tail)) {
-            lfs_tag_t foundtag = -1;
             int err = lfs_dir_find(lfs, parent, parent->tail,
                     0x7fc00fff, lfs_mktag(LFS_STRUCT_DIR, 0, sizeof(child)),
-                    child, &foundtag);
+                    child, foundtag);
-            if (err && err != LFS_ERR_NOENT) {
-                return err;
-            }
-
             if (err != LFS_ERR_NOENT) {
-                // found our parent
-                int err = lfs_dir_get(lfs, parent,
-                        0x7ffff000, foundtag,
-                        &attr->tag, &attr->u);
-                if (err) {
                 return err;
             }
-
-                return true;
-            }
         }
 
         lfs_pairswap(child);
     }
 
-    return false;
+    return LFS_ERR_NOENT;
 }
 
 // TODO rename to lfs_dir_relocate?
@@ -3328,12 +3320,12 @@ static int lfs_relocate(lfs_t *lfs,
     // find parent
     lfs_mdir_t parent;
     lfs_mattr_t attr;
-    int res = lfs_parent(lfs, oldpair, &parent, &attr);
+    int err = lfs_parent(lfs, oldpair, &parent, &attr.tag);
-    if (res < 0) {
+    if (err && err != LFS_ERR_NOENT) {
-        return res;
+        return err;
     }
 
-    if (res) {
+    if (err != LFS_ERR_NOENT) {
         // update disk, this creates a desync
         attr.u.pair[0] = newpair[0];
         attr.u.pair[1] = newpair[1];
@@ -3356,7 +3348,7 @@ static int lfs_relocate(lfs_t *lfs,
     }
 
     // find pred
-    res = lfs_pred(lfs, oldpair, &parent);
+    int res = lfs_pred(lfs, oldpair, &parent);
     if (res < 0) {
         return res;
     }
@@ -3476,12 +3468,12 @@ int lfs_deorphan(lfs_t *lfs) {
             // check if we have a parent
             lfs_mdir_t parent;
             lfs_mattr_t attr;
-            int res = lfs_parent(lfs, pdir.tail, &parent, &attr);
+            int err = lfs_parent(lfs, pdir.tail, &parent, &attr.tag);
-            if (res < 0) {
+            if (err && err != LFS_ERR_NOENT) {
-                return res;
+                return err;
             }
 
-            if (!res) {
+            if (err == LFS_ERR_NOENT) {
                 // we are an orphan
                 LFS_DEBUG("Found orphan %d %d",
                         pdir.tail[0], pdir.tail[1]);
@@ -3499,6 +3491,12 @@ int lfs_deorphan(lfs_t *lfs) {
                 break;
             }
 
+            err = lfs_dir_get(lfs, &parent,
+                    0x7ffff000, attr.tag, NULL, &attr.u);
+            if (err) {
+                return err;
+            }
+
             if (!lfs_pairsync(attr.u.pair, pdir.tail)) {
                 // we have desynced
                 LFS_DEBUG("Found half-orphan %d %d",