Changeset 79ae36dd in mainline for uspace/srv/vfs

Timestamp:

2011-06-08T19:01:55Z (14 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

0eff68e

Parents:

764d71e

Message:

new async framework with integrated exchange tracking

• strict isolation between low-level IPC and high-level async framework with integrated exchange tracking
  • each IPC connection is represented by an async_sess_t structure
  • each IPC exchange is represented by an async_exch_t structure
  • exchange management is either based on atomic messages (EXCHANGE_ATOMIC), locking (EXCHANGE_SERIALIZE) or connection cloning (EXCHANGE_CLONE)
• async_obsolete: temporary compatibility layer to keep old async clients working (several pieces of code are currently broken, but only non-essential functionality)
• IPC_M_PHONE_HANGUP is now method no. 0 (for elegant boolean evaluation)
• IPC_M_DEBUG_ALL has been renamed to IPC_M_DEBUG
• IPC_M_PING has been removed (VFS protocol now has VFS_IN_PING)
• console routines in libc have been rewritten for better abstraction
• additional use for libc-private header files (FILE structure opaque to the client)
• various cstyle changes (typos, indentation, missing externs in header files, improved comments, etc.)

Location:

uspace/srv/vfs

Files:

• vfs.c (modified) (4 diffs)
• vfs.h (modified) (2 diffs)
• vfs_file.c (modified) (2 diffs)
• vfs_lookup.c (modified) (4 diffs)
• vfs_node.c (modified) (2 diffs)
• vfs_ops.c (modified) (34 diffs)
• vfs_register.c (modified) (14 diffs)

uspace/srv/vfs/vfs.c

@@ -37 +37 @@
 
 #include <ipc/services.h>
-#include <ipc/ns.h>
+#include <ns.h>
 #include <async.h>
 #include <errno.h>
@@ -51 +51 @@
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-        bool keep_on_going = true;
-
+        bool cont = true;
+        
         /*
          * The connection was opened via the IPC_CONNECT_ME_TO call.
@@ -59 +59 @@
         async_answer_0(iid, EOK);
         
-        while (keep_on_going) {
+        while (cont) {
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
                 
+                if (!IPC_GET_IMETHOD(call))
+                        break;
+                
                 switch (IPC_GET_IMETHOD(call)) {
-                case IPC_M_PHONE_HUNGUP:
-                        keep_on_going = false;
-                        break;
                 case VFS_IN_REGISTER:
                         vfs_register(callid, &call);
-                        keep_on_going = false;
+                        cont = false;
                         break;
                 case VFS_IN_MOUNT:
@@ -123 +123 @@
                 }
         }
-
+        
         /*
          * Open files for this client will be cleaned up when its last

uspace/srv/vfs/vfs.h

@@ -53 +53 @@
         vfs_info_t vfs_info;
         fs_handle_t fs_handle;
-        async_sess_t session;
+        async_sess_t *sess;
 } fs_info_t;
 
@@ -167 +167 @@
 extern fibril_rwlock_t namespace_rwlock;
 
-extern int vfs_grab_phone(fs_handle_t);
-extern void vfs_release_phone(fs_handle_t, int);
+extern async_exch_t *vfs_exchange_grab(fs_handle_t);
+extern void vfs_exchange_release(async_exch_t *);
 
 extern fs_handle_t fs_name_to_handle(char *, bool);

uspace/srv/vfs/vfs_file.c

@@ -45 +45 @@
 #include "vfs.h"
 
-#define VFS_DATA        ((vfs_client_data_t *) async_client_data_get())
+#define VFS_DATA        ((vfs_client_data_t *) async_get_client_data())
 #define FILES           (VFS_DATA->files)
 
@@ -110 +110 @@
 static int vfs_file_close_remote(vfs_file_t *file)
 {
+        assert(!file->refcnt);
+        
+        async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
+        
         ipc_call_t answer;
-        aid_t msg;
+        aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->devmap_handle,
+            file->node->index, &answer);
+        
+        vfs_exchange_release(exch);
+        
         sysarg_t rc;
-        int phone;
-
-        assert(!file->refcnt);
-
-        phone = vfs_grab_phone(file->node->fs_handle);
-        msg = async_send_2(phone, VFS_OUT_CLOSE, file->node->devmap_handle,
-            file->node->index, &answer);
         async_wait_for(msg, &rc);
-        vfs_release_phone(file->node->fs_handle, phone);
-
+        
         return IPC_GET_ARG1(answer);
 }
-
 
 /** Increment reference count of VFS file structure.

uspace/srv/vfs/vfs_lookup.c

@@ -159 +159 @@
 
         ipc_call_t answer;
-        int phone = vfs_grab_phone(root->fs_handle);
-        aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (sysarg_t) first,
+        async_exch_t *exch = vfs_exchange_grab(root->fs_handle);
+        aid_t req = async_send_5(exch, VFS_OUT_LOOKUP, (sysarg_t) first,
             (sysarg_t) (first + len - 1) % PLB_SIZE,
             (sysarg_t) root->devmap_handle, (sysarg_t) lflag, (sysarg_t) index,
@@ -167 +167 @@
         sysarg_t rc;
         async_wait_for(req, &rc);
-        vfs_release_phone(root->fs_handle, phone);
+        vfs_exchange_release(exch);
         
         fibril_mutex_lock(&plb_mutex);
@@ -208 +208 @@
 int vfs_open_node_internal(vfs_lookup_res_t *result)
 {
-        int phone = vfs_grab_phone(result->triplet.fs_handle);
+        async_exch_t *exch = vfs_exchange_grab(result->triplet.fs_handle);
         
         ipc_call_t answer;
-        aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE,
+        aid_t req = async_send_2(exch, VFS_OUT_OPEN_NODE,
             (sysarg_t) result->triplet.devmap_handle,
             (sysarg_t) result->triplet.index, &answer);
@@ -217 +217 @@
         sysarg_t rc;
         async_wait_for(req, &rc);
-        vfs_release_phone(result->triplet.fs_handle, phone);
+        vfs_exchange_release(exch);
         
         if (rc == EOK) {

uspace/srv/vfs/vfs_node.c

@@ -104 +104 @@
         bool free_vfs_node = false;
         bool free_fs_node = false;
-
-        fibril_mutex_lock(&nodes_mutex);
+        
+        fibril_mutex_lock(&nodes_mutex);
+        
         if (node->refcnt-- == 1) {
+                
                 /*
                  * We are dropping the last reference to this node.
                  * Remove it from the VFS node hash table.
                  */
+                
                 unsigned long key[] = {
                         [KEY_FS_HANDLE] = node->fs_handle,
@@ -116 +119 @@
                         [KEY_INDEX] = node->index
                 };
+                
                 hash_table_remove(&nodes, key, 3);
                 free_vfs_node = true;
+                
                 if (!node->lnkcnt)
                         free_fs_node = true;
         }
-        fibril_mutex_unlock(&nodes_mutex);
-
+        
+        fibril_mutex_unlock(&nodes_mutex);
+        
         if (free_fs_node) {
-                /* 
+                
+                /*
                  * The node is not visible in the file system namespace.
                  * Free up its resources.
                  */
-                int phone = vfs_grab_phone(node->fs_handle);
-                sysarg_t rc;
-                rc = async_req_2_0(phone, VFS_OUT_DESTROY,
-                    (sysarg_t)node->devmap_handle, (sysarg_t)node->index);
+                
+                async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
+                sysarg_t rc = async_req_2_0(exch, VFS_OUT_DESTROY,
+                    (sysarg_t) node->devmap_handle, (sysarg_t)node->index);
+                
                 assert(rc == EOK);
-                vfs_release_phone(node->fs_handle, phone);
+                vfs_exchange_release(exch);
         }
+        
         if (free_vfs_node)
                 free(node);

uspace/srv/vfs/vfs_ops.c

@@ -78 +78 @@
         size_t rsize;
         unsigned rlnkcnt;
+        async_exch_t *exch;
         sysarg_t rc;
-        int phone;
         aid_t msg;
         ipc_call_t answer;
@@ -123 +123 @@
                         
                         /* Tell the mountee that it is being mounted. */
-                        phone = vfs_grab_phone(fs_handle);
-                        msg = async_send_1(phone, VFS_OUT_MOUNTED,
+                        exch = vfs_exchange_grab(fs_handle);
+                        msg = async_send_1(exch, VFS_OUT_MOUNTED,
                             (sysarg_t) devmap_handle, &answer);
-                        /* send the mount options */
-                        rc = async_data_write_start(phone, (void *)opts,
+                        /* Send the mount options */
+                        rc = async_data_write_start(exch, (void *)opts,
                             str_size(opts));
+                        vfs_exchange_release(exch);
+                        
                         if (rc != EOK) {
                                 async_wait_for(msg, NULL);
-                                vfs_release_phone(fs_handle, phone);
                                 fibril_rwlock_write_unlock(&namespace_rwlock);
                                 async_answer_0(rid, rc);
@@ -137 +138 @@
                         }
                         async_wait_for(msg, &rc);
-                        vfs_release_phone(fs_handle, phone);
                         
                         if (rc != EOK) {
@@ -182 +182 @@
          */
         
-        int mountee_phone = vfs_grab_phone(fs_handle);
-        assert(mountee_phone >= 0);
-
-        phone = vfs_grab_phone(mp_res.triplet.fs_handle);
-        msg = async_send_4(phone, VFS_OUT_MOUNT,
+        async_exch_t *mountee_exch = vfs_exchange_grab(fs_handle);
+        assert(mountee_exch);
+        
+        exch = vfs_exchange_grab(mp_res.triplet.fs_handle);
+        msg = async_send_4(exch, VFS_OUT_MOUNT,
             (sysarg_t) mp_res.triplet.devmap_handle,
             (sysarg_t) mp_res.triplet.index,
@@ -192 +192 @@
             (sysarg_t) devmap_handle, &answer);
         
-        /* send connection */
-        rc = async_req_1_0(phone, IPC_M_CONNECTION_CLONE, mountee_phone);
-        if (rc != EOK) {
+        /* Send connection */
+        rc = async_exchange_clone(exch, mountee_exch);
+        vfs_exchange_release(mountee_exch);
+        
+        if (rc != EOK) {
+                vfs_exchange_release(exch);
                 async_wait_for(msg, NULL);
-                vfs_release_phone(fs_handle, mountee_phone);
-                vfs_release_phone(mp_res.triplet.fs_handle, phone);
+                
                 /* Mount failed, drop reference to mp_node. */
                 if (mp_node)
                         vfs_node_put(mp_node);
-                async_answer_0(rid, rc);
-                fibril_rwlock_write_unlock(&namespace_rwlock);
-                return;
-        }
-
-        vfs_release_phone(fs_handle, mountee_phone);
+                
+                async_answer_0(rid, rc);
+                fibril_rwlock_write_unlock(&namespace_rwlock);
+                return;
+        }
         
         /* send the mount options */
-        rc = async_data_write_start(phone, (void *)opts, str_size(opts));
-        if (rc != EOK) {
+        rc = async_data_write_start(exch, (void *) opts, str_size(opts));
+        if (rc != EOK) {
+                vfs_exchange_release(exch);
                 async_wait_for(msg, NULL);
-                vfs_release_phone(mp_res.triplet.fs_handle, phone);
+                
                 /* Mount failed, drop reference to mp_node. */
                 if (mp_node)
                         vfs_node_put(mp_node);
-                fibril_rwlock_write_unlock(&namespace_rwlock);
-                async_answer_0(rid, rc);
-                return;
-        }
+                
+                fibril_rwlock_write_unlock(&namespace_rwlock);
+                async_answer_0(rid, rc);
+                return;
+        }
+        
+        vfs_exchange_release(exch);
         async_wait_for(msg, &rc);
-        vfs_release_phone(mp_res.triplet.fs_handle, phone);
         
         if (rc == EOK) {
@@ -227 +231 @@
                 rsize = (size_t) IPC_GET_ARG2(answer);
                 rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
-        
+                
                 mr_res.triplet.fs_handle = fs_handle;
                 mr_res.triplet.devmap_handle = devmap_handle;
@@ -234 +238 @@
                 mr_res.lnkcnt = rlnkcnt;
                 mr_res.type = VFS_NODE_DIRECTORY;
-        
+                
                 /* Add reference to the mounted root. */
                 mr_node = vfs_node_get(&mr_res); 
@@ -243 +247 @@
                         vfs_node_put(mp_node);
         }
-
+        
         async_answer_0(rid, rc);
         fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -303 +307 @@
         
         /*
-         * Wait for IPC_M_PING so that we can return an error if we don't know
+         * Wait for VFS_IN_PING so that we can return an error if we don't know
          * fs_name.
          */
         ipc_call_t data;
         ipc_callid_t callid = async_get_call(&data);
-        if (IPC_GET_IMETHOD(data) != IPC_M_PING) {
+        if (IPC_GET_IMETHOD(data) != VFS_IN_PING) {
                 async_answer_0(callid, ENOTSUP);
                 async_answer_0(rid, ENOTSUP);
@@ -358 +362 @@
         vfs_lookup_res_t mr_res;
         vfs_node_t *mr_node;
-        int phone;
-
+        async_exch_t *exch;
+        
         /*
          * Receive the mount point path.
@@ -367 +371 @@
         if (rc != EOK)
                 async_answer_0(rid, rc);
-
+        
         /*
          * Taking the namespace lock will do two things for us. First, it will
@@ -395 +399 @@
                 return;
         }
-
+        
         /*
          * Count the total number of references for the mounted file system. We
@@ -411 +415 @@
                 return;
         }
-
+        
         if (str_cmp(mp, "/") == 0) {
-
+                
                 /*
                  * Unmounting the root file system.
@@ -420 +424 @@
                  * VFS_OUT_UNMOUNTED directly to the mounted file system.
                  */
-
+                
                 free(mp);
-                phone = vfs_grab_phone(mr_node->fs_handle);
-                rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
+                
+                exch = vfs_exchange_grab(mr_node->fs_handle);
+                rc = async_req_1_0(exch, VFS_OUT_UNMOUNTED,
                     mr_node->devmap_handle);
-                vfs_release_phone(mr_node->fs_handle, phone);
+                vfs_exchange_release(exch);
+                
                 if (rc != EOK) {
                         fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -432 +438 @@
                         return;
                 }
+                
                 rootfs.fs_handle = 0;
                 rootfs.devmap_handle = 0;
         } else {
-
+                
                 /*
                  * Unmounting a non-root file system.
@@ -442 +449 @@
                  * file system, so we delegate the operation to it.
                  */
-
+                
                 rc = vfs_lookup_internal(mp, L_MP, &mp_res, NULL);
                 free(mp);
@@ -451 +458 @@
                         return;
                 }
+                
                 vfs_node_t *mp_node = vfs_node_get(&mp_res);
                 if (!mp_node) {
@@ -458 +466 @@
                         return;
                 }
-
-                phone = vfs_grab_phone(mp_node->fs_handle);
-                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT,
+                
+                exch = vfs_exchange_grab(mp_node->fs_handle);
+                rc = async_req_2_0(exch, VFS_OUT_UNMOUNT,
                     mp_node->devmap_handle, mp_node->index);
-                vfs_release_phone(mp_node->fs_handle, phone);
+                vfs_exchange_release(exch);
+                
                 if (rc != EOK) {
                         fibril_rwlock_write_unlock(&namespace_rwlock);
@@ -470 +479 @@
                         return;
                 }
-
+                
                 /* Drop the reference we got above. */
                 vfs_node_put(mp_node);
@@ -476 +485 @@
                 vfs_node_put(mp_node);
         }
-
-
+        
         /*
          * All went well, the mounted file system was successfully unmounted.
@@ -483 +491 @@
          */
         vfs_node_forget(mr_node);
-
+        
         fibril_rwlock_write_unlock(&namespace_rwlock);
         async_answer_0(rid, EOK);
@@ -698 +706 @@
          */
         fibril_mutex_lock(&file->lock);
-        int fs_phone = vfs_grab_phone(file->node->fs_handle);
+        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
         
         /* Make a VFS_OUT_SYMC request at the destination FS server. */
         aid_t msg;
         ipc_call_t answer;
-        msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle,
+        msg = async_send_2(fs_exch, VFS_OUT_SYNC, file->node->devmap_handle,
             file->node->index, &answer);
-
+        
+        vfs_exchange_release(fs_exch);
+        
         /* Wait for reply from the FS server. */
         sysarg_t rc;
         async_wait_for(msg, &rc);
         
-        vfs_release_phone(file->node->fs_handle, fs_phone);
         fibril_mutex_unlock(&file->lock);
-
+        
         vfs_file_put(file);
         async_answer_0(rid, rc);
@@ -720 +729 @@
 {
         int fd = IPC_GET_ARG1(*request);
-        int ret;
-        
-        ret = vfs_fd_free(fd);
+        int ret = vfs_fd_free(fd);
         async_answer_0(rid, ret);
 }
@@ -728 +735 @@
 static void vfs_rdwr(ipc_callid_t rid, ipc_call_t *request, bool read)
 {
-        vfs_info_t *vi;
-
         /*
          * The following code strongly depends on the fact that the files data
@@ -739 +744 @@
          * open files supports parallel access!
          */
-
+        
         int fd = IPC_GET_ARG1(*request);
         
@@ -754 +759 @@
          */
         fibril_mutex_lock(&file->lock);
-
-        vi = fs_handle_to_info(file->node->fs_handle);
-        assert(vi);
-
+        
+        vfs_info_t *fs_info = fs_handle_to_info(file->node->fs_handle);
+        assert(fs_info);
+        
         /*
          * Lock the file's node so that no other client can read/write to it at
@@ -763 +768 @@
          * write implementation does not modify the file size.
          */
-        if (read || (vi->concurrent_read_write && vi->write_retains_size))
+        if ((read) ||
+            ((fs_info->concurrent_read_write) && (fs_info->write_retains_size)))
                 fibril_rwlock_read_lock(&file->node->contents_rwlock);
         else
                 fibril_rwlock_write_lock(&file->node->contents_rwlock);
-
+        
         if (file->node->type == VFS_NODE_DIRECTORY) {
                 /*
@@ -777 +783 @@
         }
         
-        int fs_phone = vfs_grab_phone(file->node->fs_handle);
+        async_exch_t *fs_exch = vfs_exchange_grab(file->node->fs_handle);
         
         /*
@@ -789 +795 @@
         ipc_call_t answer;
         if (read) {
-                rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
+                rc = async_data_read_forward_3_1(fs_exch, VFS_OUT_READ,
                     file->node->devmap_handle, file->node->index, file->pos,
                     &answer);
@@ -796 +802 @@
                         file->pos = file->node->size;
                 
-                rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
+                rc = async_data_write_forward_3_1(fs_exch, VFS_OUT_WRITE,
                     file->node->devmap_handle, file->node->index, file->pos,
                     &answer);
         }
         
-        vfs_release_phone(file->node->fs_handle, fs_phone);
+        vfs_exchange_release(fs_exch);
         
         size_t bytes = IPC_GET_ARG1(answer);
@@ -809 +815 @@
         
         /* Unlock the VFS node. */
-        if (read || (vi->concurrent_read_write && vi->write_retains_size))
+        if ((read) ||
+            ((fs_info->concurrent_read_write) && (fs_info->write_retains_size)))
                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
         else {
@@ -929 +936 @@
     fs_index_t index, aoff64_t size)
 {
-        sysarg_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));
-        vfs_release_phone(fs_handle, fs_phone);
-        return (int)rc;
+        async_exch_t *exch = vfs_exchange_grab(fs_handle);
+        sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
+            (sysarg_t) devmap_handle, (sysarg_t) index, LOWER32(size),
+            UPPER32(size));
+        vfs_exchange_release(exch);
+        
+        return (int) rc;
 }
 
@@ -986 +992 @@
         fibril_mutex_lock(&file->lock);
 
-        int fs_phone = vfs_grab_phone(file->node->fs_handle);
+        async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
         
         aid_t msg;
-        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
+        msg = async_send_3(exch, VFS_OUT_STAT, file->node->devmap_handle,
             file->node->index, true, NULL);
-        async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        
+        vfs_exchange_release(exch);
+        
         async_wait_for(msg, &rc);
-        vfs_release_phone(file->node->fs_handle, fs_phone);
-
+        
         fibril_mutex_unlock(&file->lock);
         vfs_file_put(file);
@@ -1037 +1045 @@
         fibril_rwlock_read_unlock(&namespace_rwlock);
 
-        int fs_phone = vfs_grab_phone(node->fs_handle);
+        async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
+        
         aid_t msg;
-        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
+        msg = async_send_3(exch, VFS_OUT_STAT, node->devmap_handle,
             node->index, false, NULL);
-        async_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        
+        vfs_exchange_release(exch);
         
         sysarg_t rv;
         async_wait_for(msg, &rv);
-        vfs_release_phone(node->fs_handle, fs_phone);
 
         async_answer_0(rid, rv);

uspace/srv/vfs/vfs_register.c

@@ -62 +62 @@
 /** Verify the VFS info structure.
  *
- * @param info          Info structure to be verified.
- *
- * @return              Non-zero if the info structure is sane, zero otherwise.
+ * @param info Info structure to be verified.
+ *
+ * @return Non-zero if the info structure is sane, zero otherwise.
+ *
  */
 static bool vfs_info_sane(vfs_info_t *info)
 {
         int i;
-
+        
         /*
          * Check if the name is non-empty and is composed solely of ASCII
@@ -78 +79 @@
                 return false;
         }
+        
         for (i = 1; i < FS_NAME_MAXLEN; i++) {
                 if (!(islower(info->name[i]) || isdigit(info->name[i])) &&
@@ -90 +92 @@
                 }
         }
+        
         /*
          * This check is not redundant. It ensures that the name is
@@ -104 +107 @@
 /** VFS_REGISTER protocol function.
  *
- * @param rid           Hash of the call with the request.
- * @param request       Call structure with the request.
+ * @param rid     Hash of the call with the request.
+ * @param request Call structure with the request.
+ *
  */
 void vfs_register(ipc_callid_t rid, ipc_call_t *request)
 {
-        int phone;
-        
         dprintf("Processing VFS_REGISTER request received from %p.\n",
             request->in_phone_hash);
@@ -174 +176 @@
          * which to forward VFS requests to it.
          */
-        ipc_call_t call;
-        ipc_callid_t callid = async_get_call(&call);
-        if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
-                dprintf("Unexpected call, method = %d\n", IPC_GET_IMETHOD(call));
+        fs_info->sess = async_callback_receive(EXCHANGE_PARALLEL);
+        if (!fs_info->sess) {
+                dprintf("Callback connection expected\n");
                 list_remove(&fs_info->fs_link);
                 fibril_mutex_unlock(&fs_head_lock);
                 free(fs_info);
-                async_answer_0(callid, EINVAL);
                 async_answer_0(rid, EINVAL);
                 return;
         }
         
-        phone = IPC_GET_ARG5(call);
-        async_session_create(&fs_info->session, phone, 0);
-        async_answer_0(callid, EOK);
-        
         dprintf("Callback connection to FS created.\n");
         
@@ -197 +193 @@
         
         size_t size;
+        ipc_callid_t callid;
         if (!async_share_in_receive(&callid, &size)) {
                 dprintf("Unexpected call, method = %d\n", IPC_GET_IMETHOD(call));
                 list_remove(&fs_info->fs_link);
                 fibril_mutex_unlock(&fs_head_lock);
-                async_session_destroy(&fs_info->session);
-                async_hangup(phone);
+                async_hangup(fs_info->sess);
                 free(fs_info);
                 async_answer_0(callid, EINVAL);
@@ -216 +212 @@
                 list_remove(&fs_info->fs_link);
                 fibril_mutex_unlock(&fs_head_lock);
-                async_session_destroy(&fs_info->session);
-                async_hangup(phone);
+                async_hangup(fs_info->sess);
                 free(fs_info);
                 async_answer_0(callid, EINVAL);
@@ -247 +242 @@
 }
 
-/** For a given file system handle, implement policy for allocating a phone.
- *
- * @param handle        File system handle.
- *
- * @return              Phone over which a multi-call request can be safely
- *                      sent. Return 0 if no phone was found.
- */
-int vfs_grab_phone(fs_handle_t handle)
-{
+/** Begin an exchange for a given file system handle
+ *
+ * @param handle File system handle.
+ *
+ * @return Exchange for a multi-call request.
+ * @return NULL if no such file exists.
+ *
+ */
+async_exch_t *vfs_exchange_grab(fs_handle_t handle)
+{
+        /*
+         * For now, we don't try to be very clever and very fast.
+         * We simply lookup the session in the fs_head list and
+         * begin an exchange.
+         */
+        fibril_mutex_lock(&fs_head_lock);
+        
         link_t *cur;
-        fs_info_t *fs;
-        int phone;
-
-        /*
-         * For now, we don't try to be very clever and very fast.  We simply
-         * lookup the phone in the fs_head list and duplicate it.  The duplicate
-         * phone will be returned to the client and the client will use it for
-         * communication.  In the future, we should cache the connections so
-         * that they do not have to be reestablished over and over again.
-         */
-        fibril_mutex_lock(&fs_head_lock);
         for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
-                fs = list_get_instance(cur, fs_info_t, fs_link);
+                fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link);
+                
                 if (fs->fs_handle == handle) {
                         fibril_mutex_unlock(&fs_head_lock);
-                        phone = async_exchange_begin(&fs->session);
-
-                        assert(phone > 0);
-                        return phone;
+                        
+                        assert(fs->sess);
+                        async_exch_t *exch = async_exchange_begin(fs->sess);
+                        
+                        assert(exch);
+                        return exch;
                 }
         }
+        
         fibril_mutex_unlock(&fs_head_lock);
-        return 0;
-}
-
-/** Tell VFS that the phone is not needed anymore.
- *
- * @param phone         Phone to FS task.
- */
-void vfs_release_phone(fs_handle_t handle, int phone)
-{
-        link_t *cur;
-        fs_info_t *fs;
-
-        fibril_mutex_lock(&fs_head_lock);
-        for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
-                fs = list_get_instance(cur, fs_info_t, fs_link);
-                if (fs->fs_handle == handle) {
-                        fibril_mutex_unlock(&fs_head_lock);
-                        async_exchange_end(&fs->session, phone);
-                        return;
-                }
-        }
-        /* should not really get here */
-        abort();
-        fibril_mutex_unlock(&fs_head_lock);
+        
+        return NULL;
+}
+
+/** End VFS server exchange.
+ *
+ * @param exch   VFS server exchange.
+ *
+ */
+void vfs_exchange_release(async_exch_t *exch)
+{
+        async_exchange_end(exch);
 }
 
 /** Convert file system name to its handle.
  *
- * @param name          File system name.
- * @param lock          If true, the function will lock and unlock the
- *                      fs_head_lock.
- *
- * @return              File system handle or zero if file system not found.
+ * @param name File system name.
+ * @param lock If true, the function will lock and unlock the
+ *             fs_head_lock.
+ *
+ * @return File system handle or zero if file system not found.
+ *
  */
 fs_handle_t fs_name_to_handle(char *name, bool lock)
@@ -319 +304 @@
         if (lock)
                 fibril_mutex_lock(&fs_head_lock);
+        
         link_t *cur;
         for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
@@ -327 +313 @@
                 }
         }
+        
         if (lock)
                 fibril_mutex_unlock(&fs_head_lock);
+        
         return handle;
 }
@@ -334 +322 @@
 /** Find the VFS info structure.
  *
- * @param handle        FS handle for which the VFS info structure is sought.
- * @return              VFS info structure on success or NULL otherwise.
+ * @param handle FS handle for which the VFS info structure is sought.
+ *
+ * @return VFS info structure on success or NULL otherwise.
+ *
  */
 vfs_info_t *fs_handle_to_info(fs_handle_t handle)
@@ -341 +331 @@
         vfs_info_t *info = NULL;
         link_t *cur;
-
+        
         fibril_mutex_lock(&fs_head_lock);
         for (cur = fs_head.next; cur != &fs_head; cur = cur->next) {
@@ -351 +341 @@
         }
         fibril_mutex_unlock(&fs_head_lock);
-
+        
         return info;
 }
@@ -357 +347 @@
 /**
  * @}
- */ 
+ */