Changeset cb65bbe in mainline

Timestamp:

2013-07-23T22:43:48Z (11 years ago)

Author:

Ji?? Z?rev?cky <zarevucky.jiri@…>

Branches:

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

Children:

0b18364

Parents:

c442f63

Message:

Implement server side of VFS_WALK and VFS_OPEN2.

Location:

uspace

Files:

• lib/c/include/ipc/vfs.h (modified) (2 diffs)
• srv/vfs/vfs.c (modified) (1 diff)
• srv/vfs/vfs.h (modified) (2 diffs)
• srv/vfs/vfs_file.c (modified) (1 diff)
• srv/vfs/vfs_ops.c (modified) (3 diffs)

uspace/lib/c/include/ipc/vfs.h

@@ -82 +82 @@
         VFS_IN_WAIT_HANDLE,
         VFS_IN_MTAB_GET,
+        VFS_IN_WALK,
+        VFS_IN_OPEN2,
 } vfs_in_request_t;
 
@@ -168 +170 @@
 #define L_OPEN                  256
 
+/*
+ * Walk flags.
+ */
+enum {
+        /**
+         * WALK_PARTIAL requests that if the whole path cannot be traversed,
+         * the walk() operation should return the last visited file, along
+         * with an indication of how many directories have been traversed.
+         */
+        //WALK_PARTIAL = (1 << 0),
+        
+        WALK_ALL_FLAGS = 0,
+};
+
+enum {
+        MODE_READ = 1,
+        MODE_WRITE = 2,
+        MODE_APPEND = 4,
+};
+
 #endif
 

uspace/srv/vfs/vfs.c

@@ -85 +85 @@
                         vfs_unmount(callid, &call);
                         break;
+                case VFS_IN_WALK:
+                        vfs_walk(callid, &call);
+                        break;
+                case VFS_IN_OPEN2:
+                        vfs_open(callid, &call);
+                        break;
                 case VFS_IN_OPEN:
                         vfs_open(callid, &call);

uspace/srv/vfs/vfs.h

@@ -137 +137 @@
         /** Number of file handles referencing this file. */
         unsigned refcnt;
+
+        int permissions;
+        bool open_read;
+        bool open_write;
 
         /** Append on write. */
@@ -223 +227 @@
 extern void vfs_get_mtab(ipc_callid_t, ipc_call_t *);
 
+extern void vfs_walk(ipc_callid_t, ipc_call_t *);
+extern void vfs_create(ipc_callid_t, ipc_call_t *);
+extern void vfs_open2(ipc_callid_t, ipc_call_t *);
+
 #endif
 

uspace/srv/vfs/vfs_file.c

@@ -177 +177 @@
                  * endpoint FS and drop our reference to the underlying VFS node.
                  */
-                rc = vfs_file_close_remote(file);
+                if (file->open_read || file->open_write) {
+                        rc = vfs_file_close_remote(file);
+                }
                 vfs_node_delref(file->node);
                 free(file);

uspace/srv/vfs/vfs_ops.c

@@ -568 +568 @@
 }
 
+void vfs_walk(ipc_callid_t rid, ipc_call_t *request)
+{
+        /*
+         * Parent is our relative root for file lookup.
+         * For defined flags, see <ipc/vfs.h>.
+         */
+        int parentfd = IPC_GET_ARG1(*request);
+        int flags = IPC_GET_ARG2(*request);
+        
+        if ((flags&~WALK_ALL_FLAGS) != 0) {
+                /* Invalid flags. */
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+        
+        char *path;
+        int rc = async_data_write_accept((void **)&path, true, 0, 0, 0, NULL);
+        
+        /* Lookup the file structure corresponding to the file descriptor. */
+        vfs_file_t *parent = NULL;
+        vfs_pair_t *parent_node = NULL;
+        // TODO: Client-side root.
+        if (parentfd != -1) {
+                parent = vfs_file_get(parentfd);
+                if (!parent) {
+                        free(path);
+                        async_answer_0(rid, EBADF);
+                        return;
+                }
+                parent_node = (vfs_pair_t *)parent->node;
+        }
+        
+        fibril_rwlock_read_lock(&namespace_rwlock);
+        
+        vfs_lookup_res_t lr;
+        rc = vfs_lookup_internal(path, 0, &lr, parent_node);
+        free(path);
+
+        if (rc != EOK) {
+                fibril_rwlock_read_unlock(&namespace_rwlock);
+                if (parent) {
+                        vfs_file_put(parent);
+                }
+                async_answer_0(rid, rc);
+                return;
+        }
+        
+        vfs_node_t *node = vfs_node_get(&lr);
+        
+        int fd = vfs_fd_alloc(false);
+        if (fd < 0) {
+                vfs_node_put(node);
+                if (parent) {
+                        vfs_file_put(parent);
+                }
+                async_answer_0(rid, fd);
+                return;
+        }
+        
+        vfs_file_t *file = vfs_file_get(fd);
+        assert(file != NULL);
+        
+        file->node = node;
+        if (parent) {
+                file->permissions = parent->permissions;
+        } else {
+                file->permissions = MODE_READ | MODE_WRITE | MODE_APPEND;
+        }
+        file->open_read = false;
+        file->open_write = false;
+        
+        vfs_node_addref(node);
+        vfs_node_put(node);
+        vfs_file_put(file);
+        if (parent) {
+                vfs_file_put(parent);
+        }
+        
+        fibril_rwlock_read_unlock(&namespace_rwlock);
+
+        async_answer_1(rid, EOK, fd);
+}
+
+void vfs_open2(ipc_callid_t rid, ipc_call_t *request)
+{
+        int fd = IPC_GET_ARG1(*request);
+        int flags = IPC_GET_ARG2(*request);
+
+        if (flags == 0) {
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+
+        vfs_file_t *file = vfs_file_get(fd);
+        if (!file) {
+                async_answer_0(rid, EBADF);
+                return;
+        }
+        
+        if ((flags & ~file->permissions) != 0) {
+                vfs_file_put(file);
+                async_answer_0(rid, EPERM);
+                return;
+        }
+        
+        file->open_read = (flags & MODE_READ) != 0;
+        file->open_write = (flags & (MODE_WRITE | MODE_APPEND)) != 0;
+        file->append = (flags & MODE_APPEND) != 0;
+        
+        if (!file->open_read && !file->open_write) {
+                vfs_file_put(file);
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+        
+        if (file->node->type == VFS_NODE_DIRECTORY && file->open_write) {
+                file->open_read = file->open_write = false;
+                vfs_file_put(file);
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+        
+        int rc = vfs_open_node_remote(file->node);
+        if (rc != EOK) {
+                file->open_read = file->open_write = false;
+                vfs_file_put(file);
+                async_answer_0(rid, rc);
+                return;
+        }
+        
+        vfs_file_put(file);
+        async_answer_0(rid, EOK);
+}
+
 void vfs_open(ipc_callid_t rid, ipc_call_t *request)
 {
@@ -669 +803 @@
         }
         vfs_file_t *file = vfs_file_get(fd);
-        assert(file);
+        
+        /* There is a potential race with another fibril of a malicious client. */
+        if (!file) {
+                vfs_node_put(node);
+                async_answer_0(rid, EBUSY);
+                return;
+        }
+        
         file->node = node;
+        if (oflag & O_RDONLY)
+                file->open_read = true;
+        if (oflag & O_WRONLY)
+                file->open_write = true;
+        if (oflag & O_RDWR)
+                file->open_read = file->open_write = true;
         if (oflag & O_APPEND)
                 file->append = true;
@@ -758 +905 @@
          */
         fibril_mutex_lock(&file->lock);
+        
+        if ((read && !file->open_read) || (!read && !file->open_write)) {
+                fibril_mutex_unlock(&file->lock);
+                async_answer_0(rid, EINVAL);
+                return;
+        }
         
         vfs_info_t *fs_info = fs_handle_to_info(file->node->fs_handle);