WebSVN – HelenOS – Diff – /branches/tracing/uspace/srv/vfs/vfs_ops.c

  * concurrent VFS operation which modifies the file system namespace.
  */
 RWLOCK_INITIALIZE(namespace_rwlock);
 futex_t rootfs_futex = FUTEX_INITIALIZER;
-vfs_triplet_t rootfs = {
+vfs_pair_t rootfs = {
     .fs_handle = 0,
-    .dev_handle = 0,
+    .dev_handle = 0
-    .index = 0,
 };
-static int
-lookup_root(fs_handle_t fs_handle, dev_handle_t dev_handle,
-    vfs_lookup_res_t *result)
-{
-    vfs_pair_t altroot = {
-        .fs_handle = fs_handle,
-        .dev_handle = dev_handle,
-    };
-    return vfs_lookup_internal("/", L_DIRECTORY, result, &altroot);
-}
 void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
+{
     dev_handle_t dev_handle;
     vfs_node_t *mp_node = NULL;
     int rc;
     /* Deliver the mount point. */
     (void) ipc_data_write_finalize(callid, buf, size);
     buf[size] = '\0';
-    /*
-     * Lookup the root node of the filesystem being mounted.
-     * In this case, we don't need to take the namespace_futex as the root
-     * node cannot be removed. However, we do take a reference to it so
-     * that we can track how many times it has been mounted.
-     */
-    vfs_lookup_res_t mr_res;
-    rc = lookup_root(fs_handle, dev_handle, &mr_res);
-    if (rc != EOK) {
-        free(buf);
-        ipc_answer_0(rid, rc);
-        return;
-    }
-    vfs_node_t *mr_node = vfs_node_get(&mr_res);
-    if (!mr_node) {
-        free(buf);
-        ipc_answer_0(rid, ENOMEM);
-        return;
-    }
-    /* Finally, we need to resolve the path to the mountpoint. */
+    /* Resolve the path to the mountpoint. */
     vfs_lookup_res_t mp_res;
     futex_down(&rootfs_futex);
     if (rootfs.fs_handle) {
         /* We already have the root FS. */
         rwlock_write_lock(&namespace_rwlock);
         if ((size == 1) && (buf[0] == '/')) {
             /* Trying to mount root FS over root FS */
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            vfs_node_put(mr_node);
             free(buf);
             ipc_answer_0(rid, EBUSY);
             return;
+        }
         rc = vfs_lookup_internal(buf, L_DIRECTORY, &mp_res, NULL);
         if (rc != EOK) {
             /* The lookup failed for some reason. */
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            vfs_node_put(mr_node);  /* failed -> drop reference */
             free(buf);
             ipc_answer_0(rid, rc);
             return;
+        }
         mp_node = vfs_node_get(&mp_res);
         if (!mp_node) {
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            vfs_node_put(mr_node);  /* failed -> drop reference */
             free(buf);
             ipc_answer_0(rid, ENOMEM);
             return;
+        }
         /*
              * For this simple, but important case,
              * we are almost done.
              */
             free(buf);
-            /* Inform the mount point about the root mount. */
+            /* Tell the mountee that it is being mounted. */
-            phone = vfs_grab_phone(mr_res.triplet.fs_handle);
+            phone = vfs_grab_phone(fs_handle);
-            rc = async_req_5_0(phone, VFS_MOUNT,
+            rc = async_req_1_0(phone, VFS_MOUNTED,
-                (ipcarg_t) mr_res.triplet.dev_handle,
-                (ipcarg_t) mr_res.triplet.index,
-                (ipcarg_t) mr_res.triplet.fs_handle,
-                (ipcarg_t) mr_res.triplet.dev_handle,
+                (ipcarg_t) dev_handle);
-                (ipcarg_t) mr_res.triplet.index);
             vfs_release_phone(phone);
-            if (rc == EOK)
+            if (rc == EOK) {
-                rootfs = mr_res.triplet;
+                rootfs.fs_handle = fs_handle;
+                rootfs.dev_handle = dev_handle;
-            else
+            }
-                vfs_node_put(mr_node);
             futex_up(&rootfs_futex);
             ipc_answer_0(rid, rc);
             return;
         } else {
              * We can't resolve this without the root filesystem
              * being mounted first.
              */
             futex_up(&rootfs_futex);
             free(buf);
-            vfs_node_put(mr_node);  /* failed -> drop reference */
             ipc_answer_0(rid, ENOENT);
             return;
+        }
+    }
     futex_up(&rootfs_futex);
     free(buf);  /* The buffer is not needed anymore. */
     /*
      * At this point, we have all necessary pieces: file system and device
-     * handles, and we know the mount point VFS node and also the root node
+     * handles, and we know the mount point VFS node.
-     * of the file system being mounted.
      */
-    /**
-     * @todo
-     * Add more IPC parameters so that we can send mount mode/flags.
-     */
     phone = vfs_grab_phone(mp_res.triplet.fs_handle);
-    rc = async_req_5_0(phone, VFS_MOUNT,
+    rc = async_req_4_0(phone, VFS_MOUNT,
         (ipcarg_t) mp_res.triplet.dev_handle,
         (ipcarg_t) mp_res.triplet.index,
-        (ipcarg_t) mr_res.triplet.fs_handle,
+        (ipcarg_t) fs_handle,
-        (ipcarg_t) mr_res.triplet.dev_handle,
+        (ipcarg_t) dev_handle);
-        (ipcarg_t) mr_res.triplet.index);
     vfs_release_phone(phone);
     if (rc != EOK) {
-        /* Mount failed, drop references to mr_node and mp_node. */
+        /* Mount failed, drop reference to mp_node. */
-        vfs_node_put(mr_node);
         if (mp_node)
             vfs_node_put(mp_node);
+    }
     ipc_answer_0(rid, rc);
      * Additional synchronization needs to be added once the table of
      * open files supports parallel access!
      */
     int fd = IPC_GET_ARG1(*request);
     /* Lookup the file structure corresponding to the file descriptor. */
     vfs_file_t *file = vfs_file_get(fd);
     if (!file) {
         ipc_answer_0(rid, ENOENT);
         return;
+    }
     /*
      * Now we need to receive a call with client's
      * IPC_M_DATA_READ/IPC_M_DATA_WRITE request.
      */
     ipc_callid_t callid;
     if (!res) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
+    }
     /*
      * Lock the open file structure so that no other thread can manipulate
      * the same open file at a time.
      */
     futex_down(&file->lock);
     /*
      * Lock the file's node so that no other client can read/write to it at
      * the same time.
      */
     if (read)
         rwlock_read_lock(&file->node->contents_rwlock);
     else
         rwlock_write_lock(&file->node->contents_rwlock);
     int fs_phone = vfs_grab_phone(file->node->fs_handle);
     /* Make a VFS_READ/VFS_WRITE request at the destination FS server. */
     aid_t msg;
     ipc_call_t answer;
      * destination FS server. The call will be routed as if sent by
      * ourselves. Note that call arguments are immutable in this case so we
      * don't have to bother.
      */
     ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
     vfs_release_phone(fs_phone);
     /* Wait for reply from the FS server. */
     ipcarg_t rc;
     async_wait_for(msg, &rc);
     size_t bytes = IPC_GET_ARG1(answer);
     /* Unlock the VFS node. */
     if (read)
         rwlock_read_unlock(&file->node->contents_rwlock);
     else {
         /* Update the cached version of node's size. */
         if (rc == EOK)
             file->node->size = IPC_GET_ARG2(answer);
         rwlock_write_unlock(&file->node->contents_rwlock);
+    }
     /* Update the position pointer and unlock the open file. */
     if (rc == EOK)
         file->pos += bytes;
     futex_up(&file->lock);
     /*
      * FS server's reply is the final result of the whole operation we
      * return to the client.
      */
     ipc_answer_1(rid, rc, bytes);

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/srv/vfs/vfs_ops.c – Rev 3011 → 3424