Changes in uspace/srv/vfs/vfs_ops.c [228e490:991f645] 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);
 
 /**
@@ -79 +78 @@
         size_t rsize;
         unsigned rlnkcnt;
-        sysarg_t rc;
+        ipcarg_t rc;
         int phone;
         aid_t msg;
@@ -126 +125 @@
                         phone = vfs_grab_phone(fs_handle);
                         msg = async_send_1(phone, VFS_OUT_MOUNTED,
-                            (sysarg_t) devmap_handle, &answer);
+                            (ipcarg_t) devmap_handle, &answer);
                         /* send the mount options */
                         rc = async_data_write_start(phone, (void *)opts,
@@ -188 +187 @@
         phone = vfs_grab_phone(mp_res.triplet.fs_handle);
         msg = async_send_4(phone, VFS_OUT_MOUNT,
-            (sysarg_t) mp_res.triplet.devmap_handle,
-            (sysarg_t) mp_res.triplet.index,
-            (sysarg_t) fs_handle,
-            (sysarg_t) devmap_handle, &answer);
+            (ipcarg_t) mp_res.triplet.devmap_handle,
+            (ipcarg_t) mp_res.triplet.index,
+            (ipcarg_t) fs_handle,
+            (ipcarg_t) devmap_handle, &answer);
         
         /* send connection */
@@ -251 +250 @@
 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
@@ -258 +255 @@
          * in the request.
          */
-        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
+        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
         
         /*
@@ -294 +291 @@
          */
         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);
@@ -309 +306 @@
         ipc_call_t data;
         ipc_callid_t callid = async_get_call(&data);
-        if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
+        if (IPC_GET_METHOD(data) != IPC_M_PING) {
                 ipc_answer_0(callid, ENOTSUP);
                 ipc_answer_0(rid, ENOTSUP);
@@ -461 +458 @@
 
                 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) {
@@ -716 +713 @@
 
         /* Wait for reply from the FS server. */
-        sysarg_t rc;
+        ipcarg_t rc;
         async_wait_for(msg, &rc);
         
@@ -743 +740 @@
                 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. */
-                sysarg_t rc;
+                ipcarg_t rc;
                 async_wait_for(msg, &rc);
                 
@@ -781 +778 @@
 static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
 {
-        vfs_info_t *vi;
 
         /*
@@ -808 +804 @@
         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 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))
+         * the same time.
+         */
+        if (read)
                 fibril_rwlock_read_lock(&file->node->contents_rwlock);
         else
@@ -839 +831 @@
          * don't have to bother.
          */
-        sysarg_t rc;
+        ipcarg_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,
@@ -862 +854 @@
         
         /* Unlock the VFS node. */
-        if (read || (vi->concurrent_read_write && vi->write_retains_size))
+        if (read)
                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
         else {
@@ -896 +888 @@
 {
         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);
         
@@ -911 +903 @@
         off64_t newoff;
         switch (whence) {
-        case SEEK_SET:
-                if (off >= 0) {
-                        file->pos = (aoff64_t) off;
+                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;
+                        
                         fibril_mutex_unlock(&file->lock);
-                        ipc_answer_1(rid, EOK, off);
+                        ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
                         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)) {
+                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;
+                        
                         fibril_rwlock_read_unlock(&file->node->contents_rwlock);
                         fibril_mutex_unlock(&file->lock);
-                        ipc_answer_0(rid, EOVERFLOW);
+                        ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
                         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;
         }
         
@@ -973 +964 @@
     fs_index_t index, aoff64_t size)
 {
-        sysarg_t rc;
+        ipcarg_t rc;
         int fs_phone;
         
         fs_phone = vfs_grab_phone(fs_handle);
-        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (sysarg_t) devmap_handle,
-            (sysarg_t) index, LOWER32(size), UPPER32(size));
+        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) devmap_handle,
+            (ipcarg_t) index, LOWER32(size), UPPER32(size));
         vfs_release_phone(fs_handle, fs_phone);
         return (int)rc;
@@ -986 +977 @@
 {
         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;
 
@@ -1005 +996 @@
 
         fibril_mutex_unlock(&file->lock);
-        ipc_answer_0(rid, (sysarg_t)rc);
+        ipc_answer_0(rid, (ipcarg_t)rc);
 }
 
@@ -1011 +1002 @@
 {
         int fd = IPC_GET_ARG1(*request);
-        sysarg_t rc;
+        ipcarg_t rc;
 
         vfs_file_t *file = vfs_file_get(fd);
@@ -1084 +1075 @@
         ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
         
-        sysarg_t rv;
+        ipcarg_t rv;
         async_wait_for(msg, &rv);
         vfs_release_phone(node->fs_handle, fs_phone);