Changes in uspace/srv/vfs/vfs_lookup.c [3e6a98c5:5bcd5b7] in mainline

File:

• uspace/srv/vfs/vfs_lookup.c (modified) (5 diffs)

uspace/srv/vfs/vfs_lookup.c

@@ -46 +46 @@
 #include <adt/list.h>
 #include <vfs/canonify.h>
+#include <dirent.h>
+#include <assert.h>
+
+#define DPRINTF(...)
 
 #define min(a, b)  ((a) < (b) ? (a) : (b))
@@ -53 +57 @@
 uint8_t *plb = NULL;
 
-/** Perform a path lookup.
- *
- * @param path    Path to be resolved; it must be a NULL-terminated
- *                string.
- * @param lflag   Flags to be used during lookup.
- * @param result  Empty structure where the lookup result will be stored.
- *                Can be NULL.
- * @param altroot If non-empty, will be used instead of rootfs as the root
- *                of the whole VFS tree.
- *
- * @return EOK on success or an error code from errno.h.
- *
- */
-int vfs_lookup_internal(char *path, int lflag, vfs_lookup_res_t *result,
-    vfs_pair_t *altroot, ...)
-{
-        vfs_pair_t *root;
-
-        if (altroot)
-                root = altroot;
-        else
-                root = &rootfs;
-
-        if (!root->fs_handle)
-                return ENOENT;
-        
-        size_t len;
-        path = canonify(path, &len);
-        if (!path)
-                return EINVAL;
-        
-        fs_index_t index = 0;
-        if (lflag & L_LINK) {
-                va_list ap;
-
-                va_start(ap, altroot);
-                index = va_arg(ap, fs_index_t);
-                va_end(ap);
-        }
-        
+static int plb_insert_entry(plb_entry_t *entry, char *path, size_t *start, size_t len)
+{
         fibril_mutex_lock(&plb_mutex);
 
-        plb_entry_t entry;
-        link_initialize(&entry.plb_link);
-        entry.len = len;
+        link_initialize(&entry->plb_link);
+        entry->len = len;
 
         size_t first;   /* the first free index */
@@ -138 +103 @@
          */
 
-        entry.index = first;
-        entry.len = len;
+        entry->index = first;
+        entry->len = len;
 
         /*
@@ -145 +110 @@
          * buffer.
          */
-        list_append(&entry.plb_link, &plb_entries);
+        list_append(&entry->plb_link, &plb_entries);
         
         fibril_mutex_unlock(&plb_mutex);
@@ -158 +123 @@
         memcpy(plb, &path[cnt1], cnt2);
 
-        ipc_call_t answer;
-        async_exch_t *exch = vfs_exchange_grab(root->fs_handle);
-        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) first,
-            (sysarg_t) (first + len - 1) % PLB_SIZE,
-            (sysarg_t) root->service_id, (sysarg_t) lflag, (sysarg_t) index,
-            &answer);
-        
-        sysarg_t rc;
-        async_wait_for(req, &rc);
-        vfs_exchange_release(exch);
-        
+        *start = first;
+        return EOK;
+}
+
+static void plb_clear_entry(plb_entry_t *entry, size_t first, size_t len)
+{
         fibril_mutex_lock(&plb_mutex);
-        list_remove(&entry.plb_link);
+        list_remove(&entry->plb_link);
         /*
          * Erasing the path from PLB will come handy for debugging purposes.
          */
+        size_t cnt1 = min(len, (PLB_SIZE - first) + 1);
+        size_t cnt2 = len - cnt1;
         memset(&plb[first], 0, cnt1);
         memset(plb, 0, cnt2);
         fibril_mutex_unlock(&plb_mutex);
-        
-        if ((int) rc < EOK)
+}
+
+static char *_strrchr(char *path, int c)
+{
+        char *res = NULL;
+        while (*path != 0) {
+                if (*path == c) {
+                        res = path;
+                }
+                path++;
+        }
+        return res;
+}
+
+int vfs_link_internal(vfs_node_t *base, char *path, vfs_triplet_t *child)
+{
+        assert(base != NULL);
+        assert(child != NULL);
+        assert(base->fs_handle);
+        assert(child->fs_handle);
+        assert(path != NULL);
+        
+        vfs_lookup_res_t res;
+        char component[NAME_MAX + 1];
+        int rc;
+        
+        size_t len;
+        char *npath = canonify(path, &len);
+        if (!npath) {
+                rc = EINVAL;
+                goto out;
+        }
+        path = npath;
+        
+        vfs_triplet_t *triplet;
+        
+        char *slash = _strrchr(path, '/');
+        if (slash && slash != path) {
+                if (slash[1] == 0) {
+                        rc = EINVAL;
+                        goto out;
+                }
+                
+                memcpy(component, slash + 1, str_size(slash));
+                *slash = 0;
+                
+                rc = vfs_lookup_internal(base, path, L_DIRECTORY, &res);
+                if (rc != EOK) {
+                        goto out;
+                }
+                triplet = &res.triplet;
+                
+                *slash = '/';
+        } else {
+                if (base->mount != NULL) {
+                        rc = EINVAL;
+                        goto out;
+                }
+                
+                memcpy(component, path + 1, str_size(path));
+                triplet = (vfs_triplet_t *) base;
+        }
+        
+        if (triplet->fs_handle != child->fs_handle || triplet->service_id != child->service_id) {
+                rc = EXDEV;
+                goto out;
+        }
+        
+        async_exch_t *exch = vfs_exchange_grab(triplet->fs_handle);
+        aid_t req = async_send_3(exch, VFS_OUT_LINK, triplet->service_id, triplet->index, child->index, NULL);
+        
+        rc = async_data_write_start(exch, component, str_size(component) + 1);
+        sysarg_t orig_rc;
+        async_wait_for(req, &orig_rc);
+        vfs_exchange_release(exch);
+        if (orig_rc != EOK) {
+                rc = orig_rc;
+        }
+        
+out:
+        DPRINTF("vfs_link_internal() with path '%s' returns %d\n", path, rc);
+        return rc;
+}
+
+static int out_lookup(vfs_triplet_t *base, unsigned *pfirst, unsigned *plen,
+        int lflag, vfs_lookup_res_t *result)
+{
+        assert(base);
+        assert(result);
+        
+        sysarg_t rc;
+        ipc_call_t answer;
+        async_exch_t *exch = vfs_exchange_grab(base->fs_handle);
+        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) *pfirst, (sysarg_t) *plen,
+            (sysarg_t) base->service_id, (sysarg_t) base->index, (sysarg_t) lflag, &answer);
+        async_wait_for(req, &rc);
+        vfs_exchange_release(exch);
+        
+        if ((int) rc < 0) {
                 return (int) rc;
-
-        if (!result)
-                return EOK;
+        }
+        
+        unsigned last = *pfirst + *plen;
+        *pfirst = IPC_GET_ARG3(answer);
+        *plen = last - *pfirst;
         
         result->triplet.fs_handle = (fs_handle_t) rc;
         result->triplet.service_id = (service_id_t) IPC_GET_ARG1(answer);
         result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
-        result->size =
-            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(answer), IPC_GET_ARG4(answer));
-        result->lnkcnt = (unsigned int) IPC_GET_ARG5(answer);
-        
-        if (lflag & L_FILE)
-                result->type = VFS_NODE_FILE;
-        else if (lflag & L_DIRECTORY)
-                result->type = VFS_NODE_DIRECTORY;
-        else
-                result->type = VFS_NODE_UNKNOWN;
-        
+        result->size = (int64_t)(int32_t) IPC_GET_ARG4(answer);
+        result->type = IPC_GET_ARG5(answer);
         return EOK;
+}
+
+/** Perform a path lookup.
+ *
+ * @param base    The file from which to perform the lookup.
+ * @param path    Path to be resolved; it must be a NULL-terminated
+ *                string.
+ * @param lflag   Flags to be used during lookup.
+ * @param result  Empty structure where the lookup result will be stored.
+ *                Can be NULL.
+ *
+ * @return EOK on success or an error code from errno.h.
+ *
+ */
+int vfs_lookup_internal(vfs_node_t *base, char *path, int lflag, vfs_lookup_res_t *result)
+{
+        assert(base != NULL);
+        assert(path != NULL);
+        
+        size_t len;
+        int rc;
+        char *npath = canonify(path, &len);
+        if (!npath) {
+                DPRINTF("vfs_lookup_internal() can't canonify path: %s\n", path);
+                rc = EINVAL;
+                return rc;
+        }
+        path = npath;
+        
+        assert(path[0] == '/');
+        
+        size_t first;
+        
+        plb_entry_t entry;
+        rc = plb_insert_entry(&entry, path, &first, len);
+        if (rc != EOK) {
+                DPRINTF("vfs_lookup_internal() can't insert entry into PLB: %d\n", rc);
+                return rc;
+        }
+        
+        size_t next = first;
+        size_t nlen = len;
+        
+        vfs_lookup_res_t res;
+        
+        /* Resolve path as long as there are mount points to cross. */
+        while (nlen > 0) {
+                while (base->mount != NULL) {
+                        if (lflag & L_DISABLE_MOUNTS) {
+                                rc = EXDEV;
+                                goto out;
+                        }
+                        
+                        base = base->mount;
+                }
+                
+                rc = out_lookup((vfs_triplet_t *) base, &next, &nlen, lflag, &res);
+                if (rc != EOK) {
+                        goto out;
+                }
+                
+                if (nlen > 0) {
+                        base = vfs_node_peek(&res);
+                        if (base == NULL || base->mount == NULL) {
+                                rc = ENOENT;
+                                goto out;
+                        }
+                        if (lflag & L_DISABLE_MOUNTS) {
+                                rc = EXDEV;
+                                goto out;
+                        }
+                }
+        }
+        
+        assert(nlen == 0);
+        rc = EOK;
+        
+        if (result != NULL) {
+                /* The found file may be a mount point. Try to cross it. */
+                if (!(lflag & L_MP)) {
+                        base = vfs_node_peek(&res);
+                        if (base != NULL && base->mount != NULL) {
+                                while (base->mount != NULL) {
+                                        base = base->mount;
+                                }
+                                
+                                result->triplet = *(vfs_triplet_t *)base;
+                                result->type = base->type;
+                                result->size = base->size;                              
+                                goto out;
+                        }
+                }
+
+                __builtin_memcpy(result, &res, sizeof(vfs_lookup_res_t));
+        }
+        
+out:
+        plb_clear_entry(&entry, first, len);
+        DPRINTF("vfs_lookup_internal() with path '%s' returns %d\n", path, rc);
+        return rc;
 }