Changeset 371bd7d in mainline for uspace/lib/fs

Timestamp:

2010-03-27T09:22:17Z (16 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

36a75a2

Parents:

cd82bb1 (diff), eaf22d4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/lib/fs

Files:

• Makefile (added)
• Makefile.build (moved) (moved from uspace/lib/libfs/Makefile.build )
• Makefile.common (moved) (moved from uspace/lib/libfs/Makefile.common )
• libfs.c (moved) (moved from uspace/lib/libfs/libfs.c ) (26 diffs)
• libfs.h (moved) (moved from uspace/lib/libfs/libfs.h ) (3 diffs)

uspace/lib/fs/libfs.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Jakub Jermar 
+ * Copyright (c) 2009 Jakub Jermar
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libfs 
+/** @addtogroup libfs
  * @{
- */ 
+ */
 /**
  * @file
- * Glue code which is commonod to all FS implementations. 
+ * Glue code which is common to all FS implementations.
  */
 
-#include "libfs.h" 
+#include "libfs.h"
 #include "../../srv/vfs/vfs.h"
+#include <macros.h>
 #include <errno.h>
 #include <async.h>
@@ -67 +68 @@
  * code.
  *
- * @param vfs_phone     Open phone for communication with VFS.
- * @param reg           File system registration structure. It will be
- *                      initialized by this function.
- * @param info          VFS info structure supplied by the file system
- *                      implementation.
- * @param conn          Connection fibril for handling all calls originating in
- *                      VFS.
- *
- * @return              EOK on success or a non-zero error code on errror.
+ * @param vfs_phone Open phone for communication with VFS.
+ * @param reg       File system registration structure. It will be
+ *                  initialized by this function.
+ * @param info      VFS info structure supplied by the file system
+ *                  implementation.
+ * @param conn      Connection fibril for handling all calls originating in
+ *                  VFS.
+ *
+ * @return EOK on success or a non-zero error code on errror.
+ *
  */
 int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info,
@@ -87 +89 @@
         ipc_call_t answer;
         aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer);
-
+        
         /*
          * Send our VFS info structure to VFS.
@@ -96 +98 @@
                 return rc;
         }
-
+        
         /*
          * Ask VFS for callback connection.
          */
         ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
-
+        
         /*
          * Allocate piece of address space for PLB.
@@ -110 +112 @@
                 return ENOMEM;
         }
-
+        
         /*
          * Request sharing the Path Lookup Buffer with VFS.
@@ -136 +138 @@
          */
         async_set_client_connection(conn);
-
+        
         return IPC_GET_RETVAL(answer);
 }
@@ -154 +156 @@
         int res;
         ipcarg_t rc;
-
+        
         ipc_call_t call;
         ipc_callid_t callid;
-
-        /* accept the phone */
+        
+        /* Accept the phone */
         callid = async_get_call(&call);
-        int mountee_phone = (int)IPC_GET_ARG1(call);
+        int mountee_phone = (int) IPC_GET_ARG1(call);
         if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) ||
-            mountee_phone < 0) {
+            (mountee_phone < 0)) {
                 ipc_answer_0(callid, EINVAL);
                 ipc_answer_0(rid, EINVAL);
                 return;
         }
-        ipc_answer_0(callid, EOK);      /* acknowledge the mountee_phone */
-        
-        res = async_data_write_receive(&callid, NULL);
-        if (!res) {
-                ipc_hangup(mountee_phone);
-                ipc_answer_0(callid, EINVAL);
-                ipc_answer_0(rid, EINVAL);
-                return;
-        }
-
+        
+        /* Acknowledge the mountee_phone */
+        ipc_answer_0(callid, EOK);
+        
         fs_node_t *fn;
         res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
-        if (res != EOK || !fn) {
+        if ((res != EOK) || (!fn)) {
                 ipc_hangup(mountee_phone);
-                ipc_answer_0(callid, combine_rc(res, ENOENT));
+                async_data_write_void(combine_rc(res, ENOENT));
                 ipc_answer_0(rid, combine_rc(res, ENOENT));
                 return;
         }
-
+        
         if (fn->mp_data.mp_active) {
                 ipc_hangup(mountee_phone);
                 (void) ops->node_put(fn);
-                ipc_answer_0(callid, EBUSY);
+                async_data_write_void(EBUSY);
                 ipc_answer_0(rid, EBUSY);
                 return;
         }
-
+        
         rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
         if (rc != EOK) {
                 ipc_hangup(mountee_phone);
                 (void) ops->node_put(fn);
-                ipc_answer_0(callid, rc);
+                async_data_write_void(rc);
                 ipc_answer_0(rid, rc);
                 return;
@@ -204 +200 @@
         
         ipc_call_t answer;
-        aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle,
-            &answer);
-        ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
-        async_wait_for(msg, &rc);
+        rc = async_data_write_forward_1_1(mountee_phone, VFS_OUT_MOUNTED,
+            mr_dev_handle, &answer);
         
         if (rc == EOK) {
@@ -215 +209 @@
                 fn->mp_data.phone = mountee_phone;
         }
+        
         /*
          * Do not release the FS node so that it stays in memory.
@@ -220 +215 @@
         ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
             IPC_GET_ARG3(answer));
+}
+
+void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *request)
+{
+        dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+        fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request);
+        fs_node_t *fn;
+        int res;
+
+        res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
+        if ((res != EOK) || (!fn)) {
+                ipc_answer_0(rid, combine_rc(res, ENOENT));
+                return;
+        }
+
+        /*
+         * We are clearly expecting to find the mount point active.
+         */
+        if (!fn->mp_data.mp_active) {
+                (void) ops->node_put(fn);
+                ipc_answer_0(rid, EINVAL);
+                return;
+        }
+
+        /*
+         * Tell the mounted file system to unmount.
+         */
+        res = async_req_1_0(fn->mp_data.phone, VFS_OUT_UNMOUNTED,
+            fn->mp_data.dev_handle);
+
+        /*
+         * If everything went well, perform the clean-up on our side.
+         */
+        if (res == EOK) {
+                ipc_hangup(fn->mp_data.phone);
+                fn->mp_data.mp_active = false;
+                fn->mp_data.fs_handle = 0;
+                fn->mp_data.dev_handle = 0;
+                fn->mp_data.phone = 0;
+                /* Drop the reference created in libfs_mount(). */
+                (void) ops->node_put(fn);
+        }
+
+        (void) ops->node_put(fn);
+        ipc_answer_0(rid, res);
 }
 
@@ -238 +278 @@
     ipc_call_t *request)
 {
-        unsigned first = IPC_GET_ARG1(*request);
-        unsigned last = IPC_GET_ARG2(*request);
-        unsigned next = first;
+        unsigned int first = IPC_GET_ARG1(*request);
+        unsigned int last = IPC_GET_ARG2(*request);
+        unsigned int next = first;
         dev_handle_t dev_handle = IPC_GET_ARG3(*request);
         int lflag = IPC_GET_ARG4(*request);
-        fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
+        fs_index_t index = IPC_GET_ARG5(*request);
         char component[NAME_MAX + 1];
         int len;
         int rc;
-
+        
         if (last < next)
                 last += PLB_SIZE;
-
+        
         fs_node_t *par = NULL;
         fs_node_t *cur = NULL;
         fs_node_t *tmp = NULL;
-
+        
         rc = ops->root_get(&cur, dev_handle);
         on_error(rc, goto out_with_answer);
-
+        
         if (cur->mp_data.mp_active) {
                 ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP,
@@ -265 +305 @@
                 return;
         }
-
+        
+        /* Eat slash */
         if (ops->plb_get_char(next) == '/')
-                next++;         /* eat slash */
+                next++;
         
         while (next <= last) {
                 bool has_children;
-
+                
                 rc = ops->has_children(&has_children, cur);
                 on_error(rc, goto out_with_answer);
                 if (!has_children)
                         break;
-
-                /* collect the component */
+                
+                /* Collect the component */
                 len = 0;
-                while ((next <= last) &&  (ops->plb_get_char(next) != '/')) {
+                while ((next <= last) && (ops->plb_get_char(next) != '/')) {
                         if (len + 1 == NAME_MAX) {
-                                /* component length overflow */
+                                /* Component length overflow */
                                 ipc_answer_0(rid, ENAMETOOLONG);
                                 goto out;
                         }
                         component[len++] = ops->plb_get_char(next);
-                        next++; /* process next character */
+                        /* Process next character */
+                        next++;
                 }
-
+                
                 assert(len);
                 component[len] = '\0';
-                next++;         /* eat slash */
-
-                /* match the component */
+                /* Eat slash */
+                next++;
+                
+                /* Match the component */
                 rc = ops->match(&tmp, cur, component);
                 on_error(rc, goto out_with_answer);
-
-                if (tmp && tmp->mp_data.mp_active) {
+                
+                /*
+                 * If the matching component is a mount point, there are two
+                 * legitimate semantics of the lookup operation. The first is
+                 * the commonly used one in which the lookup crosses each mount
+                 * point into the mounted file system. The second semantics is
+                 * used mostly during unmount() and differs from the first one
+                 * only in that the last mount point in the looked up path,
+                 * which is also its last component, is not crossed.
+                 */
+
+                if ((tmp) && (tmp->mp_data.mp_active) &&
+                    (!(lflag & L_MP) || (next <= last))) {
                         if (next > last)
                                 next = last = first;
                         else
                                 next--;
-                                
+                        
                         ipc_forward_slow(rid, tmp->mp_data.phone,
                             VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle,
@@ -312 +366 @@
                         return;
                 }
-
-                /* handle miss: match amongst siblings */
+                
+                /* Handle miss: match amongst siblings */
                 if (!tmp) {
                         if (next <= last) {
-                                /* there are unprocessed components */
+                                /* There are unprocessed components */
                                 ipc_answer_0(rid, ENOENT);
                                 goto out;
                         }
-                        /* miss in the last component */
-                        if (lflag & (L_CREATE | L_LINK)) { 
-                                /* request to create a new link */
+                        
+                        /* Miss in the last component */
+                        if (lflag & (L_CREATE | L_LINK)) {
+                                /* Request to create a new link */
                                 if (!ops->is_directory(cur)) {
                                         ipc_answer_0(rid, ENOTDIR);
                                         goto out;
                                 }
+                                
                                 fs_node_t *fn;
                                 if (lflag & L_CREATE)
@@ -335 +391 @@
                                             index);
                                 on_error(rc, goto out_with_answer);
+                                
                                 if (fn) {
                                         rc = ops->link(cur, fn, component);
@@ -342 +399 @@
                                                 ipc_answer_0(rid, rc);
                                         } else {
-                                                ipc_answer_5(rid, EOK,
-                                                    fs_handle, dev_handle,
+                                                aoff64_t size = ops->size_get(fn);
+                                                ipc_answer_5(rid, fs_handle,
+                                                    dev_handle,
                                                     ops->index_get(fn),
-                                                    ops->size_get(fn),
+                                                    LOWER32(size),
+                                                    UPPER32(size),
                                                     ops->lnkcnt_get(fn));
                                                 (void) ops->node_put(fn);
                                         }
-                                } else {
+                                } else
                                         ipc_answer_0(rid, ENOSPC);
-                                }
+                                
                                 goto out;
-                        } 
+                        }
+                        
                         ipc_answer_0(rid, ENOENT);
                         goto out;
                 }
-
+                
                 if (par) {
                         rc = ops->node_put(par);
                         on_error(rc, goto out_with_answer);
                 }
-
-                /* descend one level */
+                
+                /* Descend one level */
                 par = cur;
                 cur = tmp;
                 tmp = NULL;
         }
-
-        /* handle miss: excessive components */
+        
+        /* Handle miss: excessive components */
         if (next <= last) {
                 bool has_children;
-
                 rc = ops->has_children(&has_children, cur);
                 on_error(rc, goto out_with_answer);
+                
                 if (has_children)
                         goto skip_miss;
-
+                
                 if (lflag & (L_CREATE | L_LINK)) {
                         if (!ops->is_directory(cur)) {
@@ -383 +443 @@
                                 goto out;
                         }
-
-                        /* collect next component */
+                        
+                        /* Collect next component */
                         len = 0;
                         while (next <= last) {
                                 if (ops->plb_get_char(next) == '/') {
-                                        /* more than one component */
+                                        /* More than one component */
                                         ipc_answer_0(rid, ENOENT);
                                         goto out;
                                 }
+                                
                                 if (len + 1 == NAME_MAX) {
-                                        /* component length overflow */
+                                        /* Component length overflow */
                                         ipc_answer_0(rid, ENAMETOOLONG);
                                         goto out;
                                 }
+                                
                                 component[len++] = ops->plb_get_char(next);
-                                next++; /* process next character */
+                                /* Process next character */
+                                next++;
                         }
+                        
                         assert(len);
                         component[len] = '\0';
-                                
+                        
                         fs_node_t *fn;
                         if (lflag & L_CREATE)
@@ -409 +473 @@
                                 rc = ops->node_get(&fn, dev_handle, index);
                         on_error(rc, goto out_with_answer);
+                        
                         if (fn) {
                                 rc = ops->link(cur, fn, component);
@@ -416 +481 @@
                                         ipc_answer_0(rid, rc);
                                 } else {
-                                        ipc_answer_5(rid, EOK,
-                                            fs_handle, dev_handle,
+                                        aoff64_t size = ops->size_get(fn);
+                                        ipc_answer_5(rid, fs_handle,
+                                            dev_handle,
                                             ops->index_get(fn),
-                                            ops->size_get(fn),
+                                            LOWER32(size),
+                                            UPPER32(size),
                                             ops->lnkcnt_get(fn));
                                         (void) ops->node_put(fn);
                                 }
-                        } else {
+                        } else
                                 ipc_answer_0(rid, ENOSPC);
-                        }
+                        
                         goto out;
                 }
+                
                 ipc_answer_0(rid, ENOENT);
                 goto out;
         }
+        
 skip_miss:
-
-        /* handle hit */
+        
+        /* Handle hit */
         if (lflag & L_UNLINK) {
-                unsigned old_lnkcnt = ops->lnkcnt_get(cur);
+                unsigned int old_lnkcnt = ops->lnkcnt_get(cur);
                 rc = ops->unlink(par, cur, component);
-                ipc_answer_5(rid, (ipcarg_t)rc, fs_handle, dev_handle,
-                    ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
+                
+                if (rc == EOK) {
+                        aoff64_t size = ops->size_get(cur);
+                        ipc_answer_5(rid, fs_handle, dev_handle,
+                            ops->index_get(cur), LOWER32(size), UPPER32(size),
+                            old_lnkcnt);
+                } else
+                        ipc_answer_0(rid, rc);
+                
                 goto out;
         }
+        
         if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
             (lflag & L_LINK)) {
@@ -446 +523 @@
                 goto out;
         }
+        
         if ((lflag & L_FILE) && (ops->is_directory(cur))) {
                 ipc_answer_0(rid, EISDIR);
                 goto out;
         }
+        
         if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
                 ipc_answer_0(rid, ENOTDIR);
@@ -455 +534 @@
         }
 
+        if ((lflag & L_ROOT) && par) {
+                ipc_answer_0(rid, EINVAL);
+                goto out;
+        }
+        
 out_with_answer:
+        
         if (rc == EOK) {
-                ipc_answer_5(rid, EOK, fs_handle, dev_handle,
-                    ops->index_get(cur), ops->size_get(cur),
-                    ops->lnkcnt_get(cur));
-        } else {
+                if (lflag & L_OPEN)
+                        rc = ops->node_open(cur);
+                
+                if (rc == EOK) {
+                        aoff64_t size = ops->size_get(cur);
+                        ipc_answer_5(rid, fs_handle, dev_handle,
+                            ops->index_get(cur), LOWER32(size), UPPER32(size),
+                            ops->lnkcnt_get(cur));
+                } else
+                        ipc_answer_0(rid, rc);
+                
+        } else
                 ipc_answer_0(rid, rc);
-        }
-
+        
 out:
+        
         if (par)
                 (void) ops->node_put(par);
+        
         if (cur)
                 (void) ops->node_put(cur);
+        
         if (tmp)
                 (void) ops->node_put(tmp);
@@ -478 +573 @@
         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        
         fs_node_t *fn;
-        int rc;
-
-        rc = ops->node_get(&fn, dev_handle, index);
+        int rc = ops->node_get(&fn, dev_handle, index);
         on_error(rc, answer_and_return(rid, rc));
-
+        
         ipc_callid_t callid;
         size_t size;
-        if (!async_data_read_receive(&callid, &size) ||
-            size != sizeof(struct stat)) {
+        if ((!async_data_read_receive(&callid, &size)) ||
+            (size != sizeof(struct stat))) {
+                ops->node_put(fn);
                 ipc_answer_0(callid, EINVAL);
                 ipc_answer_0(rid, EINVAL);
                 return;
         }
-
+        
         struct stat stat;
         memset(&stat, 0, sizeof(struct stat));
@@ -499 +594 @@
         stat.dev_handle = dev_handle;
         stat.index = index;
-        stat.lnkcnt = ops->lnkcnt_get(fn); 
+        stat.lnkcnt = ops->lnkcnt_get(fn);
         stat.is_file = ops->is_file(fn);
+        stat.is_directory = ops->is_directory(fn);
         stat.size = ops->size_get(fn);
-
+        stat.device = ops->device_get(fn);
+        
+        ops->node_put(fn);
+        
         async_data_read_finalize(callid, &stat, sizeof(struct stat));
         ipc_answer_0(rid, EOK);
@@ -509 +608 @@
 /** Open VFS triplet.
  *
- * @param ops       libfs operations structure with function pointers to
- *                  file system implementation
- * @param rid       Request ID of the VFS_OUT_OPEN_NODE request.
- * @param request   VFS_OUT_OPEN_NODE request data itself.
+ * @param ops     libfs operations structure with function pointers to
+ *                file system implementation
+ * @param rid     Request ID of the VFS_OUT_OPEN_NODE request.
+ * @param request VFS_OUT_OPEN_NODE request data itself.
  *
  */
@@ -520 +619 @@
         dev_handle_t dev_handle = IPC_GET_ARG1(*request);
         fs_index_t index = IPC_GET_ARG2(*request);
+        
         fs_node_t *fn;
-        int rc;
-        
-        rc = ops->node_get(&fn, dev_handle, index);
+        int rc = ops->node_get(&fn, dev_handle, index);
         on_error(rc, answer_and_return(rid, rc));
         
@@ -531 +629 @@
         }
         
-        ipc_answer_3(rid, EOK, ops->size_get(fn), ops->lnkcnt_get(fn),
+        rc = ops->node_open(fn);
+        aoff64_t size = ops->size_get(fn);
+        ipc_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn),
             (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0));
         

uspace/lib/fs/libfs.h

@@ -64 +64 @@
         int (* match)(fs_node_t **, fs_node_t *, const char *);
         int (* node_get)(fs_node_t **, dev_handle_t, fs_index_t);
+        int (* node_open)(fs_node_t *);
         int (* node_put)(fs_node_t *);
         int (* create)(fs_node_t **, dev_handle_t, int);
@@ -75 +76 @@
          */
         fs_index_t (* index_get)(fs_node_t *);
-        size_t (* size_get)(fs_node_t *);
-        unsigned (* lnkcnt_get)(fs_node_t *);
+        aoff64_t (* size_get)(fs_node_t *);
+        unsigned int (* lnkcnt_get)(fs_node_t *);
         char (* plb_get_char)(unsigned pos);
         bool (* is_directory)(fs_node_t *);
         bool (* is_file)(fs_node_t *);
+        dev_handle_t (* device_get)(fs_node_t *);
 } libfs_ops_t;
 
@@ -93 +95 @@
 
 extern void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
+extern void libfs_unmount(libfs_ops_t *, ipc_callid_t, ipc_call_t *);
 extern void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
 extern void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);