Changeset 354b642 in mainline for uspace/srv/vfs

Timestamp:

2017-03-07T10:53:31Z (8 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

a274a5f

Parents:

c577a9a

git-author:

Jiri Zarevucky <zarevucky.jiri@…> (2017-03-07 10:53:31)

git-committer:

Jakub Jermar <jakub@…> (2017-03-07 10:53:31)

Message:

Merge from lp:~zarevucky-jiri/helenos/vfs-2.5/ revisions 1932-1936

Original commit messages:

1936: Jiri Zarevucky 2013-08-05 Modifications to vfs_rdwr.
1935: Jiri Zarevucky 2013-08-05 Fix a bug in read/write.
1934: Jiri Zarevucky 2013-08-05 Fix a hidden bug in handle passing.
1933: Jiri Zarevucky 2013-08-05 Add VFS_IN_CLONE.
1932: Jiri Zarevucky 2013-08-05 Add functions for passing handles around.

Modifications:

• New vcl_* interfaces renamed to vfs_*
• Server-side vfs_pass_handle() and vfs_clone() renamed to vfs_op_* to avoid name conflict with libc

Location:

uspace/srv/vfs

Files:

• vfs.c (modified) (2 diffs)
• vfs.h (modified) (2 diffs)
• vfs_file.c (modified) (3 diffs)
• vfs_ops.c (modified) (6 diffs)

uspace/srv/vfs/vfs.c

@@ -149 +149 @@
                         vfs_statfs(callid, &call);
                         break;
+                case VFS_IN_CLONE:
+                        vfs_op_clone(callid, &call);
+                        break;
                 default:
                         async_answer_0(callid, ENOTSUP);
@@ -164 +167 @@
 {
         if (IPC_GET_ARG1(*call) == VFS_PASS_HANDLE)
-                vfs_pass_handle(
+                vfs_op_pass_handle(
                     (task_id_t) MERGE_LOUP32(IPC_GET_ARG4(*call),
                     IPC_GET_ARG5(*call)), call->in_task_id,

uspace/srv/vfs/vfs.h

@@ -196 +196 @@
 extern void vfs_client_data_destroy(void *);
 
-extern void vfs_pass_handle(task_id_t, task_id_t, int);
+extern void vfs_op_pass_handle(task_id_t, task_id_t, int);
 extern int vfs_wait_handle_internal(void);
 
@@ -237 +237 @@
 extern void vfs_open2(ipc_callid_t, ipc_call_t *);
 extern void vfs_unlink2(ipc_callid_t, ipc_call_t *);
+extern void vfs_op_clone(ipc_callid_t, ipc_call_t *);
 
 #endif

uspace/srv/vfs/vfs_file.c

@@ -360 +360 @@
 }
 
-void vfs_pass_handle(task_id_t donor_id, task_id_t acceptor_id, int donor_fd)
+void vfs_op_pass_handle(task_id_t donor_id, task_id_t acceptor_id, int donor_fd)
 {
         vfs_client_data_t *donor_data = NULL;
@@ -397 +397 @@
          */
         vfs_node_addref(donor_file->node);
-        (void) vfs_open_node_remote(donor_file->node);
 
         assert(acceptor_file);
@@ -412 +411 @@
         acceptor_file->open_read = donor_file->open_read;
         acceptor_file->open_write = donor_file->open_write;
+
+        if (acceptor_file->open_read || acceptor_file->open_write) {
+                (void) vfs_open_node_remote(acceptor_file->node);
+        }
 
 out:

uspace/srv/vfs/vfs_ops.c

@@ -696 +696 @@
         vfs_file_t *file = vfs_file_get(fd);
         if (!file)
-                return ENOENT;
+                return EBADF;
         
         if ((read && !file->open_read) || (!read && !file->open_write)) {
@@ -705 +705 @@
         vfs_info_t *fs_info = fs_handle_to_info(file->node->fs_handle);
         assert(fs_info);
+        
+        bool rlock = read || ((fs_info->concurrent_read_write) && (fs_info->write_retains_size));
         
         /*
@@ -711 +713 @@
          * write implementation does not modify the file size.
          */
-        if ((read) ||
-            ((fs_info->concurrent_read_write) && (fs_info->write_retains_size)))
+        if (rlock) {
                 fibril_rwlock_read_lock(&file->node->contents_rwlock);
-        else
+        } else {
                 fibril_rwlock_write_lock(&file->node->contents_rwlock);
+        }
         
         if (file->node->type == VFS_NODE_DIRECTORY) {
@@ -722 +724 @@
                  * while we are in readdir().
                  */
-                assert(read);
+                
+                if (!read) {
+                        if (rlock) {
+                                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
+                        } else {
+                                fibril_rwlock_write_unlock(&file->node->contents_rwlock);
+                        }
+                        vfs_file_put(file);
+                        return EINVAL;
+                }
+                
                 fibril_rwlock_read_lock(&namespace_rwlock);
         }
@@ -746 +758 @@
         
         /* Unlock the VFS node. */
-        if ((read) ||
-            ((fs_info->concurrent_read_write) && (fs_info->write_retains_size)))
+        if (rlock) {
                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
-        else {
+        } else {
                 /* Update the cached version of node's size. */
-                if (rc == EOK)
+                if (rc == EOK) {
                         file->node->size = MERGE_LOUP32(IPC_GET_ARG2(answer),
                             IPC_GET_ARG3(answer));
+                }
                 fibril_rwlock_write_unlock(&file->node->contents_rwlock);
         }
         
         /* Update the position pointer and unlock the open file. */
-        if (rc == EOK)
+        if (rc == EOK) {
                 file->pos += bytes;
+        }
         vfs_file_put(file);     
 
@@ -1354 +1367 @@
 }
 
+void vfs_op_clone(ipc_callid_t rid, ipc_call_t *request)
+{
+        int oldfd = IPC_GET_ARG1(*request);
+        bool desc = IPC_GET_ARG2(*request);
+        
+        /* Lookup the file structure corresponding to fd. */
+        vfs_file_t *oldfile = vfs_file_get(oldfd);
+        if (!oldfile) {
+                async_answer_0(rid, EBADF);
+                return;
+        }
+        
+        vfs_file_t *newfile;
+        int newfd = vfs_fd_alloc(&newfile, desc);
+        if (newfd < 0) {
+                async_answer_0(rid, newfd);
+                vfs_file_put(oldfile);
+                return;
+        }
+        
+        assert(oldfile->node != NULL);
+        
+        newfile->node = oldfile->node;
+        newfile->permissions = oldfile->permissions;
+
+        vfs_file_put(oldfile);
+        vfs_file_put(newfile);
+        
+        async_answer_0(rid, newfd);
+}
+
 /**
  * @}