Changes in uspace/srv/vfs/vfs_ops.c [991f645:228e490] in mainline

File:

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

uspace/srv/vfs/vfs_ops.c

@@ -55 +55 @@
 
 /* Forward declarations of static functions. */
-static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t, aoff64_t);
+static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
+    aoff64_t);
 
 /**
@@ -78 +79 @@
         size_t rsize;
         unsigned rlnkcnt;
-        ipcarg_t rc;
+        sysarg_t rc;
         int phone;
         aid_t msg;
@@ -125 +126 @@
                         phone = vfs_grab_phone(fs_handle);
                         msg = async_send_1(phone, VFS_OUT_MOUNTED,
-                            (ipcarg_t) devmap_handle, &answer);
+                            (sysarg_t) devmap_handle, &answer);
                         /* send the mount options */
                         rc = async_data_write_start(phone, (void *)opts,
@@ -187 +188 @@
         phone = vfs_grab_phone(mp_res.triplet.fs_handle);
         msg = async_send_4(phone, VFS_OUT_MOUNT,
-            (ipcarg_t) mp_res.triplet.devmap_handle,
-            (ipcarg_t) mp_res.triplet.index,
-            (ipcarg_t) fs_handle,
-            (ipcarg_t) devmap_handle, &answer);
+            (sysarg_t) mp_res.triplet.devmap_handle,
+            (sysarg_t) mp_res.triplet.index,
+            (sysarg_t) fs_handle,
+            (sysarg_t) devmap_handle, &answer);
         
         /* send connection */
@@ -250 +251 @@
 void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
 {
+        devmap_handle_t devmap_handle;
+
         /*
          * We expect the library to do the device-name to device-handle
@@ -255 +258 @@
          * in the request.
          */
-        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         
         /*
@@ -291 +294 @@
          */
         char *fs_name;
-        rc = async_data_write_accept((void **) &fs_name, true, 0, FS_NAME_MAXLEN,
-            0, NULL);
+        rc = async_data_write_accept((void **) &fs_name, true, 0,
+            FS_NAME_MAXLEN, 0, NULL);
         if (rc != EOK) {
                 free(mp);
@@ -306 +309 @@
         ipc_call_t data;
         ipc_callid_t callid = async_get_call(&data);
-        if (IPC_GET_METHOD(data) != IPC_M_PING) {
+        if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
                 ipc_answer_0(callid, ENOTSUP);
                 ipc_answer_0(rid, ENOTSUP);
@@ -458 +461 @@
 
                 phone = vfs_grab_phone(mp_node->fs_handle);
-                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->devmap_handle,
-                    mp_node->index);
+                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT,
+                    mp_node->devmap_handle, mp_node->index);
                 vfs_release_phone(mp_node->fs_handle, phone);
                 if (rc != EOK) {
@@ -713 +716 @@
 
         /* Wait for reply from the FS server. */
-        ipcarg_t rc;
+        sysarg_t rc;
         async_wait_for(msg, &rc);
         
@@ -740 +743 @@
                 aid_t msg;
                 ipc_call_t answer;
-                msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->devmap_handle,
-                    file->node->index, &answer);
+                msg = async_send_2(fs_phone, VFS_OUT_CLOSE,
+                    file->node->devmap_handle, file->node->index, &answer);
                 
                 /* Wait for reply from the FS server. */
-                ipcarg_t rc;
+                sysarg_t rc;
                 async_wait_for(msg, &rc);
                 
@@ -778 +781 @@
 static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
 {
+        vfs_info_t *vi;
 
         /*
@@ -804 +808 @@
         fibril_mutex_lock(&file->lock);
 
+        vi = fs_handle_to_info(file->node->fs_handle);
+        assert(vi);
+
         /*
          * Lock the file's node so that no other client can read/write to it at
-         * the same time.
-         */
-        if (read)
+         * the same time unless the FS supports concurrent reads/writes and its
+         * write implementation does not modify the file size.
+         */
+        if (read || (vi->concurrent_read_write && vi->write_retains_size))
                 fibril_rwlock_read_lock(&file->node->contents_rwlock);
         else
@@ -831 +839 @@
          * don't have to bother.
          */
-        ipcarg_t rc;
+        sysarg_t rc;
         ipc_call_t answer;
         if (read) {
-                if (file->append)
-                        file->pos = file->node->size;
-                
                 rc = async_data_read_forward_3_1(fs_phone, 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_3_1(fs_phone, VFS_OUT_WRITE,
                     file->node->devmap_handle, file->node->index, file->pos,
@@ -854 +862 @@
         
         /* Unlock the VFS node. */
-        if (read)
+        if (read || (vi->concurrent_read_write && vi->write_retains_size))
                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
         else {
@@ -888 +896 @@
 {
         int fd = (int) IPC_GET_ARG1(*request);
-        off64_t off =
-            (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
+        off64_t off = (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
+            IPC_GET_ARG3(*request));
         int whence = (int) IPC_GET_ARG4(*request);
         
@@ -903 +911 @@
         off64_t newoff;
         switch (whence) {
-                case SEEK_SET:
-                        if (off >= 0) {
-                                file->pos = (aoff64_t) off;
-                                fibril_mutex_unlock(&file->lock);
-                                ipc_answer_1(rid, EOK, off);
-                                return;
-                        }
-                        break;
-                case SEEK_CUR:
-                        if ((off >= 0) && (file->pos + off < file->pos)) {
-                                fibril_mutex_unlock(&file->lock);
-                                ipc_answer_0(rid, EOVERFLOW);
-                                return;
-                        }
-                        
-                        if ((off < 0) && (file->pos < (aoff64_t) -off)) {
-                                fibril_mutex_unlock(&file->lock);
-                                ipc_answer_0(rid, EOVERFLOW);
-                                return;
-                        }
-                        
-                        file->pos += off;
-                        newoff = (file->pos > OFF64_MAX) ? OFF64_MAX : file->pos;
-                        
+        case SEEK_SET:
+                if (off >= 0) {
+                        file->pos = (aoff64_t) off;
                         fibril_mutex_unlock(&file->lock);
-                        ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
-                        return;
-                case SEEK_END:
-                        fibril_rwlock_read_lock(&file->node->contents_rwlock);
-                        aoff64_t size = file->node->size;
-                        
-                        if ((off >= 0) && (size + off < size)) {
-                                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
-                                fibril_mutex_unlock(&file->lock);
-                                ipc_answer_0(rid, EOVERFLOW);
-                                return;
-                        }
-                        
-                        if ((off < 0) && (size < (aoff64_t) -off)) {
-                                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
-                                fibril_mutex_unlock(&file->lock);
-                                ipc_answer_0(rid, EOVERFLOW);
-                                return;
-                        }
-                        
-                        file->pos = size + off;
-                        newoff = (file->pos > OFF64_MAX) ? OFF64_MAX : file->pos;
-                        
+                        ipc_answer_1(rid, EOK, off);
+                        return;
+                }
+                break;
+        case SEEK_CUR:
+                if ((off >= 0) && (file->pos + off < file->pos)) {
+                        fibril_mutex_unlock(&file->lock);
+                        ipc_answer_0(rid, EOVERFLOW);
+                        return;
+                }
+                
+                if ((off < 0) && (file->pos < (aoff64_t) -off)) {
+                        fibril_mutex_unlock(&file->lock);
+                        ipc_answer_0(rid, EOVERFLOW);
+                        return;
+                }
+                
+                file->pos += off;
+                newoff = (file->pos > OFF64_MAX) ?  OFF64_MAX : file->pos;
+                
+                fibril_mutex_unlock(&file->lock);
+                ipc_answer_2(rid, EOK, LOWER32(newoff),
+                    UPPER32(newoff));
+                return;
+        case SEEK_END:
+                fibril_rwlock_read_lock(&file->node->contents_rwlock);
+                aoff64_t size = file->node->size;
+                
+                if ((off >= 0) && (size + off < size)) {
                         fibril_rwlock_read_unlock(&file->node->contents_rwlock);
                         fibril_mutex_unlock(&file->lock);
-                        ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
-                        return;
+                        ipc_answer_0(rid, EOVERFLOW);
+                        return;
+                }
+                
+                if ((off < 0) && (size < (aoff64_t) -off)) {
+                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
+                        fibril_mutex_unlock(&file->lock);
+                        ipc_answer_0(rid, EOVERFLOW);
+                        return;
+                }
+                
+                file->pos = size + off;
+                newoff = (file->pos > OFF64_MAX) ?  OFF64_MAX : file->pos;
+                
+                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
+                fibril_mutex_unlock(&file->lock);
+                ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
+                return;
         }
         
@@ -964 +973 @@
     fs_index_t index, aoff64_t size)
 {
-        ipcarg_t rc;
+        sysarg_t rc;
         int fs_phone;
         
         fs_phone = vfs_grab_phone(fs_handle);
-        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) devmap_handle,
-            (ipcarg_t) index, LOWER32(size), UPPER32(size));
+        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (sysarg_t) devmap_handle,
+            (sysarg_t) index, LOWER32(size), UPPER32(size));
         vfs_release_phone(fs_handle, fs_phone);
         return (int)rc;
@@ -977 +986 @@
 {
         int fd = IPC_GET_ARG1(*request);
-        aoff64_t size =
-            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request), IPC_GET_ARG3(*request));
+        aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
+            IPC_GET_ARG3(*request));
         int rc;
 
@@ -996 +1005 @@
 
         fibril_mutex_unlock(&file->lock);
-        ipc_answer_0(rid, (ipcarg_t)rc);
+        ipc_answer_0(rid, (sysarg_t)rc);
 }
 
@@ -1002 +1011 @@
 {
         int fd = IPC_GET_ARG1(*request);
-        ipcarg_t rc;
+        sysarg_t rc;
 
         vfs_file_t *file = vfs_file_get(fd);
@@ -1075 +1084 @@
         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
         
-        ipcarg_t rv;
+        sysarg_t rv;
         async_wait_for(msg, &rv);
         vfs_release_phone(node->fs_handle, fs_phone);