Changes in uspace/srv/vfs/vfs_ops.c [c69646f8:b72efe8] in mainline

File:

• uspace/srv/vfs/vfs_ops.c (modified) (27 diffs)

uspace/srv/vfs/vfs_ops.c

@@ -54 +54 @@
 
 /* Forward declarations of static functions. */
-static int vfs_truncate_internal(fs_handle_t, service_id_t, fs_index_t,
+static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
     aoff64_t);
 
@@ -65 +65 @@
 vfs_pair_t rootfs = {
         .fs_handle = 0,
-        .service_id = 0
+        .devmap_handle = 0
 };
 
-static void vfs_mount_internal(ipc_callid_t rid, service_id_t service_id,
+static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
     fs_handle_t fs_handle, char *mp, char *opts)
 {
@@ -76 +76 @@
         vfs_node_t *mr_node;
         fs_index_t rindex;
-        aoff64_t rsize;
+        size_t rsize;
         unsigned rlnkcnt;
         async_exch_t *exch;
@@ -125 +125 @@
                         exch = vfs_exchange_grab(fs_handle);
                         msg = async_send_1(exch, VFS_OUT_MOUNTED,
-                            (sysarg_t) service_id, &answer);
+                            (sysarg_t) devmap_handle, &answer);
                         /* Send the mount options */
                         rc = async_data_write_start(exch, (void *)opts,
@@ -146 +146 @@
 
                         rindex = (fs_index_t) IPC_GET_ARG1(answer);
-                        rsize = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
-                        rlnkcnt = (unsigned) IPC_GET_ARG4(answer);
+                        rsize = (size_t) IPC_GET_ARG2(answer);
+                        rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
                         
                         mr_res.triplet.fs_handle = fs_handle;
-                        mr_res.triplet.service_id = service_id;
+                        mr_res.triplet.devmap_handle = devmap_handle;
                         mr_res.triplet.index = rindex;
                         mr_res.size = rsize;
@@ -157 +157 @@
                         
                         rootfs.fs_handle = fs_handle;
-                        rootfs.service_id = service_id;
+                        rootfs.devmap_handle = devmap_handle;
                         
                         /* Add reference to the mounted root. */
@@ -178 +178 @@
         
         /*
-         * At this point, we have all necessary pieces: file system handle
-         * and service ID, and we know the mount point VFS node.
+         * At this point, we have all necessary pieces: file system and device
+         * handles, and we know the mount point VFS node.
          */
         
@@ -187 +187 @@
         exch = vfs_exchange_grab(mp_res.triplet.fs_handle);
         msg = async_send_4(exch, VFS_OUT_MOUNT,
-            (sysarg_t) mp_res.triplet.service_id,
+            (sysarg_t) mp_res.triplet.devmap_handle,
             (sysarg_t) mp_res.triplet.index,
             (sysarg_t) fs_handle,
-            (sysarg_t) service_id, &answer);
+            (sysarg_t) devmap_handle, &answer);
         
         /* Send connection */
@@ -224 +224 @@
         }
         
-        /*
-         * Wait for the answer before releasing the exchange to avoid deadlock
-         * in case the answer depends on further calls to the same file system.
-         * Think of a case when mounting a FS on a file_bd backed by a file on
-         * the same FS. 
-         */
+        vfs_exchange_release(exch);
         async_wait_for(msg, &rc);
-        vfs_exchange_release(exch);
         
         if (rc == EOK) {
                 rindex = (fs_index_t) IPC_GET_ARG1(answer);
-                rsize = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(answer),
-                    IPC_GET_ARG3(answer));
-                rlnkcnt = (unsigned) IPC_GET_ARG4(answer);
+                rsize = (size_t) IPC_GET_ARG2(answer);
+                rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
                 
                 mr_res.triplet.fs_handle = fs_handle;
-                mr_res.triplet.service_id = service_id;
+                mr_res.triplet.devmap_handle = devmap_handle;
                 mr_res.triplet.index = rindex;
                 mr_res.size = rsize;
@@ -261 +254 @@
 void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
 {
-        service_id_t service_id;
+        devmap_handle_t devmap_handle;
 
         /*
@@ -268 +261 @@
          * in the request.
          */
-        service_id = (service_id_t) IPC_GET_ARG1(*request);
+        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         
         /*
@@ -356 +349 @@
         
         /* Do the mount */
-        vfs_mount_internal(rid, service_id, fs_handle, mp, opts);
+        vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
         free(mp);
         free(fs_name);
@@ -415 +408 @@
          */
         if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
-            mr_node->service_id) != 2) {
+            mr_node->devmap_handle) != 2) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
                 vfs_node_put(mr_node);
@@ -436 +429 @@
                 exch = vfs_exchange_grab(mr_node->fs_handle);
                 rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
-                    mr_node->service_id);
+                    mr_node->devmap_handle);
                 vfs_exchange_release(exch);
                 
@@ -447 +440 @@
                 
                 rootfs.fs_handle = 0;
-                rootfs.service_id = 0;
+                rootfs.devmap_handle = 0;
         } else {
                 
@@ -476 +469 @@
                 exch = vfs_exchange_grab(mp_node->fs_handle);
                 rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
-                    mp_node->service_id, mp_node->index);
+                    mp_node->devmap_handle, mp_node->index);
                 vfs_exchange_release(exch);
                 
@@ -581 +574 @@
                 if (node->size) {
                         rc = vfs_truncate_internal(node->fs_handle,
-                            node->service_id, node->index, 0);
+                            node->devmap_handle, node->index, 0);
                         if (rc) {
                                 fibril_rwlock_write_unlock(&node->contents_rwlock);
@@ -624 +617 @@
 }
 
+void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
+{
+        // FIXME: check for sanity of the supplied fs, dev and index
+        
+        /*
+         * The interface is open_node(fs, dev, index, oflag).
+         */
+        vfs_lookup_res_t lr;
+        
+        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
+        lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
+        lr.triplet.index = IPC_GET_ARG3(*request);
+        int oflag = IPC_GET_ARG4(*request);
+        
+        fibril_rwlock_read_lock(&namespace_rwlock);
+        
+        int rc = vfs_open_node_internal(&lr);
+        if (rc != EOK) {
+                fibril_rwlock_read_unlock(&namespace_rwlock);
+                async_answer_0(rid, rc);
+                return;
+        }
+        
+        vfs_node_t *node = vfs_node_get(&lr);
+        fibril_rwlock_read_unlock(&namespace_rwlock);
+        
+        /* Truncate the file if requested and if necessary. */
+        if (oflag & O_TRUNC) {
+                fibril_rwlock_write_lock(&node->contents_rwlock);
+                if (node->size) {
+                        rc = vfs_truncate_internal(node->fs_handle,
+                            node->devmap_handle, node->index, 0);
+                        if (rc) {
+                                fibril_rwlock_write_unlock(&node->contents_rwlock);
+                                vfs_node_put(node);
+                                async_answer_0(rid, rc);
+                                return;
+                        }
+                        node->size = 0;
+                }
+                fibril_rwlock_write_unlock(&node->contents_rwlock);
+        }
+        
+        /*
+         * Get ourselves a file descriptor and the corresponding vfs_file_t
+         * structure.
+         */
+        int fd = vfs_fd_alloc((oflag & O_DESC) != 0);
+        if (fd < 0) {
+                vfs_node_put(node);
+                async_answer_0(rid, fd);
+                return;
+        }
+        vfs_file_t *file = vfs_file_get(fd);
+        file->node = node;
+        if (oflag & O_APPEND)
+                file->append = true;
+        
+        /*
+         * The following increase in reference count is for the fact that the
+         * file is being opened and that a file structure is pointing to it.
+         * It is necessary so that the file will not disappear when
+         * vfs_node_put() is called. The reference will be dropped by the
+         * respective VFS_IN_CLOSE.
+         */
+        vfs_node_addref(node);
+        vfs_node_put(node);
+        vfs_file_put(file);
+        
+        /* Success! Return the new file descriptor to the client. */
+        async_answer_1(rid, EOK, fd);
+}
+
 void vfs_sync(ipc_callid_t rid, ipc_call_t *request)
 {
@@ -645 +711 @@
         aid_t msg;
         ipc_call_t answer;
-        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->service_id,
+        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
             file->node->index, &answer);
         
@@ -729 +795 @@
         ipc_call_t answer;
         if (read) {
-                rc = async_data_read_forward_4_1(fs_exch, VFS_OUT_READ,
-                    file->node->service_id, file->node->index,
-                    LOWER32(file->pos), UPPER32(file->pos), &answer);
+                rc = async_data_read_forward_3_1(fs_exch, VFS_OUT_READ,
+                    file->node->devmap_handle, file->node->index, file->pos,
+                    &answer);
         } else {
                 if (file->append)
                         file->pos = file->node->size;
                 
-                rc = async_data_write_forward_4_1(fs_exch, VFS_OUT_WRITE,
-                    file->node->service_id, file->node->index,
-                    LOWER32(file->pos), UPPER32(file->pos), &answer);
+                rc = async_data_write_forward_3_1(fs_exch, VFS_OUT_WRITE,
+                    file->node->devmap_handle, file->node->index, file->pos,
+                    &answer);
         }
         
@@ -755 +821 @@
                 /* Update the cached version of node's size. */
                 if (rc == EOK)
-                        file->node->size = MERGE_LOUP32(IPC_GET_ARG2(answer),
-                            IPC_GET_ARG3(answer));
+                        file->node->size = IPC_GET_ARG2(answer); 
                 fibril_rwlock_write_unlock(&file->node->contents_rwlock);
         }
@@ -868 +933 @@
 }
 
-int vfs_truncate_internal(fs_handle_t fs_handle, service_id_t service_id,
+int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
     fs_index_t index, aoff64_t size)
 {
         async_exch_t *exch = vfs_exchange_grab(fs_handle);
         sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
-            (sysarg_t) service_id, (sysarg_t) index, LOWER32(size),
+            (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
             UPPER32(size));
         vfs_exchange_release(exch);
@@ -896 +961 @@
         fibril_rwlock_write_lock(&file->node->contents_rwlock);
         rc = vfs_truncate_internal(file->node->fs_handle,
-            file->node->service_id, file->node->index, size);
+            file->node->devmap_handle, file->node->index, size);
         if (rc == EOK)
                 file->node->size = size;
@@ -930 +995 @@
         
         aid_t msg;
-        msg = async_send_3(exch, VFS_OUT_STAT, file->node->service_id,
+        msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
             file->node->index, true, NULL);
         async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
@@ -983 +1048 @@
         
         aid_t msg;
-        msg = async_send_3(exch, VFS_OUT_STAT, node->service_id,
+        msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
             node->index, false, NULL);
         async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
@@ -1160 +1225 @@
         /* Check whether linking to the same file system instance. */
         if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
-            (old_node->service_id != new_par_lr.triplet.service_id)) {
+            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
                 fibril_rwlock_write_unlock(&namespace_rwlock);
                 vfs_node_put(old_node);
@@ -1282 +1347 @@
 }
 
-void vfs_wait_handle(ipc_callid_t rid, ipc_call_t *request)
-{
-        int fd = vfs_wait_handle_internal();
-        async_answer_1(rid, EOK, fd);
-}
-
 /**
  * @}