Changeset 371bd7d in mainline for uspace/lib/c/generic

Timestamp:

2010-03-27T09:22:17Z (16 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

36a75a2

Parents:

cd82bb1 (diff), eaf22d4 (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.

Location:

uspace/lib/c/generic

Files:

• adt/hash_table.c (moved) (moved from uspace/lib/libc/generic/adt/hash_table.c ) (2 diffs)
• adt/list.c (moved) (moved from uspace/lib/libc/generic/adt/list.c )
• as.c (moved) (moved from uspace/lib/libc/generic/as.c )
• async.c (moved) (moved from uspace/lib/libc/generic/async.c ) (6 diffs)
• cap.c (moved) (moved from uspace/lib/libc/generic/cap.c )
• clipboard.c (added)
• ddi.c (moved) (moved from uspace/lib/libc/generic/ddi.c )
• devmap.c (moved) (moved from uspace/lib/libc/generic/devmap.c ) (11 diffs)
• err.c (moved) (moved from uspace/lib/libc/generic/err.c )
• errno.c (moved) (moved from uspace/lib/libc/generic/errno.c )
• event.c (moved) (moved from uspace/lib/libc/generic/event.c )
• fibril.c (moved) (moved from uspace/lib/libc/generic/fibril.c ) (9 diffs)
• fibril_synch.c (moved) (moved from uspace/lib/libc/generic/fibril_sync.c ) (1 diff)
• futex.c (added)
• getopt.c (moved) (moved from uspace/lib/libc/generic/getopt.c ) (1 diff)
• io/asprintf.c (moved) (moved from uspace/lib/libc/generic/io/asprintf.c ) (1 diff)
• io/console.c (moved) (moved from uspace/lib/libc/generic/io/console.c )
• io/io.c (moved) (moved from uspace/lib/libc/generic/io/io.c ) (21 diffs)
• io/klog.c (moved) (moved from uspace/lib/libc/generic/io/klog.c ) (1 diff)
• io/printf.c (moved) (moved from uspace/lib/libc/generic/io/printf.c )
• io/printf_core.c (moved) (moved from uspace/lib/libc/generic/io/printf_core.c ) (1 diff)
• io/snprintf.c (moved) (moved from uspace/lib/libc/generic/io/snprintf.c )
• io/vprintf.c (moved) (moved from uspace/lib/libc/generic/io/vprintf.c ) (1 diff)
• io/vsnprintf.c (moved) (moved from uspace/lib/libc/generic/io/vsnprintf.c ) (1 diff)
• ipc.c (moved) (moved from uspace/lib/libc/generic/ipc.c ) (1 diff)
• libc.c (moved) (moved from uspace/lib/libc/generic/libc.c )
• loader.c (moved) (moved from uspace/lib/libc/generic/loader.c ) (3 diffs)
• malloc.c (moved) (moved from uspace/lib/libc/generic/malloc.c ) (1 diff)
• mem.c (moved) (moved from uspace/lib/libc/generic/mem.c )
• mman.c (moved) (moved from uspace/lib/libc/generic/mman.c ) (1 diff)
• pcb.c (moved) (moved from uspace/lib/libc/generic/pcb.c )
• smc.c (moved) (moved from uspace/lib/libc/generic/smc.c )
• stacktrace.c (added)
• stdlib.c (moved) (moved from uspace/lib/libc/generic/stdlib.c )
• str.c (moved) (moved from uspace/lib/libc/generic/string.c ) (4 diffs)
• sysinfo.c (moved) (moved from uspace/lib/libc/generic/sysinfo.c ) (1 diff)
• task.c (moved) (moved from uspace/lib/libc/generic/task.c ) (2 diffs)
• thread.c (moved) (moved from uspace/lib/libc/generic/thread.c ) (2 diffs)
• time.c (moved) (moved from uspace/lib/libc/generic/time.c ) (3 diffs)
• tls.c (moved) (moved from uspace/lib/libc/generic/tls.c ) (1 diff)
• udebug.c (moved) (moved from uspace/lib/libc/generic/udebug.c ) (2 diffs)
• vfs/canonify.c (moved) (moved from uspace/lib/libc/generic/vfs/canonify.c )
• vfs/vfs.c (moved) (moved from uspace/lib/libc/generic/vfs/vfs.c ) (9 diffs)

uspace/lib/c/generic/adt/hash_table.c

@@ -43 +43 @@
 #include <assert.h>
 #include <stdio.h>
-#include <string.h>
+#include <str.h>
 
 /** Create chained hash table.
@@ -193 +193 @@
 }
 
+/** Apply fucntion to all items in hash table.
+ *
+ * @param h             Hash table.
+ * @param f             Function to be applied.
+ * @param arg           Argument to be passed to the function.
+ */
+void
+hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
+{
+        hash_index_t bucket;
+        link_t *cur;
+
+        for (bucket = 0; bucket < h->entries; bucket++) {
+                for (cur = h->entry[bucket].next; cur != &h->entry[bucket];
+                    cur = cur->next) {
+                        f(cur, arg);
+                }
+        }
+}
+
 /** @}
  */

uspace/lib/c/generic/async.c

@@ -1101 +1101 @@
 }
 
+/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
+ * 
+ * Ask through phone for a new connection to some service.
+ *
+ * @param phoneid       Phone handle used for contacting the other side.
+ * @param arg1          User defined argument.
+ * @param arg2          User defined argument.
+ * @param arg3          User defined argument.
+ *
+ * @return              New phone handle on success or a negative error code.
+ */
+int
+async_connect_me_to(int phoneid, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3)
+{
+        int rc;
+        ipcarg_t newphid;
+
+        rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL,
+            NULL, NULL, NULL, &newphid);
+        
+        if (rc != EOK)  
+                return rc;
+
+        return newphid;
+}
+
+/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
+ * 
+ * Ask through phone for a new connection to some service and block until
+ * success.
+ *
+ * @param phoneid       Phone handle used for contacting the other side.
+ * @param arg1          User defined argument.
+ * @param arg2          User defined argument.
+ * @param arg3          User defined argument.
+ *
+ * @return              New phone handle on success or a negative error code.
+ */
+int
+async_connect_me_to_blocking(int phoneid, ipcarg_t arg1, ipcarg_t arg2,
+    ipcarg_t arg3)
+{
+        int rc;
+        ipcarg_t newphid;
+
+        rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+            IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
+        
+        if (rc != EOK)  
+                return rc;
+
+        return newphid;
+}
+
 /** Wrapper for making IPC_M_SHARE_IN calls using the async framework.
  *
@@ -1287 +1341 @@
 }
 
+/** Wrapper for forwarding any read request
+ *
+ *
+ */
+int async_data_read_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
+{
+        ipc_callid_t callid;
+        if (!async_data_read_receive(&callid, NULL)) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4,
+            dataptr);
+        if (msg == 0) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0,
+            IPC_FF_ROUTE_FROM_ME);
+        if (retval != EOK) {
+                async_wait_for(msg, NULL);
+                ipc_answer_0(callid, retval);
+                return retval;
+        }
+        
+        ipcarg_t rc;
+        async_wait_for(msg, &rc);
+        
+        return (int) rc;
+}
+
 /** Wrapper for making IPC_M_DATA_WRITE calls using the async framework.
  *
- * @param phoneid       Phone that will be used to contact the receiving side.
- * @param src           Address of the beginning of the source buffer.
- * @param size          Size of the source buffer.
- *
- * @return              Zero on success or a negative error code from errno.h.
+ * @param phoneid Phone that will be used to contact the receiving side.
+ * @param src     Address of the beginning of the source buffer.
+ * @param size    Size of the source buffer.
+ *
+ * @return Zero on success or a negative error code from errno.h.
+ *
  */
 int async_data_write_start(int phoneid, const void *src, size_t size)
@@ -1308 +1397 @@
  * So far, this wrapper is to be used from within a connection fibril.
  *
- * @param callid        Storage where the hash of the IPC_M_DATA_WRITE call will
- *                      be stored.
- * @param size          Storage where the suggested size will be stored. May be
- *                      NULL
- *
- * @return              Non-zero on success, zero on failure.
+ * @param callid Storage where the hash of the IPC_M_DATA_WRITE call will
+ *               be stored.
+ * @param size   Storage where the suggested size will be stored. May be
+ *               NULL
+ *
+ * @return Non-zero on success, zero on failure.
+ *
  */
 int async_data_write_receive(ipc_callid_t *callid, size_t *size)
@@ -1320 +1410 @@
         
         assert(callid);
-
+        
         *callid = async_get_call(&data);
         if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
                 return 0;
+        
         if (size)
                 *size = (size_t) IPC_GET_ARG2(data);
+        
         return 1;
 }
@@ -1334 +1426 @@
  * so that the user doesn't have to remember the meaning of each IPC argument.
  *
- * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst           Final destination address for the IPC_M_DATA_WRITE call.
- * @param size          Final size for the IPC_M_DATA_WRITE call.
- *
- * @return              Zero on success or a value from @ref errno.h on failure.
+ * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
+ * @param dst    Final destination address for the IPC_M_DATA_WRITE call.
+ * @param size   Final size for the IPC_M_DATA_WRITE call.
+ *
+ * @return Zero on success or a value from @ref errno.h on failure.
+ *
  */
 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
@@ -1345 +1438 @@
 }
 
+/** Wrapper for receiving binary data or strings
+ *
+ * This wrapper only makes it more comfortable to use async_data_write_*
+ * functions to receive binary data or strings.
+ *
+ * @param data       Pointer to data pointer (which should be later disposed
+ *                   by free()). If the operation fails, the pointer is not
+ *                   touched.
+ * @param nullterm   If true then the received data is always zero terminated.
+ *                   This also causes to allocate one extra byte beyond the
+ *                   raw transmitted data.
+ * @param min_size   Minimum size (in bytes) of the data to receive.
+ * @param max_size   Maximum size (in bytes) of the data to receive. 0 means
+ *                   no limit.
+ * @param granulariy If non-zero then the size of the received data has to
+ *                   be divisible by this value.
+ * @param received   If not NULL, the size of the received data is stored here.
+ *
+ * @return Zero on success or a value from @ref errno.h on failure.
+ *
+ */
+int async_data_write_accept(void **data, const bool nullterm,
+    const size_t min_size, const size_t max_size, const size_t granularity,
+    size_t *received)
+{
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_write_receive(&callid, &size)) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        if (size < min_size) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        if ((max_size > 0) && (size > max_size)) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        if ((granularity > 0) && ((size % granularity) != 0)) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        void *_data;
+        
+        if (nullterm)
+                _data = malloc(size + 1);
+        else
+                _data = malloc(size);
+        
+        if (_data == NULL) {
+                ipc_answer_0(callid, ENOMEM);
+                return ENOMEM;
+        }
+        
+        int rc = async_data_write_finalize(callid, _data, size);
+        if (rc != EOK) {
+                free(_data);
+                return rc;
+        }
+        
+        if (nullterm)
+                ((char *) _data)[size] = 0;
+        
+        *data = _data;
+        if (received != NULL)
+                *received = size;
+        
+        return EOK;
+}
+
+/** Wrapper for voiding any data that is about to be received
+ *
+ * This wrapper can be used to void any pending data
+ *
+ * @param retval Error value from @ref errno.h to be returned to the caller.
+ *
+ */
+void async_data_write_void(const int retval)
+{
+        ipc_callid_t callid;
+        async_data_write_receive(&callid, NULL);
+        ipc_answer_0(callid, retval);
+}
+
+/** Wrapper for forwarding any data that is about to be received
+ *
+ *
+ */
+int async_data_write_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
+{
+        ipc_callid_t callid;
+        if (!async_data_write_receive(&callid, NULL)) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4,
+            dataptr);
+        if (msg == 0) {
+                ipc_answer_0(callid, EINVAL);
+                return EINVAL;
+        }
+        
+        int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0,
+            IPC_FF_ROUTE_FROM_ME);
+        if (retval != EOK) {
+                async_wait_for(msg, NULL);
+                ipc_answer_0(callid, retval);
+                return retval;
+        }
+        
+        ipcarg_t rc;
+        async_wait_for(msg, &rc);
+        
+        return (int) rc;
+}
+
 /** @}
  */

uspace/lib/c/generic/devmap.c

@@ -28 +28 @@
  */
 
-#include <string.h>
+#include <str.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>
@@ -35 +35 @@
 #include <async.h>
 #include <errno.h>
+#include <malloc.h>
+#include <bool.h>
 
 static int devmap_phone_driver = -1;
@@ -105 +107 @@
         aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
         
-        ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
-        
+        ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
         if (retval != EOK) {
                 async_wait_for(req, NULL);
@@ -126 +127 @@
 /** Register new device.
  *
- * @param name   Device name.
- * @param handle Output: Handle to the created instance of device.
+ * @param namespace Namespace name.
+ * @param fqdn      Fully qualified device name.
+ * @param handle    Output: Handle to the created instance of device.
  *
  */
-int devmap_device_register(const char *name, dev_handle_t *handle)
+int devmap_device_register(const char *fqdn, dev_handle_t *handle)
 {
         int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
@@ -143 +145 @@
             &answer);
         
-        ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
-        
+        ipcarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
         if (retval != EOK) {
                 async_wait_for(req, NULL);
@@ -167 +168 @@
 }
 
-int devmap_device_get_handle(const char *name, dev_handle_t *handle, unsigned int flags)
+int devmap_device_get_handle(const char *fqdn, dev_handle_t *handle, unsigned int flags)
 {
         int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
@@ -180 +181 @@
             &answer);
         
-        ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
-        
+        ipcarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
         if (retval != EOK) {
                 async_wait_for(req, NULL);
@@ -202 +202 @@
         
         return retval;
+}
+
+int devmap_namespace_get_handle(const char *name, dev_handle_t *handle, unsigned int flags)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
+        
+        if (phone < 0)
+                return phone;
+        
+        async_serialize_start();
+        
+        ipc_call_t answer;
+        aid_t req = async_send_2(phone, DEVMAP_NAMESPACE_GET_HANDLE, flags, 0,
+            &answer);
+        
+        ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        
+        async_wait_for(req, &retval);
+        
+        async_serialize_end();
+        
+        if (retval != EOK) {
+                if (handle != NULL)
+                        *handle = (dev_handle_t) -1;
+                return retval;
+        }
+        
+        if (handle != NULL)
+                *handle = (dev_handle_t) IPC_GET_ARG1(answer);
+        
+        return retval;
+}
+
+devmap_handle_type_t devmap_handle_probe(dev_handle_t handle)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        
+        if (phone < 0)
+                return phone;
+        
+        ipcarg_t type;
+        int retval = async_req_1_1(phone, DEVMAP_HANDLE_PROBE, handle, &type);
+        if (retval != EOK)
+                return DEV_HANDLE_NONE;
+        
+        return (devmap_handle_type_t) type;
 }
 
@@ -227 +278 @@
         
         ipcarg_t null_id;
-        int retval = async_req_0_1(phone, DEVMAP_DEVICE_NULL_CREATE, &null_id);
+        int retval = async_req_0_1(phone, DEVMAP_NULL_CREATE, &null_id);
         if (retval != EOK)
                 return -1;
@@ -241 +292 @@
                 return;
         
-        async_req_1_0(phone, DEVMAP_DEVICE_NULL_DESTROY, (ipcarg_t) null_id);
-}
-
-ipcarg_t devmap_device_get_count(void)
-{
-        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
-        
-        if (phone < 0)
-                return 0;
-        
+        async_req_1_0(phone, DEVMAP_NULL_DESTROY, (ipcarg_t) null_id);
+}
+
+static size_t devmap_count_namespaces_internal(int phone)
+{
         ipcarg_t count;
-        int retval = async_req_0_1(phone, DEVMAP_DEVICE_GET_COUNT, &count);
+        int retval = async_req_0_1(phone, DEVMAP_GET_NAMESPACE_COUNT, &count);
         if (retval != EOK)
                 return 0;
@@ -259 +305 @@
 }
 
-ipcarg_t devmap_device_get_devices(ipcarg_t count, dev_desc_t *data)
-{
-        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
-        
-        if (phone < 0)
-                return 0;
-        
-        async_serialize_start();
-        
-        ipc_call_t answer;
-        aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer);
-        
-        ipcarg_t retval = async_data_read_start(phone, data, count * sizeof(dev_desc_t));
-        
-        if (retval != EOK) {
-                async_wait_for(req, NULL);
-                async_serialize_end();
-                return 0;
-        }
-        
-        async_wait_for(req, &retval);
-        
-        async_serialize_end();
-        
+static size_t devmap_count_devices_internal(int phone, dev_handle_t ns_handle)
+{
+        ipcarg_t count;
+        int retval = async_req_1_1(phone, DEVMAP_GET_DEVICE_COUNT, ns_handle, &count);
         if (retval != EOK)
                 return 0;
         
-        return IPC_GET_ARG1(answer);
-}
+        return count;
+}
+
+size_t devmap_count_namespaces(void)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        
+        if (phone < 0)
+                return 0;
+        
+        return devmap_count_namespaces_internal(phone);
+}
+
+size_t devmap_count_devices(dev_handle_t ns_handle)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        
+        if (phone < 0)
+                return 0;
+        
+        return devmap_count_devices_internal(phone, ns_handle);
+}
+
+size_t devmap_get_namespaces(dev_desc_t **data)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        
+        if (phone < 0)
+                return 0;
+        
+        /* Loop until namespaces read succesful */
+        while (true) {
+                size_t count = devmap_count_namespaces_internal(phone);
+                if (count == 0)
+                        return 0;
+                
+                dev_desc_t *devs = (dev_desc_t *) calloc(count, sizeof(dev_desc_t));
+                if (devs == NULL)
+                        return 0;
+                
+                async_serialize_start();
+                
+                ipc_call_t answer;
+                aid_t req = async_send_0(phone, DEVMAP_GET_NAMESPACES, &answer);
+                
+                int rc = async_data_read_start(phone, devs, count * sizeof(dev_desc_t));
+                if (rc == EOVERFLOW) {
+                        /*
+                         * Number of namespaces has changed since
+                         * the last call of DEVMAP_DEVICE_GET_NAMESPACE_COUNT
+                         */
+                        async_serialize_end();
+                        free(devs);
+                        continue;
+                }
+                
+                if (rc != EOK) {
+                        async_wait_for(req, NULL);
+                        async_serialize_end();
+                        free(devs);
+                        return 0;
+                }
+                
+                ipcarg_t retval;
+                async_wait_for(req, &retval);
+                async_serialize_end();
+                
+                if (retval != EOK)
+                        return 0;
+                
+                *data = devs;
+                return count;
+        }
+}
+
+size_t devmap_get_devices(dev_handle_t ns_handle, dev_desc_t **data)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        
+        if (phone < 0)
+                return 0;
+        
+        /* Loop until namespaces read succesful */
+        while (true) {
+                size_t count = devmap_count_devices_internal(phone, ns_handle);
+                if (count == 0)
+                        return 0;
+                
+                dev_desc_t *devs = (dev_desc_t *) calloc(count, sizeof(dev_desc_t));
+                if (devs == NULL)
+                        return 0;
+                
+                async_serialize_start();
+                
+                ipc_call_t answer;
+                aid_t req = async_send_1(phone, DEVMAP_GET_DEVICES, ns_handle, &answer);
+                
+                int rc = async_data_read_start(phone, devs, count * sizeof(dev_desc_t));
+                if (rc == EOVERFLOW) {
+                        /*
+                         * Number of devices has changed since
+                         * the last call of DEVMAP_DEVICE_GET_DEVICE_COUNT
+                         */
+                        async_serialize_end();
+                        free(devs);
+                        continue;
+                }
+                
+                if (rc != EOK) {
+                        async_wait_for(req, NULL);
+                        async_serialize_end();
+                        free(devs);
+                        return 0;
+                }
+                
+                ipcarg_t retval;
+                async_wait_for(req, &retval);
+                async_serialize_end();
+                
+                if (retval != EOK)
+                        return 0;
+                
+                *data = devs;
+                return count;
+        }
+}

uspace/lib/c/generic/fibril.c

@@ -41 +41 @@
 #include <unistd.h>
 #include <stdio.h>
+#include <arch/barrier.h>
 #include <libarch/faddr.h>
 #include <futex.h>
@@ -133 +134 @@
 int fibril_switch(fibril_switch_type_t stype)
 {
-        fibril_t *srcf, *dstf;
         int retval = 0;
         
         futex_down(&fibril_futex);
-
+        
         if (stype == FIBRIL_PREEMPT && list_empty(&ready_list))
                 goto ret_0;
-
+        
         if (stype == FIBRIL_FROM_MANAGER) {
-                if (list_empty(&ready_list) && list_empty(&serialized_list))
+                if ((list_empty(&ready_list)) && (list_empty(&serialized_list)))
                         goto ret_0;
+                
                 /*
                  * Do not preempt if there is not enough threads to run the
                  * ready fibrils which are not serialized.
                  */
-                if (list_empty(&serialized_list) &&
-                    threads_in_manager <= serialized_threads) {
+                if ((list_empty(&serialized_list)) &&
+                    (threads_in_manager <= serialized_threads)) {
                         goto ret_0;
                 }
         }
+        
         /* If we are going to manager and none exists, create it */
-        if (stype == FIBRIL_TO_MANAGER || stype == FIBRIL_FROM_DEAD) {
+        if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) {
                 while (list_empty(&manager_list)) {
                         futex_up(&fibril_futex);
@@ -162 +164 @@
         }
         
-        srcf = __tcb_get()->fibril_data;
+        fibril_t *srcf = __tcb_get()->fibril_data;
         if (stype != FIBRIL_FROM_DEAD) {
+                
                 /* Save current state */
                 if (!context_save(&srcf->ctx)) {
                         if (serialization_count)
                                 srcf->flags &= ~FIBRIL_SERIALIZED;
+                        
                         if (srcf->clean_after_me) {
                                 /*
@@ -173 +177 @@
                                  * restored context here.
                                  */
-                                void *stack = srcf->clean_after_me->stack; 
+                                void *stack = srcf->clean_after_me->stack;
                                 if (stack) {
                                         /*
@@ -188 +192 @@
                                 srcf->clean_after_me = NULL;
                         }
+                        
                         return 1;       /* futex_up already done here */
                 }
-
+                
                 /* Save myself to the correct run list */
                 if (stype == FIBRIL_PREEMPT)
@@ -197 +202 @@
                         list_append(&srcf->link, &manager_list);
                         threads_in_manager--;
-                } else {        
+                } else {
                         /*
                          * If stype == FIBRIL_TO_MANAGER, don't put ourselves to
@@ -207 +212 @@
         
         /* Choose a new fibril to run */
-        if (stype == FIBRIL_TO_MANAGER || stype == FIBRIL_FROM_DEAD) {
+        fibril_t *dstf;
+        if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) {
                 dstf = list_get_instance(manager_list.next, fibril_t, link);
                 if (serialization_count && stype == FIBRIL_TO_MANAGER) {
@@ -214 +220 @@
                 }
                 threads_in_manager++;
-
+                
                 if (stype == FIBRIL_FROM_DEAD) 
                         dstf->clean_after_me = srcf;
@@ -228 +234 @@
         }
         list_remove(&dstf->link);
-
+        
         futex_up(&fibril_futex);
         context_restore(&dstf->ctx);
         /* not reached */
-
+        
 ret_0:
         futex_up(&fibril_futex);

uspace/lib/c/generic/fibril_synch.c

@@ -33 +33 @@
  */
 
-#include <fibril_sync.h>
+#include <fibril_synch.h>
 #include <fibril.h>
 #include <async.h>

uspace/lib/c/generic/getopt.c

@@ -38 +38 @@
 #include <getopt.h>
 #include <stdlib.h>
-#include <string.h>
+#include <str.h>
 
 /* HelenOS Port : We're incorporating only the modern getopt_long with wrappers

uspace/lib/c/generic/io/asprintf.c

@@ -37 +37 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
+#include <str.h>
 #include <io/printf_core.h>
 

uspace/lib/c/generic/io/io.c

@@ -37 +37 @@
 #include <fcntl.h>
 #include <assert.h>
-#include <string.h>
+#include <str.h>
 #include <errno.h>
 #include <bool.h>
@@ -46 +46 @@
 #include <adt/list.h>
 
+static void _ffillbuf(FILE *stream);
 static void _fflushbuf(FILE *stream);
 
@@ -57 +58 @@
         .buf = NULL,
         .buf_size = 0,
-        .buf_head = NULL
+        .buf_head = NULL,
+        .buf_tail = NULL,
+        .buf_state = _bs_empty
 };
 
@@ -69 +72 @@
         .buf = NULL,
         .buf_size = BUFSIZ,
-        .buf_head = NULL
+        .buf_head = NULL,
+        .buf_tail = NULL,
+        .buf_state = _bs_empty
 };
 
@@ -81 +86 @@
         .buf = NULL,
         .buf_size = 0,
-        .buf_head = NULL
+        .buf_head = NULL,
+        .buf_tail = NULL,
+        .buf_state = _bs_empty
 };
 
@@ -179 +186 @@
         stream->buf_size = size;
         stream->buf_head = stream->buf;
+        stream->buf_tail = stream->buf;
+        stream->buf_state = _bs_empty;
 }
 
@@ -210 +219 @@
         
         stream->buf_head = stream->buf;
+        stream->buf_tail = stream->buf;
         return 0;
 }
@@ -243 +253 @@
         stream->klog = false;
         stream->phone = -1;
+        stream->need_sync = false;
         _setvbuf(stream);
         
@@ -264 +275 @@
         stream->klog = false;
         stream->phone = -1;
+        stream->need_sync = false;
         _setvbuf(stream);
         
@@ -295 +307 @@
         stream->klog = false;
         stream->phone = -1;
+        stream->need_sync = false;
         _setvbuf(stream);
         
@@ -331 +344 @@
 }
 
-/** Read from a stream.
+/** Read from a stream (unbuffered).
  *
  * @param buf    Destination buffer.
@@ -337 +350 @@
  * @param nmemb  Number of records to read.
  * @param stream Pointer to the stream.
- *
- */
-size_t fread(void *buf, size_t size, size_t nmemb, FILE *stream)
-{
-        size_t left = size * nmemb;
-        size_t done = 0;
-        
-        /* Make sure no data is pending write. */
-        _fflushbuf(stream);
+ */
+static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
+{
+        size_t left, done;
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
+        left = size * nmemb;
+        done = 0;
         
         while ((left > 0) && (!stream->error) && (!stream->eof)) {
@@ -363 +377 @@
 }
 
+/** Write to a stream (unbuffered).
+ *
+ * @param buf    Source buffer.
+ * @param size   Size of each record.
+ * @param nmemb  Number of records to write.
+ * @param stream Pointer to the stream.
+ */
 static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
 {
-        size_t left = size * nmemb;
-        size_t done = 0;
-        
+        size_t left;
+        size_t done;
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
+        left = size * nmemb;
+        done = 0;
+
         while ((left > 0) && (!stream->error)) {
                 ssize_t wr;
@@ -383 +410 @@
                 }
         }
+
+        if (done > 0)
+                stream->need_sync = true;
         
         return (done / size);
 }
 
-/** Drain stream buffer, do not sync stream. */
+/** Read some data in stream buffer. */
+static void _ffillbuf(FILE *stream)
+{
+        ssize_t rc;
+
+        stream->buf_head = stream->buf_tail = stream->buf;
+
+        rc = read(stream->fd, stream->buf, stream->buf_size);
+        if (rc < 0) {
+                stream->error = true;
+                return;
+        }
+
+        if (rc == 0) {
+                stream->eof = true;
+                return;
+        }
+
+        stream->buf_head += rc;
+        stream->buf_state = _bs_read;
+}
+
+/** Write out stream buffer, do not sync stream. */
 static void _fflushbuf(FILE *stream)
 {
         size_t bytes_used;
-        
+
         if ((!stream->buf) || (stream->btype == _IONBF) || (stream->error))
                 return;
-        
-        bytes_used = stream->buf_head - stream->buf;
+
+        bytes_used = stream->buf_head - stream->buf_tail;
         if (bytes_used == 0)
                 return;
-        
-        (void) _fwrite(stream->buf, 1, bytes_used, stream);
+
+        /* If buffer has prefetched read data, we need to seek back. */
+        if (stream->buf_state == _bs_read)
+                lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+
+        /* If buffer has unwritten data, we need to write them out. */
+        if (stream->buf_state == _bs_write)
+                (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
+
         stream->buf_head = stream->buf;
-}
+        stream->buf_tail = stream->buf;
+        stream->buf_state = _bs_empty;
+}
+
+/** Read from a stream.
+ *
+ * @param dest   Destination buffer.
+ * @param size   Size of each record.
+ * @param nmemb  Number of records to read.
+ * @param stream Pointer to the stream.
+ *
+ */
+size_t fread(void *dest, size_t size, size_t nmemb, FILE *stream)
+{
+        uint8_t *dp;
+        size_t bytes_left;
+        size_t now;
+        size_t data_avail;
+        size_t total_read;
+        size_t i;
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
+        /* If not buffered stream, read in directly. */
+        if (stream->btype == _IONBF) {
+                now = _fread(dest, size, nmemb, stream);
+                return now;
+        }
+
+        /* Make sure no data is pending write. */
+        if (stream->buf_state == _bs_write)
+                _fflushbuf(stream);
+
+        /* Perform lazy allocation of stream buffer. */
+        if (stream->buf == NULL) {
+                if (_fallocbuf(stream) != 0)
+                        return 0; /* Errno set by _fallocbuf(). */
+        }
+
+        bytes_left = size * nmemb;
+        total_read = 0;
+        dp = (uint8_t *) dest;
+
+        while ((!stream->error) && (!stream->eof) && (bytes_left > 0)) {
+                if (stream->buf_head == stream->buf_tail)
+                        _ffillbuf(stream);
+
+                if (stream->error || stream->eof)
+                        break;
+
+                data_avail = stream->buf_head - stream->buf_tail;
+
+                if (bytes_left > data_avail)
+                        now = data_avail;
+                else
+                        now = bytes_left;
+
+                for (i = 0; i < now; i++) {
+                        dp[i] = stream->buf_tail[i];
+                }
+
+                dp += now;
+                stream->buf_tail += now;
+                bytes_left -= now;
+                total_read += now;
+        }
+
+        return (total_read / size);
+}
+
 
 /** Write to a stream.
@@ -421 +550 @@
         uint8_t b;
         bool need_flush;
-        
+
+        if (size == 0 || nmemb == 0)
+                return 0;
+
         /* If not buffered stream, write out directly. */
         if (stream->btype == _IONBF) {
@@ -428 +560 @@
                 return now;
         }
-        
+
+        /* Make sure buffer contains no prefetched data. */
+        if (stream->buf_state == _bs_read)
+                _fflushbuf(stream);
+
+
         /* Perform lazy allocation of stream buffer. */
         if (stream->buf == NULL) {
@@ -468 +605 @@
         }
         
+        if (total_written > 0)
+                stream->buf_state = _bs_write;
+
         if (need_flush)
                 fflush(stream);
@@ -522 +662 @@
 }
 
+char *fgets(char *str, int size, FILE *stream)
+{
+        int c;
+        int idx;
+
+        idx = 0;
+        while (idx < size - 1) {
+                c = fgetc(stream);
+                if (c == EOF)
+                        break;
+
+                str[idx++] = c;
+
+                if (c == '\n')
+                        break;
+        }
+
+        if (ferror(stream))
+                return NULL;
+
+        if (idx == 0)
+                return NULL;
+
+        str[idx] = '\0';
+        return str;
+}
+
 int getchar(void)
 {
@@ -527 +694 @@
 }
 
-int fseek(FILE *stream, long offset, int origin)
-{
-        off_t rc = lseek(stream->fd, offset, origin);
-        if (rc == (off_t) (-1)) {
-                /* errno has been set by lseek. */
+int fseek(FILE *stream, off64_t offset, int whence)
+{
+        off64_t rc;
+
+        _fflushbuf(stream);
+
+        rc = lseek(stream->fd, offset, whence);
+        if (rc == (off64_t) (-1)) {
+                /* errno has been set by lseek64. */
                 return -1;
         }
-        
+
         stream->eof = false;
-        
         return 0;
+}
+
+off64_t ftell(FILE *stream)
+{
+        return lseek(stream->fd, 0, SEEK_CUR);
 }
 
@@ -554 +729 @@
         }
         
-        if (stream->fd >= 0)
+        if (stream->fd >= 0 && stream->need_sync) {
+                /**
+                 * Better than syncing always, but probably still not the
+                 * right thing to do.
+                 */
+                stream->need_sync = false;
                 return fsync(stream->fd);
+        }
         
         return ENOENT;
@@ -568 +749 @@
 {
         return stream->error;
+}
+
+void clearerr(FILE *stream)
+{
+        stream->eof = false;
+        stream->error = false;
 }
 

uspace/lib/c/generic/io/klog.c

@@ -35 +35 @@
 
 #include <libc.h>
-#include <string.h>
+#include <str.h>
 #include <sys/types.h>
 #include <unistd.h>

uspace/lib/c/generic/io/printf_core.c

@@ -41 +41 @@
 #include <io/printf_core.h>
 #include <ctype.h>
-#include <string.h>
+#include <str.h>
 
 /** show prefixes 0x or 0 */

uspace/lib/c/generic/io/vprintf.c

@@ -39 +39 @@
 #include <futex.h>
 #include <async.h>
-#include <string.h>
+#include <str.h>
 
 static atomic_t printf_futex = FUTEX_INITIALIZER;

uspace/lib/c/generic/io/vsnprintf.c

@@ -35 +35 @@
 #include <stdarg.h>
 #include <stdio.h>
-#include <string.h>
+#include <str.h>
 #include <io/printf_core.h>
 #include <errno.h>

uspace/lib/c/generic/ipc.c

@@ -728 +728 @@
     int *flags)
 {
-        int res;
-        sysarg_t tmp_flags;
-        res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
+        sysarg_t tmp_flags = 0;
+        int res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
             (ipcarg_t) size, arg, NULL, &tmp_flags);
+        
         if (flags)
                 *flags = tmp_flags;
+        
         return res;
 }

uspace/lib/c/generic/loader.c

@@ -38 +38 @@
 #include <libc.h>
 #include <task.h>
-#include <string.h>
+#include <str.h>
 #include <stdlib.h>
 #include <async.h>
@@ -183 +183 @@
  *
  */
-int loader_set_args(loader_t *ldr, char *const argv[])
+int loader_set_args(loader_t *ldr, const char *const argv[])
 {
         /*
@@ -189 +189 @@
          * compute size of the buffer needed.
          */
-        char *const *ap = argv;
+        const char *const *ap = argv;
         size_t buffer_size = 0;
         while (*ap != NULL) {

uspace/lib/c/generic/malloc.c

@@ -164 +164 @@
 {
         if (size == 0)
+                return false;
+
+        if ((heap_start + size < heap_start) || (heap_end + size < heap_end))
                 return false;
         

uspace/lib/c/generic/mman.c

@@ -39 +39 @@
 
 void *mmap(void *start, size_t length, int prot, int flags, int fd,
-    off_t offset)
+    aoff64_t offset)
 {
         if (!start)

uspace/lib/c/generic/str.c

@@ -34 +34 @@
  */
 
-#include <string.h>
+#include <str.h>
 #include <stdlib.h>
 #include <assert.h>
@@ -43 +43 @@
 #include <align.h>
 #include <mem.h>
-#include <string.h>
+#include <str.h>
 
 /** Byte mask consisting of lowest @n bits (out of 8) */
@@ -896 +896 @@
 }
 
+char *str_dup(const char *src)
+{
+        size_t size = str_size(src);
+        void *dest = malloc(size + 1);
+        
+        if (dest == NULL)
+                return (char *) NULL;
+        
+        return (char *) memcpy(dest, src, size + 1);
+}
+
+char *str_ndup(const char *src, size_t max_size)
+{
+        size_t size = str_size(src);
+        if (size > max_size)
+                size = max_size;
+        
+        char *dest = (char *) malloc(size + 1);
+        
+        if (dest == NULL)
+                return (char *) NULL;
+        
+        memcpy(dest, src, size);
+        dest[size] = 0;
+        return dest;
+}
+
 
 /** Convert initial part of string to unsigned long according to given base.
@@ -920 +947 @@
 }
 
-char *str_dup(const char *src)
-{
-        size_t size = str_size(src);
-        void *dest = malloc(size + 1);
-
-        if (dest == NULL)
-                return (char *) NULL;
-
-        return (char *) memcpy(dest, src, size + 1);
-}
-
 char *strtok(char *s, const char *delim)
 {

uspace/lib/c/generic/sysinfo.c

@@ -35 +35 @@
 #include <libc.h>
 #include <sysinfo.h>
-#include <string.h>
+#include <str.h>
 
-sysarg_t sysinfo_value(char *name)
+sysarg_t sysinfo_value(const char *name)
 {
-        return __SYSCALL2(SYS_SYSINFO_VALUE, (sysarg_t ) name,
+        return __SYSCALL2(SYS_SYSINFO_VALUE, (sysarg_t) name,
             (sysarg_t) str_size(name));
 }

uspace/lib/c/generic/task.c

@@ -39 +39 @@
 #include <errno.h>
 #include <loader/loader.h>
-#include <string.h>
+#include <str.h>
 #include <ipc/ns.h>
 #include <macros.h>
@@ -76 +76 @@
  *
  */
-task_id_t task_spawn(const char *path, char *const args[])
+task_id_t task_spawn(const char *path, const char *const args[])
 {
         /* Connect to a program loader. */

uspace/lib/c/generic/thread.c

@@ -39 +39 @@
 #include <kernel/proc/uarg.h>
 #include <fibril.h>
-#include <string.h>
+#include <str.h>
 #include <async.h>
 
@@ -86 +86 @@
  * @return Zero on success or a code from @ref errno.h on failure.
  */
-int thread_create(void (* function)(void *), void *arg, char *name,
+int thread_create(void (* function)(void *), void *arg, const char *name,
     thread_id_t *tid)
 {

uspace/lib/c/generic/time.c

@@ -31 +31 @@
  */
 /** @file
- */ 
+ */
 
 #include <sys/time.h>
@@ -40 +40 @@
 #include <unistd.h>
 #include <atomic.h>
-#include <futex.h>
 #include <sysinfo.h>
 #include <ipc/services.h>
+#include <libc.h>
 
 #include <sysinfo.h>
@@ -189 +189 @@
 
 /** Wait unconditionally for specified number of microseconds */
-int usleep(unsigned long usec)
-{
-        atomic_t futex = FUTEX_INITIALIZER;
-
-        futex_initialize(&futex, 0);
-        futex_down_timeout(&futex, usec, 0);
+int usleep(useconds_t usec)
+{
+        (void) __SYSCALL1(SYS_THREAD_USLEEP, usec);
         return 0;
 }
 
 /** Wait unconditionally for specified number of seconds */
-unsigned int sleep(unsigned int seconds)
-{
-        atomic_t futex = FUTEX_INITIALIZER;
-
-        futex_initialize(&futex, 0);
-        
+unsigned int sleep(unsigned int sec)
+{
         /* Sleep in 1000 second steps to support
            full argument range */
-        while (seconds > 0) {
-                unsigned int period = (seconds > 1000) ? 1000 : seconds;
+        while (sec > 0) {
+                unsigned int period = (sec > 1000) ? 1000 : sec;
         
-                futex_down_timeout(&futex, period * 1000000, 0);
-                seconds -= period;
+                usleep(period * 1000000);
+                sec -= period;
         }
         return 0;

uspace/lib/c/generic/tls.c

@@ -40 +40 @@
 #include <tls.h>
 #include <malloc.h>
-#include <string.h>
+#include <str.h>
 #include <align.h>
 

uspace/lib/c/generic/udebug.c

@@ -69 +69 @@
 }
 
+int udebug_name_read(int phoneid, void *buffer, size_t n,
+        size_t *copied, size_t *needed)
+{
+        ipcarg_t a_copied, a_needed;
+        int rc;
+
+        rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_NAME_READ,
+                (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
+
+        *copied = (size_t)a_copied;
+        *needed = (size_t)a_needed;
+
+        return rc;
+}
+
+int udebug_areas_read(int phoneid, void *buffer, size_t n,
+        size_t *copied, size_t *needed)
+{
+        ipcarg_t a_copied, a_needed;
+        int rc;
+
+        rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_AREAS_READ,
+                (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
+
+        *copied = (size_t)a_copied;
+        *needed = (size_t)a_needed;
+
+        return rc;
+}
+
 int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n)
 {
@@ -78 +108 @@
 {
         return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_ARGS_READ,
+            tid, (sysarg_t)buffer);
+}
+
+int udebug_regs_read(int phoneid, thash_t tid, void *buffer)
+{
+        return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_REGS_READ,
             tid, (sysarg_t)buffer);
 }

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

@@ -35 +35 @@
 #include <vfs/vfs.h>
 #include <vfs/canonify.h>
+#include <macros.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -48 +49 @@
 #include <futex.h>
 #include <errno.h>
-#include <string.h>
+#include <str.h>
 #include <devmap.h>
 #include <ipc/vfs.h>
@@ -117 +118 @@
 }
 
-int mount(const char *fs_name, const char *mp, const char *dev,
+int mount(const char *fs_name, const char *mp, const char *fqdn,
     const char *opts, unsigned int flags)
 {
-        int res;
+        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;
+        }
+        
+        dev_handle_t dev_handle;
+        int res = devmap_device_get_handle(fqdn, &dev_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;
+        }
+        
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        
+        ipcarg_t rc_orig;
+        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
+        ipcarg_t rc = async_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);
+                free(mpa);
+                
+                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) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                free(mpa);
+                
+                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) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                free(mpa);
+                
+                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) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                free(mpa);
+                
+                if (null_id != -1)
+                        devmap_null_destroy(null_id);
+                
+                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(mpa);
+        
+        if ((rc != EOK) && (null_id != -1))
+                devmap_null_destroy(null_id);
+        
+        return (int) rc;
+}
+
+int unmount(const char *mp)
+{
         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)
-                return res;
-        
         size_t mpa_size;
-        char *mpa = absolutize(mp, &mpa_size);
+        char *mpa;
+        
+        mpa = absolutize(mp, &mpa_size);
         if (!mpa)
                 return ENOMEM;
@@ -139 +252 @@
         vfs_connect();
         
-        req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
+        req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
         rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
@@ -152 +265 @@
         }
         
-        rc = async_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 = async_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();
@@ -358 +435 @@
 }
 
-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);
-
+off64_t lseek(int fildes, off64_t offset, int whence)
+{
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        
+        ipcarg_t newoff_lo;
+        ipcarg_t newoff_hi;
+        ipcarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes,
+            LOWER32(offset), UPPER32(offset), whence,
+            &newoff_lo, &newoff_hi);
+        
+        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 (off64_t) -1;
+        
+        return (off64_t) MERGE_LOUP32(newoff_lo, newoff_hi);
+}
+
+int ftruncate(int fildes, aoff64_t length)
+{
+        ipcarg_t rc;
+        
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        
+        rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes,
+            LOWER32(length), UPPER32(length));
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        
         return (int) rc;
 }
@@ -403 +482 @@
         
         req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
-        rc = async_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
+        rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
         if (rc != EOK) {
                 ipcarg_t rc_orig;
@@ -477 +556 @@
         if (!abs) {
                 free(dirp);
-                return ENOMEM;
+                return NULL;
         }
         
@@ -703 +782 @@
         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);
 }