Changeset 5cde90f in mainline for uspace/lib/libfs/libfs.c

Timestamp:

2010-02-19T17:16:46Z (14 years ago)

Author:

Pavel Rimsky <pavel@…>

Branches:

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

Children:

617652f

Parents:

b86d436 (diff), f41aa81 (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:

Synchronizing with head (which has just been synchronized with this branch).

File:

• uspace/lib/libfs/libfs.c (modified) (15 diffs)

uspace/lib/libfs/libfs.c

@@ -37 +37 @@
 #include "libfs.h"
 #include "../../srv/vfs/vfs.h"
+#include <macros.h>
 #include <errno.h>
 #include <async.h>
@@ -161 +162 @@
         /* 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)) {
@@ -172 +173 @@
         ipc_answer_0(callid, EOK);
         
-        res = async_data_write_receive(&callid, NULL);
-        if (!res) {
-                ipc_hangup(mountee_phone);
-                ipc_answer_0(callid, EINVAL);
-                ipc_answer_0(rid, EINVAL);
-                return;
-        }
-        
         fs_node_t *fn;
         res = ops->node_get(&fn, mp_dev_handle, mp_fs_index);
         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;
@@ -192 +185 @@
                 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;
@@ -201 +194 @@
                 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;
@@ -207 +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) {
@@ -224 +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);
 }
 
@@ -304 +340 @@
                 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;
@@ -352 +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);
@@ -432 +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);
@@ -455 +506 @@
                 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;
         }
@@ -475 +533 @@
                 goto out;
         }
+
+        if ((lflag & L_ROOT) && par) {
+                ipc_answer_0(rid, EINVAL);
+                goto out;
+        }
         
 out_with_answer:
@@ -482 +545 @@
                         rc = ops->node_open(cur);
                 
-                ipc_answer_5(rid, rc, fs_handle, dev_handle,
-                    ops->index_get(cur), ops->size_get(cur),
-                    ops->lnkcnt_get(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);
@@ -551 +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));
         
@@ -563 +630 @@
         
         rc = ops->node_open(fn);
-        ipc_answer_3(rid, rc, ops->size_get(fn), ops->lnkcnt_get(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));