Changeset 5a4fef9 in mainline for uspace/srv/vfs/vfs_ops.c

Timestamp:

2009-11-16T21:24:28Z (14 years ago)

Author:

Pavel Rimsky <pavel@…>

Branches:

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

Children:

18baf9c0

Parents:

5f678b1c (diff), 9c70ed6 (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:

merged head changes to this branch

File:

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

uspace/srv/vfs/vfs_ops.c

@@ -543 +543 @@
          * structure.
          */
-        int fd = vfs_fd_alloc();
+        int fd = vfs_fd_alloc((oflag & O_DESC) != 0);
         if (fd < 0) {
                 vfs_node_put(node);
@@ -620 +620 @@
          * structure.
          */
-        int fd = vfs_fd_alloc();
+        int fd = vfs_fd_alloc((oflag & O_DESC) != 0);
         if (fd < 0) {
                 vfs_node_put(node);
@@ -679 +679 @@
 }
 
+static int vfs_close_internal(vfs_file_t *file)
+{
+        /*
+         * Lock the open file structure so that no other thread can manipulate
+         * the same open file at a time.
+         */
+        fibril_mutex_lock(&file->lock);
+        
+        if (file->refcnt <= 1) {
+                /* Only close the file on the destination FS server
+                   if there are no more file descriptors (except the
+                   present one) pointing to this file. */
+                
+                int fs_phone = vfs_grab_phone(file->node->fs_handle);
+                
+                /* Make a VFS_OUT_CLOSE request at the destination FS server. */
+                aid_t msg;
+                ipc_call_t answer;
+                msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
+                    file->node->index, &answer);
+                
+                /* Wait for reply from the FS server. */
+                ipcarg_t rc;
+                async_wait_for(msg, &rc);
+                
+                vfs_release_phone(fs_phone);
+                fibril_mutex_unlock(&file->lock);
+                
+                return IPC_GET_ARG1(answer);
+        }
+        
+        fibril_mutex_unlock(&file->lock);
+        return EOK;
+}
+
 void vfs_close(ipc_callid_t rid, ipc_call_t *request)
 {
@@ -690 +725 @@
         }
         
-        /*
-         * Lock the open file structure so that no other thread can manipulate
-         * the same open file at a time.
-         */
-        fibril_mutex_lock(&file->lock);
-        int fs_phone = vfs_grab_phone(file->node->fs_handle);
-        
-        /* Make a VFS_OUT_CLOSE request at the destination FS server. */
-        aid_t msg;
-        ipc_call_t answer;
-        msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
-            file->node->index, &answer);
-
-        /* Wait for reply from the FS server. */
-        ipcarg_t rc;
-        async_wait_for(msg, &rc);
-
-        vfs_release_phone(fs_phone);
-        fibril_mutex_unlock(&file->lock);
-        
-        int retval = IPC_GET_ARG1(answer);
-        if (retval != EOK)
-                ipc_answer_0(rid, retval);
-        
-        retval = vfs_fd_free(fd);
-        ipc_answer_0(rid, retval);
+        int ret = vfs_close_internal(file);
+        if (ret != EOK)
+                ipc_answer_0(rid, ret);
+        
+        ret = vfs_fd_free(fd);
+        ipc_answer_0(rid, ret);
 }
 
@@ -1310 +1325 @@
 }
 
+void vfs_dup(ipc_callid_t rid, ipc_call_t *request)
+{
+        int oldfd = IPC_GET_ARG1(*request);
+        int newfd = IPC_GET_ARG2(*request);
+        
+        /* Lookup the file structure corresponding to oldfd. */
+        vfs_file_t *oldfile = vfs_file_get(oldfd);
+        if (!oldfile) {
+                ipc_answer_0(rid, EBADF);
+                return;
+        }
+        
+        /* If the file descriptors are the same, do nothing. */
+        if (oldfd == newfd) {
+                ipc_answer_1(rid, EOK, newfd);
+                return;
+        }
+        
+        /*
+         * Lock the open file structure so that no other thread can manipulate
+         * the same open file at a time.
+         */
+        fibril_mutex_lock(&oldfile->lock);
+        
+        /* Lookup an open file structure possibly corresponding to newfd. */
+        vfs_file_t *newfile = vfs_file_get(newfd);
+        if (newfile) {
+                /* Close the originally opened file. */
+                int ret = vfs_close_internal(newfile);
+                if (ret != EOK) {
+                        ipc_answer_0(rid, ret);
+                        return;
+                }
+                
+                ret = vfs_fd_free(newfd);
+                if (ret != EOK) {
+                        ipc_answer_0(rid, ret);
+                        return;
+                }
+        }
+        
+        /* Assign the old file to newfd. */
+        int ret = vfs_fd_assign(oldfile, newfd);
+        fibril_mutex_unlock(&oldfile->lock);
+        
+        if (ret != EOK)
+                ipc_answer_0(rid, ret);
+        else
+                ipc_answer_1(rid, EOK, newfd);
+}
+
 /**
  * @}