Changeset 04803bf in mainline for uspace/lib/c/generic/vfs/vfs.c

Timestamp:

2011-03-21T22:00:17Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

143932e3

Parents:

b50b5af2 (diff), 7308e84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes (needs fixes).

File:

• uspace/lib/c/generic/vfs/vfs.c (moved) (moved from uspace/lib/libc/generic/vfs/vfs.c ) (14 diffs)

uspace/lib/c/generic/vfs/vfs.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2008 Jakub Jermar 
+ * Copyright (c) 2008 Jakub Jermar
  * All rights reserved.
  *
@@ -35 +35 @@
 #include <vfs/vfs.h>
 #include <vfs/canonify.h>
+#include <macros.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -42 +43 @@
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/ns.h>
 #include <async.h>
-#include <atomic.h>
-#include <futex.h>
+#include <fibril_synch.h>
 #include <errno.h>
-#include <string.h>
+#include <assert.h>
+#include <str.h>
 #include <devmap.h>
 #include <ipc/vfs.h>
 #include <ipc/devmap.h>
 
+static async_sess_t vfs_session;
+
+static FIBRIL_MUTEX_INITIALIZE(vfs_phone_mutex);
 static int vfs_phone = -1;
-static futex_t vfs_phone_futex = FUTEX_INITIALIZER;
-static futex_t cwd_futex = FUTEX_INITIALIZER;
-
-DIR *cwd_dir = NULL;
-char *cwd_path = NULL;
-size_t cwd_size = 0;
+
+static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
+
+static int cwd_fd = -1;
+static char *cwd_path = NULL;
+static size_t cwd_size = 0;
 
 char *absolutize(const char *path, size_t *retlen)
@@ -65 +69 @@
         char *ncwd_path;
         char *ncwd_path_nc;
-
-        futex_down(&cwd_futex);
+        size_t total_size; 
+
+        fibril_mutex_lock(&cwd_mutex);
         size_t size = str_size(path);
         if (*path != '/') {
                 if (!cwd_path) {
-                        futex_up(&cwd_futex);
+                        fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
                 }
-                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
+                total_size = cwd_size + 1 + size + 1;
+                ncwd_path_nc = malloc(total_size);
                 if (!ncwd_path_nc) {
-                        futex_up(&cwd_futex);
+                        fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
                 }
-                str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
+                str_cpy(ncwd_path_nc, total_size, cwd_path);
                 ncwd_path_nc[cwd_size] = '/';
                 ncwd_path_nc[cwd_size + 1] = '\0';
         } else {
-                ncwd_path_nc = malloc(size + 1);
+                total_size = size + 1;
+                ncwd_path_nc = malloc(total_size);
                 if (!ncwd_path_nc) {
-                        futex_up(&cwd_futex);
+                        fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
                 }
                 ncwd_path_nc[0] = '\0';
         }
-        str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
+        str_append(ncwd_path_nc, total_size, path);
         ncwd_path = canonify(ncwd_path_nc, retlen);
         if (!ncwd_path) {
-                futex_up(&cwd_futex);
+                fibril_mutex_unlock(&cwd_mutex);
                 free(ncwd_path_nc);
                 return NULL;
@@ -104 +111 @@
         free(ncwd_path_nc);
         if (!ncwd_path) {
-                futex_up(&cwd_futex);
+                fibril_mutex_unlock(&cwd_mutex);
                 return NULL;
         }
-        futex_up(&cwd_futex);
+        fibril_mutex_unlock(&cwd_mutex);
         return ncwd_path;
 }
 
+/** Connect to VFS service and create session. */
 static void vfs_connect(void)
 {
         while (vfs_phone < 0)
-                vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
-}
-
-int mount(const char *fs_name, const char *mp, const char *dev,
+                vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
+        
+        async_session_create(&vfs_session, vfs_phone, 0);
+}
+
+/** Start an async exchange on the VFS session.
+ *
+ * @return              New phone to be used during the exchange.
+ */
+static int vfs_exchange_begin(void)
+{
+        fibril_mutex_lock(&vfs_phone_mutex);
+        if (vfs_phone < 0)
+                vfs_connect();
+        fibril_mutex_unlock(&vfs_phone_mutex);
+
+        return async_exchange_begin(&vfs_session);
+}
+
+/** End an async exchange on the VFS session.
+ *
+ * @param phone         Phone used during the exchange.
+ */
+static void vfs_exchange_end(int phone)
+{
+        async_exchange_end(&vfs_session, phone);
+}
+
+int mount(const char *fs_name, const char *mp, const char *fqdn,
     const char *opts, unsigned int flags)
 {
-        int res;
-        ipcarg_t rc;
-        ipcarg_t rc_orig;
-        aid_t req;
-        dev_handle_t dev_handle;
-        
-        res = devmap_device_get_handle(dev, &dev_handle, flags);
-        if (res != EOK)
+        int null_id = -1;
+        char null[DEVMAP_NAME_MAXLEN];
+        
+        if (str_cmp(fqdn, "") == 0) {
+                /* No device specified, create a fresh
+                   null/%d device instead */
+                null_id = devmap_null_create();
+                
+                if (null_id == -1)
+                        return ENOMEM;
+                
+                snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id);
+                fqdn = null;
+        }
+        
+        devmap_handle_t devmap_handle;
+        int res = devmap_device_get_handle(fqdn, &devmap_handle, flags);
+        if (res != EOK) {
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
                 return res;
+        }
         
         size_t mpa_size;
         char *mpa = absolutize(mp, &mpa_size);
+        if (!mpa) {
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
+                return ENOMEM;
+        }
+        
+        int vfs_phone = vfs_exchange_begin();
+
+        sysarg_t rc_orig;
+        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
+        sysarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+        rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+        rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+        /* Ask VFS whether it likes fs_name. */
+        rc = async_req_0_0(vfs_phone, IPC_M_PING);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(mpa);
+                async_wait_for(req, &rc_orig);
+                
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+        vfs_exchange_end(vfs_phone);
+        free(mpa);
+        async_wait_for(req, &rc);
+        
+        if ((rc != EOK) && (null_id != -1))
+                devmap_null_destroy(null_id);
+        
+        return (int) rc;
+}
+
+int unmount(const char *mp)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        aid_t req;
+        size_t mpa_size;
+        char *mpa;
+        
+        mpa = absolutize(mp, &mpa_size);
         if (!mpa)
                 return ENOMEM;
         
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
-        rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
+        rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 free(mpa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        
-        rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                free(mpa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-
-        rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                free(mpa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-
-        /* Ask VFS whether it likes fs_name. */
-        rc = async_req_0_0(vfs_phone, IPC_M_PING);
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                free(mpa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+
+        vfs_exchange_end(vfs_phone);
         free(mpa);
+        async_wait_for(req, &rc);
         
         return (int) rc;
 }
 
-static int _open(const char *path, int lflag, int oflag, ...)
-{
-        ipcarg_t rc;
+static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
+{
+        int vfs_phone = vfs_exchange_begin();
+        
         ipc_call_t answer;
+        aid_t req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
+        sysarg_t rc = async_data_write_start(vfs_phone, abs, abs_size);
+        
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
+        
+        if (rc != EOK)
+            return (int) rc;
+        
+        return (int) IPC_GET_ARG1(answer);
+}
+
+int open(const char *path, int oflag, ...)
+{
+        size_t abs_size;
+        char *abs = absolutize(path, &abs_size);
+        if (!abs)
+                return ENOMEM;
+        
+        int ret = open_internal(abs, abs_size, L_FILE, oflag);
+        free(abs);
+        
+        return ret;
+}
+
+int open_node(fdi_node_t *node, int oflag)
+{
+        int vfs_phone = vfs_exchange_begin();
+        
+        ipc_call_t answer;
+        aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
+            node->devmap_handle, node->index, oflag, &answer);
+        
+        vfs_exchange_end(vfs_phone);
+
+        sysarg_t rc;
+        async_wait_for(req, &rc);
+        
+        if (rc != EOK)
+                return (int) rc;
+        
+        return (int) IPC_GET_ARG1(answer);
+}
+
+int close(int fildes)
+{
+        sysarg_t rc;
+        
+        int vfs_phone = vfs_exchange_begin();
+        
+        rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
+        
+        vfs_exchange_end(vfs_phone);
+        
+        return (int)rc;
+}
+
+ssize_t read(int fildes, void *buf, size_t nbyte) 
+{
+        sysarg_t rc;
+        ipc_call_t answer;
+        aid_t req;
+
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
+        rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+
+                if (rc_orig == EOK)
+                        return (ssize_t) rc;
+                else
+                        return (ssize_t) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
+        if (rc == EOK)
+                return (ssize_t) IPC_GET_ARG1(answer);
+        else
+                return rc;
+}
+
+ssize_t write(int fildes, const void *buf, size_t nbyte) 
+{
+        sysarg_t rc;
+        ipc_call_t answer;
+        aid_t req;
+
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
+        rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+
+                if (rc_orig == EOK)
+                        return (ssize_t) rc;
+                else
+                        return (ssize_t) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
+        if (rc == EOK)
+                return (ssize_t) IPC_GET_ARG1(answer);
+        else
+                return -1;
+}
+
+int fsync(int fildes)
+{
+        int vfs_phone = vfs_exchange_begin();
+        
+        sysarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
+        
+        vfs_exchange_end(vfs_phone);
+        
+        return (int) rc;
+}
+
+off64_t lseek(int fildes, off64_t offset, int whence)
+{
+        int vfs_phone = vfs_exchange_begin();
+        
+        sysarg_t newoff_lo;
+        sysarg_t newoff_hi;
+        sysarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes,
+            LOWER32(offset), UPPER32(offset), whence,
+            &newoff_lo, &newoff_hi);
+        
+        vfs_exchange_end(vfs_phone);
+        
+        if (rc != EOK)
+                return (off64_t) -1;
+        
+        return (off64_t) MERGE_LOUP32(newoff_lo, newoff_hi);
+}
+
+int ftruncate(int fildes, aoff64_t length)
+{
+        sysarg_t rc;
+        
+        int vfs_phone = vfs_exchange_begin();
+        
+        rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes,
+            LOWER32(length), UPPER32(length));
+        vfs_exchange_end(vfs_phone);
+        
+        return (int) rc;
+}
+
+int fstat(int fildes, struct stat *stat)
+{
+        sysarg_t rc;
+        aid_t req;
+
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
+        rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+
+                if (rc_orig == EOK)
+                        return (ssize_t) rc;
+                else
+                        return (ssize_t) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
+
+        return rc;
+}
+
+int stat(const char *path, struct stat *stat)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
         aid_t req;
         
@@ -208 +506 @@
                 return ENOMEM;
         
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
-        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-        
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
+        rc = async_data_write_start(vfs_phone, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 free(pa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(pa);
-        
-        if (rc != EOK)
-            return (int) rc;
-        
-        return (int) IPC_GET_ARG1(answer);
-}
-
-int open(const char *path, int oflag, ...)
-{
-        return _open(path, L_FILE, oflag);
-}
-
-int open_node(fdi_node_t *node, int oflag)
-{
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        ipc_call_t answer;
-        aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
-            node->dev_handle, node->index, oflag, &answer);
-        
-        ipcarg_t rc;
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        
-        if (rc != EOK)
-                return (int) rc;
-        
-        return (int) IPC_GET_ARG1(answer);
-}
-
-int close(int fildes)
-{
-        ipcarg_t rc;
-        
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
-        
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        
-        return (int)rc;
-}
-
-ssize_t read(int fildes, void *buf, size_t nbyte) 
-{
-        ipcarg_t rc;
-        ipc_call_t answer;
-        aid_t req;
-
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
-        rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-        
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                if (rc_orig == EOK)
-                        return (ssize_t) rc;
-                else
-                        return (ssize_t) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        if (rc == EOK)
-                return (ssize_t) IPC_GET_ARG1(answer);
-        else
-                return rc;
-}
-
-ssize_t write(int fildes, const void *buf, size_t nbyte) 
-{
-        ipcarg_t rc;
-        ipc_call_t answer;
-        aid_t req;
-
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
-        rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-        
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                if (rc_orig == EOK)
-                        return (ssize_t) rc;
-                else
-                        return (ssize_t) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        if (rc == EOK)
-                return (ssize_t) IPC_GET_ARG1(answer);
-        else
-                return -1;
-}
-
-int fsync(int fildes)
-{
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        ipcarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
-        
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        
-        return (int) rc;
-}
-
-off_t lseek(int fildes, off_t offset, int whence)
-{
-        ipcarg_t rc;
-
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        ipcarg_t newoffs;
-        rc = async_req_3_1(vfs_phone, VFS_IN_SEEK, fildes, offset, whence,
-            &newoffs);
-
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-
-        if (rc != EOK)
-                return (off_t) -1;
-        
-        return (off_t) newoffs;
-}
-
-int ftruncate(int fildes, off_t length)
-{
-        ipcarg_t rc;
-        
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        rc = async_req_2_0(vfs_phone, VFS_IN_TRUNCATE, fildes, length);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        return (int) rc;
-}
-
-int fstat(int fildes, struct stat *stat)
-{
-        ipcarg_t rc;
-        aid_t req;
-
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
-        rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-                
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                if (rc_orig == EOK)
-                        return (ssize_t) rc;
-                else
-                        return (ssize_t) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-
+        async_wait_for(req, &rc);
         return rc;
 }
 
-int stat(const char *path, struct stat *stat)
-{
-        ipcarg_t rc;
-        ipcarg_t rc_orig;
+DIR *opendir(const char *dirname)
+{
+        DIR *dirp = malloc(sizeof(DIR));
+        if (!dirp)
+                return NULL;
+        
+        size_t abs_size;
+        char *abs = absolutize(dirname, &abs_size);
+        if (!abs) {
+                free(dirp);
+                return NULL;
+        }
+        
+        int ret = open_internal(abs, abs_size, L_DIRECTORY, 0);
+        free(abs);
+        
+        if (ret < 0) {
+                free(dirp);
+                return NULL;
+        }
+        
+        dirp->fd = ret;
+        return dirp;
+}
+
+struct dirent *readdir(DIR *dirp)
+{
+        ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
+        if (len <= 0)
+                return NULL;
+        return &dirp->res;
+}
+
+void rewinddir(DIR *dirp)
+{
+        (void) lseek(dirp->fd, 0, SEEK_SET);
+}
+
+int closedir(DIR *dirp)
+{
+        (void) close(dirp->fd);
+        free(dirp);
+        return 0;
+}
+
+int mkdir(const char *path, mode_t mode)
+{
+        sysarg_t rc;
         aid_t req;
         
@@ -432 +590 @@
                 return ENOMEM;
         
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
-        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
+        rc = async_data_write_start(vfs_phone, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 free(pa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                free(pa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
+
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(pa);
+        async_wait_for(req, &rc);
         return rc;
 }
 
-DIR *opendir(const char *dirname)
-{
-        DIR *dirp = malloc(sizeof(DIR));
-        if (!dirp)
-                return NULL;
-        dirp->fd = _open(dirname, L_DIRECTORY, 0);
-        if (dirp->fd < 0) {
-                free(dirp);
-                return NULL;
-        }
-        return dirp;
-}
-
-struct dirent *readdir(DIR *dirp)
-{
-        ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1);
-        if (len <= 0)
-                return NULL;
-        return &dirp->res;
-}
-
-void rewinddir(DIR *dirp)
-{
-        (void) lseek(dirp->fd, 0, SEEK_SET);
-}
-
-int closedir(DIR *dirp)
-{
-        (void) close(dirp->fd);
-        free(dirp);
-        return 0;
-}
-
-int mkdir(const char *path, mode_t mode)
-{
-        ipcarg_t rc;
+static int _unlink(const char *path, int lflag)
+{
+        sysarg_t rc;
         aid_t req;
         
@@ -508 +621 @@
         if (!pa)
                 return ENOMEM;
-        
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
-        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-        
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
+
+        int vfs_phone = vfs_exchange_begin();
+        
+        req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
+        rc = async_data_write_start(vfs_phone, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 free(pa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
+
+                sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(pa);
+        async_wait_for(req, &rc);
         return rc;
 }
 
-static int _unlink(const char *path, int lflag)
-{
-        ipcarg_t rc;
-        aid_t req;
-        
-        size_t pa_size;
-        char *pa = absolutize(path, &pa_size);
-        if (!pa)
-                return ENOMEM;
-
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
-        
-        req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
-        rc = ipc_data_write_start(vfs_phone, pa, pa_size);
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                free(pa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
-        free(pa);
-        return rc;
-}
-
 int unlink(const char *path)
 {
@@ -581 +656 @@
 int rename(const char *old, const char *new)
 {
-        ipcarg_t rc;
-        ipcarg_t rc_orig;
+        sysarg_t rc;
+        sysarg_t rc_orig;
         aid_t req;
         
@@ -597 +672 @@
         }
 
-        futex_down(&vfs_phone_futex);
-        async_serialize_start();
-        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         
         req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
-        rc = ipc_data_write_start(vfs_phone, olda, olda_size);
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
+        rc = async_data_write_start(vfs_phone, olda, olda_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 free(olda);
                 free(newa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        rc = ipc_data_write_start(vfs_phone, newa, newa_size);
-        if (rc != EOK) {
-                async_wait_for(req, &rc_orig);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        rc = async_data_write_start(vfs_phone, newa, newa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 free(olda);
                 free(newa);
-                if (rc_orig == EOK)
-                        return (int) rc;
-                else
-                        return (int) rc_orig;
-        }
-        async_wait_for(req, &rc);
-        async_serialize_end();
-        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(olda);
         free(newa);
+        async_wait_for(req, &rc);
         return rc;
 }
@@ -636 +706 @@
 int chdir(const char *path)
 {
-        size_t pa_size;
-        char *pa = absolutize(path, &pa_size);
-        if (!pa)
+        size_t abs_size;
+        char *abs = absolutize(path, &abs_size);
+        if (!abs)
                 return ENOMEM;
-
-        DIR *d = opendir(pa);
-        if (!d) {
-                free(pa);
+        
+        int fd = open_internal(abs, abs_size, L_DIRECTORY, O_DESC);
+        
+        if (fd < 0) {
+                free(abs);
                 return ENOENT;
         }
-
-        futex_down(&cwd_futex);
-        if (cwd_dir) {
-                closedir(cwd_dir);
-                cwd_dir = NULL;
-                free(cwd_path); 
-                cwd_path = NULL;
-                cwd_size = 0;
-        }
-        cwd_dir = d;
-        cwd_path = pa;
-        cwd_size = pa_size;
-        futex_up(&cwd_futex);
+        
+        fibril_mutex_lock(&cwd_mutex);
+        
+        if (cwd_fd >= 0)
+                close(cwd_fd);
+        
+        
+        if (cwd_path)
+                free(cwd_path);
+        
+        cwd_fd = fd;
+        cwd_path = abs;
+        cwd_size = abs_size;
+        
+        fibril_mutex_unlock(&cwd_mutex);
         return EOK;
 }
@@ -664 +737 @@
 char *getcwd(char *buf, size_t size)
 {
-        if (!size)
+        if (size == 0)
                 return NULL;
-        futex_down(&cwd_futex);
-        if (size < cwd_size + 1) {
-                futex_up(&cwd_futex);
+        
+        fibril_mutex_lock(&cwd_mutex);
+        
+        if ((cwd_size == 0) || (size < cwd_size + 1)) {
+                fibril_mutex_unlock(&cwd_mutex);
                 return NULL;
         }
+        
         str_cpy(buf, size, cwd_path);
-        futex_up(&cwd_futex);
+        fibril_mutex_unlock(&cwd_mutex);
+        
         return buf;
 }
@@ -683 +760 @@
         rc = fstat(fildes, &stat);
 
-        if (!stat.devfs_stat.device)
+        if (!stat.device)
                 return -1;
         
-        return devmap_device_connect(stat.devfs_stat.device, 0);
+        return devmap_device_connect(stat.device, 0);
 }
 
@@ -698 +775 @@
         if (rc == EOK) {
                 node->fs_handle = stat.fs_handle;
-                node->dev_handle = stat.dev_handle;
+                node->devmap_handle = stat.devmap_handle;
                 node->index = stat.index;
         }
         
         return rc;
+}
+
+int dup2(int oldfd, int newfd)
+{
+        int vfs_phone = vfs_exchange_begin();
+        
+        sysarg_t ret;
+        sysarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
+        
+        vfs_exchange_end(vfs_phone);
+        
+        if (rc == EOK)
+                return (int) ret;
+        
+        return (int) rc;
 }