Changeset c47e1a8 in mainline for uspace/lib/c/generic

Timestamp:

2010-05-21T07:50:04Z (16 years ago)

Author:

Lenka Trochtova <trochtova.lenka@…>

Branches:

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

Children:

d51ee2b

Parents:

cf8cc36 (diff), 15b592b (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 (rev. 451)

Location:

uspace/lib/c/generic

Files:

• adt/hash_table.c (moved) (moved from uspace/lib/libc/generic/adt/hash_table.c ) (11 diffs)
• adt/list.c (moved) (moved from uspace/lib/libc/generic/adt/list.c )
• arg_parse.c (added)
• as.c (moved) (moved from uspace/lib/libc/generic/as.c )
• async.c (moved) (moved from uspace/lib/libc/generic/async.c ) (11 diffs)
• cap.c (moved) (moved from uspace/lib/libc/generic/cap.c )
• clipboard.c (moved) (moved from uspace/lib/libc/generic/clipboard.c ) (2 diffs)
• ddi.c (moved) (moved from uspace/lib/libc/generic/ddi.c )
• device/char.c (moved) (moved from uspace/lib/libc/generic/device/char.c ) (2 diffs)
• device/hw_res.c (moved) (moved from uspace/lib/libc/generic/device/hw_res.c )
• devman.c (moved) (moved from uspace/lib/libc/generic/devman.c ) (1 diff)
• devmap.c (moved) (moved from uspace/lib/libc/generic/devmap.c ) (1 diff)
• 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 ) (15 diffs)
• fibril_synch.c (moved) (moved from uspace/lib/libc/generic/fibril_synch.c )
• futex.c (moved) (moved from uspace/lib/libc/generic/futex.c ) (5 diffs)
• 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 ) (2 diffs)
• io/console.c (moved) (moved from uspace/lib/libc/generic/io/console.c ) (3 diffs)
• io/io.c (moved) (moved from uspace/lib/libc/generic/io/io.c ) (20 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 ) (10 diffs)
• io/screenbuffer.c (moved) (moved from uspace/srv/hid/console/screenbuffer.c ) (6 diffs)
• 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 ) (2 diffs)
• 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 ) (3 diffs)
• loader.c (moved) (moved from uspace/lib/libc/generic/loader.c ) (3 diffs)
• malloc.c (moved) (moved from uspace/lib/libc/generic/malloc.c ) (19 diffs)
• 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 (moved) (moved from uspace/lib/libc/generic/stacktrace.c )
• stats.c (added)
• stdlib.c (moved) (moved from uspace/lib/libc/generic/stdlib.c )
• str.c (moved) (moved from uspace/lib/libc/generic/string.c ) (7 diffs)
• str_error.c (added)
• sysinfo.c (added)
• task.c (moved) (moved from uspace/lib/libc/generic/task.c ) (4 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 )
• tls.c (moved) (moved from uspace/lib/libc/generic/tls.c ) (1 diff)
• udebug.c (moved) (moved from uspace/lib/libc/generic/udebug.c )
• 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 ) (5 diffs)

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

@@ -42 +42 @@
 #include <malloc.h>
 #include <assert.h>
-#include <stdio.h>
-#include <string.h>
+#include <str.h>
 
 /** Create chained hash table.
  *
- * @param h             Hash table structure. Will be initialized by this call.
- * @param m             Number of hash table buckets.
- * @param max_keys      Maximal number of keys needed to identify an item.
- * @param op            Hash table operations structure.
- * @return              True on success
+ * @param h        Hash table structure. Will be initialized by this call.
+ * @param m        Number of hash table buckets.
+ * @param max_keys Maximal number of keys needed to identify an item.
+ * @param op       Hash table operations structure.
+ *
+ * @return True on success
+ *
  */
 int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {
-        hash_count_t i;
-
         assert(h);
         assert(op && op->hash && op->compare);
@@ -63 +62 @@
         
         h->entry = malloc(m * sizeof(link_t));
-        if (!h->entry) {
-                printf("cannot allocate memory for hash table\n");
+        if (!h->entry)
                 return false;
-        }
+        
         memset((void *) h->entry, 0,  m * sizeof(link_t));
         
+        hash_count_t i;
         for (i = 0; i < m; i++)
                 list_initialize(&h->entry[i]);
@@ -75 +74 @@
         h->max_keys = max_keys;
         h->op = op;
+        
         return true;
 }
@@ -80 +80 @@
 /** Destroy a hash table instance.
  *
- * @param h             Hash table to be destroyed.
+ * @param h Hash table to be destroyed.
+ *
  */
 void hash_table_destroy(hash_table_t *h)
@@ -86 +87 @@
         assert(h);
         assert(h->entry);
+        
         free(h->entry);
 }
@@ -91 +93 @@
 /** Insert item into a hash table.
  *
- * @param h             Hash table.
- * @param key           Array of all keys necessary to compute hash index.
- * @param item          Item to be inserted into the hash table.
+ * @param h    Hash table.
+ * @param key  Array of all keys necessary to compute hash index.
+ * @param item Item to be inserted into the hash table.
  */
 void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item)
 {
-        hash_index_t chain;
-
         assert(item);
         assert(h && h->op && h->op->hash && h->op->compare);
-
-        chain = h->op->hash(key);
+        
+        hash_index_t chain = h->op->hash(key);
         assert(chain < h->entries);
         
@@ -110 +110 @@
 /** Search hash table for an item matching keys.
  *
- * @param h             Hash table.
- * @param key           Array of all keys needed to compute hash index.
- *
- * @return              Matching item on success, NULL if there is no such item.
+ * @param h   Hash table.
+ * @param key Array of all keys needed to compute hash index.
+ *
+ * @return Matching item on success, NULL if there is no such item.
+ *
  */
 link_t *hash_table_find(hash_table_t *h, unsigned long key[])
 {
+        assert(h && h->op && h->op->hash && h->op->compare);
+        
+        hash_index_t chain = h->op->hash(key);
+        assert(chain < h->entries);
+        
         link_t *cur;
-        hash_index_t chain;
-
-        assert(h && h->op && h->op->hash && h->op->compare);
-
-        chain = h->op->hash(key);
-        assert(chain < h->entries);
-        
         for (cur = h->entry[chain].next; cur != &h->entry[chain];
             cur = cur->next) {
@@ -142 +141 @@
  * For each removed item, h->remove_callback() is called.
  *
- * @param h             Hash table.
- * @param key           Array of keys that will be compared against items of
- *                      the hash table.
- * @param keys          Number of keys in the 'key' array.
+ * @param h    Hash table.
+ * @param key  Array of keys that will be compared against items of
+ *             the hash table.
+ * @param keys Number of keys in the 'key' array.
+ *
  */
 void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys)
 {
-        hash_index_t chain;
-        link_t *cur;
-
         assert(h && h->op && h->op->hash && h->op->compare &&
             h->op->remove_callback);
         assert(keys <= h->max_keys);
         
+        link_t *cur;
+        
         if (keys == h->max_keys) {
-
                 /*
                  * All keys are known, hash_table_find() can be used to find the
                  * entry.
                  */
-        
+                
                 cur = hash_table_find(h, key);
                 if (cur) {
@@ -168 +166 @@
                         h->op->remove_callback(cur);
                 }
+                
                 return;
         }
@@ -175 +174 @@
          * Any partially matching entries are to be removed.
          */
+        hash_index_t chain;
         for (chain = 0; chain < h->entries; chain++) {
                 for (cur = h->entry[chain].next; cur != &h->entry[chain];
@@ -195 +195 @@
 /** 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)
+ * @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];

uspace/lib/c/generic/async.c

@@ -746 +746 @@
         if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,
             &conn_hash_table_ops)) {
-                printf("%s: cannot create hash table\n", "async");
+                printf("%s: Cannot create async hash table\n", "libc");
                 return ENOMEM;
         }
@@ -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.
  *
@@ -1310 +1364 @@
             IPC_FF_ROUTE_FROM_ME);
         if (retval != EOK) {
+                async_wait_for(msg, NULL);
                 ipc_answer_0(callid, retval);
                 return retval;
@@ -1383 +1438 @@
 }
 
-/** Wrapper for receiving binary data
+/** Wrapper for receiving binary data or strings
  *
  * This wrapper only makes it more comfortable to use async_data_write_*
- * functions to receive binary data.
+ * 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
+ * @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.
@@ -1401 +1459 @@
  *
  */
-int async_data_receive(void **data, const size_t min_size,
-    const size_t max_size, const size_t granularity, size_t *received)
+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;
@@ -1426 +1485 @@
         }
         
-        void *_data = malloc(size);
+        void *_data;
+        
+        if (nullterm)
+                _data = malloc(size + 1);
+        else
+                _data = malloc(size);
+        
         if (_data == NULL) {
                 ipc_answer_0(callid, ENOMEM);
@@ -1438 +1503 @@
         }
         
+        if (nullterm)
+                ((char *) _data)[size] = 0;
+        
         *data = _data;
         if (received != NULL)
@@ -1445 +1513 @@
 }
 
-/** Wrapper for receiving strings
- *
- * This wrapper only makes it more comfortable to use async_data_write_*
- * functions to receive strings.
- *
- * @param str      Pointer to string pointer (which should be later disposed
- *                 by free()). If the operation fails, the pointer is not
- *                 touched.
- * @param max_size Maximum size (in bytes) of the string to receive. 0 means
- *                 no limit.
- * @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_string_receive(char **str, const size_t max_size, 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 ((max_size > 0) && (size > max_size)) {
-                ipc_answer_0(callid, EINVAL);
-                return EINVAL;
-        }
-        
-        char *data = (char *) malloc(size + 1);
-        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;
-        }
-        
-        data[size] = 0;
-        *str = data;
-        if (received != NULL)
-                *received = size;
-        
-        return EOK;
-}
-
 /** Wrapper for voiding any data that is about to be received
  *
@@ -1501 +1520 @@
  *
  */
-void async_data_void(const int retval)
+void async_data_write_void(const int retval)
 {
         ipc_callid_t callid;
@@ -1512 +1531 @@
  *
  */
-int async_data_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
+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)
 {
@@ -1531 +1550 @@
             IPC_FF_ROUTE_FROM_ME);
         if (retval != EOK) {
+                async_wait_for(msg, NULL);
                 ipc_answer_0(callid, retval);
                 return retval;

uspace/lib/c/generic/clipboard.c

@@ -42 +42 @@
 #include <ipc/clipboard.h>
 #include <async.h>
-#include <string.h>
+#include <str.h>
 #include <errno.h>
 #include <malloc.h>
@@ -148 +148 @@
                         aid_t req = async_send_1(clip_phone, CLIPBOARD_GET_DATA, tag, NULL);
                         rc = async_data_read_start(clip_phone, (void *) sbuf, size);
-                        if (rc == EOVERFLOW) {
+                        if ((int) rc == EOVERFLOW) {
                                 /*
                                  * The data in the clipboard has changed since

uspace/lib/c/generic/device/char.c

@@ -60 +60 @@
         
         aid_t req;
-        int rc;
+        int ret;
         
         if (read) {
                 req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_READ_DEV, &answer);
-                rc = async_data_read_start(dev_phone, buf, len);                
+                ret = async_data_read_start(dev_phone, buf, len);               
         } else {
                 req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_WRITE_DEV, &answer);
-                rc = async_data_write_start(dev_phone, buf, len);
+                ret = async_data_write_start(dev_phone, buf, len);
         }
         
-        if (rc != EOK) {
-                ipcarg_t rc_orig;
-                async_wait_for(req, &rc_orig);
+        ipcarg_t rc;
+        if (ret != EOK) {               
+                async_wait_for(req, &rc);
                 async_serialize_end();
-                if (rc_orig == EOK) {
-                        return rc;
+                if (rc == EOK) {
+                        return ret;
                 }
                 else {
-                        return (int) rc_orig;
+                        return (int) rc;
                 }
         }
@@ -85 +85 @@
         async_serialize_end();
         
-        if (EOK != rc) {
-                return rc;
+        ret = (int)rc;
+        if (EOK != ret) {
+                return ret;
         }
         

uspace/lib/c/generic/devman.c

@@ -35 +35 @@
  */
 
-#include <string.h>
+#include <str.h>
 #include <stdio.h>
 #include <ipc/ipc.h>

uspace/lib/c/generic/devmap.c

@@ -28 +28 @@
  */
 
-#include <string.h>
+#include <str.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>

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>
@@ -47 +48 @@
 
 #ifndef FIBRIL_INITIAL_STACK_PAGES_NO
-#define FIBRIL_INITIAL_STACK_PAGES_NO   1
+        #define FIBRIL_INITIAL_STACK_PAGES_NO  1
 #endif
 
 /**
- * This futex serializes access to ready_list, serialized_list and manager_list.
- */ 
+ * This futex serializes access to ready_list,
+ * serialized_list and manager_list.
+ */
 static atomic_t fibril_futex = FUTEX_INITIALIZER;
 
@@ -59 +61 @@
 static LIST_INITIALIZE(manager_list);
 
-static void fibril_main(void);
-
 /** Number of threads that are executing a manager fibril. */
 static int threads_in_manager;
-/** Number of threads that are executing a manager fibril and are serialized. */
-static int serialized_threads;  /* Protected by async_futex */
+
+/**
+ * Number of threads that are executing a manager fibril
+ * and are serialized. Protected by async_futex.
+ */
+static int serialized_threads;
+
 /** Fibril-local count of serialization. If > 0, we must not preempt */
 static fibril_local int serialization_count;
-
-/** Setup fibril information into TCB structure */
-fibril_t *fibril_setup(void)
-{
-        fibril_t *f;
-        tcb_t *tcb;
-
-        tcb = __make_tls();
-        if (!tcb)
-                return NULL;
-
-        f = malloc(sizeof(fibril_t));
-        if (!f) {
-                __free_tls(tcb);
-                return NULL;
-        }
-
-        tcb->fibril_data = f;
-        f->tcb = tcb;
-
-        f->func = NULL;
-        f->arg = NULL;
-        f->stack = NULL;
-        f->clean_after_me = NULL;
-        f->retval = 0;
-        f->flags = 0;
-
-        return f;
-}
-
-void fibril_teardown(fibril_t *f)
-{
-        __free_tls(f->tcb);
-        free(f);
-}
 
 /** Function that spans the whole life-cycle of a fibril.
@@ -108 +78 @@
  * the fibril logic is called.  After its return, the return value is saved.
  * The fibril then switches to another fibril, which cleans up after it.
- */
-void fibril_main(void)
-{
-        fibril_t *f = __tcb_get()->fibril_data;
-
+ *
+ */
+static void fibril_main(void)
+{
+        fibril_t *fibril = __tcb_get()->fibril_data;
+        
         /* Call the implementing function. */
-        f->retval = f->func(f->arg);
-
+        fibril->retval = fibril->func(fibril->arg);
+        
         fibril_switch(FIBRIL_FROM_DEAD);
-        /* not reached */
+        /* Not reached */
+}
+
+/** Setup fibril information into TCB structure
+ *
+ */
+fibril_t *fibril_setup(void)
+{
+        tcb_t *tcb = __make_tls();
+        if (!tcb)
+                return NULL;
+        
+        fibril_t *fibril = malloc(sizeof(fibril_t));
+        if (!fibril) {
+                __free_tls(tcb);
+                return NULL;
+        }
+        
+        tcb->fibril_data = fibril;
+        fibril->tcb = tcb;
+        
+        fibril->func = NULL;
+        fibril->arg = NULL;
+        fibril->stack = NULL;
+        fibril->clean_after_me = NULL;
+        fibril->retval = 0;
+        fibril->flags = 0;
+        
+        return fibril;
+}
+
+void fibril_teardown(fibril_t *fibril)
+{
+        __free_tls(fibril->tcb);
+        free(fibril);
 }
 
@@ -125 +130 @@
  * held.
  *
- * @param stype         Switch type. One of FIBRIL_PREEMPT, FIBRIL_TO_MANAGER,
- *                      FIBRIL_FROM_MANAGER, FIBRIL_FROM_DEAD. The parameter
- *                      describes the circumstances of the switch.
- * @return              Return 0 if there is no ready fibril,
- *                      return 1 otherwise.
+ * @param stype Switch type. One of FIBRIL_PREEMPT, FIBRIL_TO_MANAGER,
+ *              FIBRIL_FROM_MANAGER, FIBRIL_FROM_DEAD. The parameter
+ *              describes the circumstances of the switch.
+ *
+ * @return 0 if there is no ready fibril,
+ * @return 1 otherwise.
+ *
  */
 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 +170 @@
         }
         
-        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 +183 @@
                                  * restored context here.
                                  */
-                                void *stack = srcf->clean_after_me->stack; 
+                                void *stack = srcf->clean_after_me->stack;
                                 if (stack) {
                                         /*
@@ -188 +198 @@
                                 srcf->clean_after_me = NULL;
                         }
+                        
                         return 1;       /* futex_up already done here */
                 }
-
+                
                 /* Save myself to the correct run list */
                 if (stype == FIBRIL_PREEMPT)
@@ -197 +208 @@
                         list_append(&srcf->link, &manager_list);
                         threads_in_manager--;
-                } else {        
+                } else {
                         /*
                          * If stype == FIBRIL_TO_MANAGER, don't put ourselves to
@@ -207 +218 @@
         
         /* 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 +226 @@
                 }
                 threads_in_manager++;
-
+                
                 if (stype == FIBRIL_FROM_DEAD) 
                         dstf->clean_after_me = srcf;
@@ -228 +240 @@
         }
         list_remove(&dstf->link);
-
+        
         futex_up(&fibril_futex);
         context_restore(&dstf->ctx);
         /* not reached */
-
+        
 ret_0:
         futex_up(&fibril_futex);
@@ -240 +252 @@
 /** Create a new fibril.
  *
- * @param func          Implementing function of the new fibril.
- * @param arg           Argument to pass to func.
- *
- * @return              Return 0 on failure or TLS of the new fibril.
+ * @param func Implementing function of the new fibril.
+ * @param arg Argument to pass to func.
+ *
+ * @return 0 on failure or TLS of the new fibril.
+ *
  */
 fid_t fibril_create(int (*func)(void *), void *arg)
 {
-        fibril_t *f;
-
-        f = fibril_setup();
-        if (!f) 
+        fibril_t *fibril;
+        
+        fibril = fibril_setup();
+        if (fibril == NULL)
                 return 0;
-        f->stack = (char *) malloc(FIBRIL_INITIAL_STACK_PAGES_NO *
-            getpagesize());
-        if (!f->stack) {
-                fibril_teardown(f);
+        
+        fibril->stack =
+            (char *) malloc(FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize());
+        if (!fibril->stack) {
+                fibril_teardown(fibril);
                 return 0;
         }
         
-        f->func = func;
-        f->arg = arg;
-
-        context_save(&f->ctx);
-        context_set(&f->ctx, FADDR(fibril_main), f->stack,
-            FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize(), f->tcb);
-
-        return (fid_t) f;
+        fibril->func = func;
+        fibril->arg = arg;
+        
+        context_save(&fibril->ctx);
+        context_set(&fibril->ctx, FADDR(fibril_main), fibril->stack,
+            FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize(), fibril->tcb);
+
+        return (fid_t) fibril;
 }
 
 /** Add a fibril to the ready list.
  *
- * @param fid           Pointer to the fibril structure of the fibril to be
- *                      added.
+ * @param fid Pointer to the fibril structure of the fibril to be
+ *            added.
+ *
  */
 void fibril_add_ready(fid_t fid)
 {
-        fibril_t *f;
-
-        f = (fibril_t *) fid;
+        fibril_t *fibril = (fibril_t *) fid;
+        
         futex_down(&fibril_futex);
-        if ((f->flags & FIBRIL_SERIALIZED))
-                list_append(&f->link, &serialized_list);
+        
+        if ((fibril->flags & FIBRIL_SERIALIZED))
+                list_append(&fibril->link, &serialized_list);
         else
-                list_append(&f->link, &ready_list);
+                list_append(&fibril->link, &ready_list);
+        
         futex_up(&fibril_futex);
 }
@@ -289 +305 @@
 /** Add a fibril to the manager list.
  *
- * @param fid           Pointer to the fibril structure of the fibril to be
- *                      added.
+ * @param fid Pointer to the fibril structure of the fibril to be
+ *            added.
+ *
  */
 void fibril_add_manager(fid_t fid)
 {
-        fibril_t *f;
-
-        f = (fibril_t *) fid;
-
+        fibril_t *fibril = (fibril_t *) fid;
+        
         futex_down(&fibril_futex);
-        list_append(&f->link, &manager_list);
+        list_append(&fibril->link, &manager_list);
         futex_up(&fibril_futex);
 }
@@ -307 +322 @@
 {
         futex_down(&fibril_futex);
-        if (list_empty(&manager_list)) {
-                futex_up(&fibril_futex);
-                return;
-        }
-        list_remove(manager_list.next);
+        
+        if (!list_empty(&manager_list))
+                list_remove(manager_list.next);
+        
         futex_up(&fibril_futex);
 }

uspace/lib/c/generic/futex.c

@@ -31 +31 @@
  */
 /** @file
- */ 
+ */
 
 #include <futex.h>
@@ -40 +40 @@
 /** Initialize futex counter.
  *
- * @param futex         Futex.
- * @param val           Initialization value.
+ * @param futex Futex.
+ * @param val   Initialization value.
+ *
  */
 void futex_initialize(futex_t *futex, int val)
@@ -50 +51 @@
 /** Try to down the futex.
  *
- * @param futex         Futex.
- * @return              Non-zero if the futex was acquired.
- * @return              Zero if the futex was not acquired.
+ * @param futex Futex.
+ *
+ * @return Non-zero if the futex was acquired.
+ * @return Zero if the futex was not acquired.
+ *
  */
 int futex_trydown(futex_t *futex)
@@ -61 +64 @@
 /** Down the futex.
  *
- * @param futex         Futex.
- * @return              ENOENT if there is no such virtual address.
- * @return              Zero in the uncontended case. 
- * @return              Otherwise one of ESYNCH_OK_ATOMIC or ESYNCH_OK_BLOCKED.
+ * @param futex Futex.
+ *
+ * @return ENOENT if there is no such virtual address.
+ * @return Zero in the uncontended case.
+ * @return Otherwise one of ESYNCH_OK_ATOMIC or ESYNCH_OK_BLOCKED.
+ *
  */
 int futex_down(futex_t *futex)
 {
-        if (atomic_predec(futex) < 0)
+        if ((atomic_signed_t) atomic_predec(futex) < 0)
                 return __SYSCALL1(SYS_FUTEX_SLEEP, (sysarg_t) &futex->count);
-
+        
         return 0;
 }
@@ -76 +81 @@
 /** Up the futex.
  *
- * @param futex         Futex.
- * @return              ENOENT if there is no such virtual address.
- * @return              Zero in the uncontended case.
+ * @param futex Futex.
+ *
+ * @return ENOENT if there is no such virtual address.
+ * @return Zero in the uncontended case.
+ *
  */
 int futex_up(futex_t *futex)
 {
-        if (atomic_postinc(futex) < 0)
+        if ((atomic_signed_t) atomic_postinc(futex) < 0)
                 return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->count);
-                
+        
         return 0;
 }

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>
 
@@ -61 +61 @@
 int asprintf(char **strp, const char *fmt, ...)
 {
-        struct printf_spec ps = {
+        printf_spec_t ps = {
                 asprintf_str_write,
                 asprintf_wstr_write,

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

@@ -45 +45 @@
 }
 
-int console_get_size(int phone, int *cols, int *rows)
+int console_get_size(int phone, ipcarg_t *cols, ipcarg_t *rows)
 {
-        ipcarg_t cols_v;
-        ipcarg_t rows_v;
-        int rc;
-
-        rc = async_req_0_2(phone, CONSOLE_GET_SIZE, &cols_v, &rows_v);
-
-        *cols = (int) cols_v;
-        *rows = (int) rows_v;
-        return rc;
+        return async_req_0_2(phone, CONSOLE_GET_SIZE, cols, rows);
 }
 
-void console_set_style(int phone, int style)
+void console_set_style(int phone, uint8_t style)
 {
         async_msg_1(phone, CONSOLE_SET_STYLE, style);
 }
 
-void console_set_color(int phone, int fg_color, int bg_color, int flags)
+void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color,
+    uint8_t flags)
 {
         async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
 }
 
-void console_set_rgb_color(int phone, int fg_color, int bg_color)
+void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color)
 {
         async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
@@ -75 +68 @@
 void console_cursor_visibility(int phone, bool show)
 {
-        async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, show != false);
+        async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, (show != false));
 }
 
-int console_get_color_cap(int phone, int *ccap)
+int console_get_color_cap(int phone, ipcarg_t *ccap)
 {
-        ipcarg_t ccap_tmp;
-        int rc;
-
-        rc = async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, &ccap_tmp);
-        *ccap = ccap_tmp;
-
-        return rc;
+        return async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, ccap);
 }
 
@@ -94 +81 @@
 }
 
-int console_get_pos(int phone, int *col, int *row)
+int console_get_pos(int phone, ipcarg_t *col, ipcarg_t *row)
 {
-        ipcarg_t col_v;
-        ipcarg_t row_v;
-        int rc;
-
-        rc = async_req_0_2(phone, CONSOLE_GET_POS, &col_v, &row_v);
-
-        *col = (int) col_v;
-        *row = (int) row_v;
-        return rc;
+        return async_req_0_2(phone, CONSOLE_GET_POS, col, row);
 }
 
-void console_goto(int phone, int col, int row)
+void console_set_pos(int phone, ipcarg_t col, ipcarg_t row)
 {
         async_msg_2(phone, CONSOLE_GOTO, col, row);

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)
+ */
+static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
 {
         size_t left, done;
@@ -345 +357 @@
         if (size == 0 || nmemb == 0)
                 return 0;
-
-        /* Make sure no data is pending write. */
-        _fflushbuf(stream);
 
         left = size * nmemb;
@@ -368 +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)
 {
@@ -394 +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.
@@ -442 +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) {
@@ -482 +605 @@
         }
         
+        if (total_written > 0)
+                stream->buf_state = _bs_write;
+
         if (need_flush)
                 fflush(stream);
@@ -536 +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)
 {
@@ -541 +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;
 }
 
-int ftell(FILE *stream)
-{
-        off_t rc = lseek(stream->fd, 0, SEEK_CUR);
-        if (rc == (off_t) (-1)) {
-                /* errno has been set by lseek. */
-                return -1;
-        }
-
-        return rc;
+off64_t ftell(FILE *stream)
+{
+        return lseek(stream->fd, 0, SEEK_CUR);
 }
 
@@ -579 +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;

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 */
 #define __PRINTF_FLAG_PREFIX       0x00000001
+
 /** signed / unsigned number */
 #define __PRINTF_FLAG_SIGNED       0x00000002
+
 /** print leading zeroes */
 #define __PRINTF_FLAG_ZEROPADDED   0x00000004
+
 /** align to left */
 #define __PRINTF_FLAG_LEFTALIGNED  0x00000010
+
 /** always show + sign */
 #define __PRINTF_FLAG_SHOWPLUS     0x00000020
+
 /** print space instead of plus */
 #define __PRINTF_FLAG_SPACESIGN    0x00000040
+
 /** show big characters */
 #define __PRINTF_FLAG_BIGCHARS     0x00000080
+
 /** number has - sign */
 #define __PRINTF_FLAG_NEGATIVE     0x00000100
@@ -78 +85 @@
 } qualifier_t;
 
-static char nullstr[] = "(NULL)";
-static char digits_small[] = "0123456789abcdef";
-static char digits_big[] = "0123456789ABCDEF";
-static char invalch = U_SPECIAL;
+static const char *nullstr = "(NULL)";
+static const char *digits_small = "0123456789abcdef";
+static const char *digits_big = "0123456789ABCDEF";
+static const char invalch = U_SPECIAL;
 
 /** Print one or more characters without adding newline.
@@ -253 +260 @@
         if (str == NULL)
                 return printf_putstr(nullstr, ps);
-
+        
         /* Print leading spaces. */
         size_t strw = str_length(str);
         if (precision == 0)
                 precision = strw;
-
+        
         /* Left padding */
         size_t counter = 0;
@@ -268 +275 @@
                 }
         }
-
+        
         /* Part of @a str fitting into the alloted space. */
         int retval;
@@ -350 +357 @@
     uint32_t flags, printf_spec_t *ps)
 {
-        char *digits;
+        const char *digits;
         if (flags & __PRINTF_FLAG_BIGCHARS)
                 digits = digits_big;
@@ -383 +390 @@
          */
         if (flags & __PRINTF_FLAG_PREFIX) {
-                switch(base) {
+                switch (base) {
                 case 2:
                         /* Binary formating is not standard, but usefull */
@@ -447 +454 @@
         /* Print prefix */
         if (flags & __PRINTF_FLAG_PREFIX) {
-                switch(base) {
+                switch (base) {
                 case 2:
                         /* Binary formating is not standard, but usefull */
@@ -562 +569 @@
  *
  *  - P, p Print value of a pointer. Void * value is expected and it is
- *         printed in hexadecimal notation with prefix (as with \%#X / \%#x
- *         for 32-bit or \%#X / \%#x for 64-bit long pointers).
+ *         printed in hexadecimal notation with prefix (as with
+ *         \%#0.8X / \%#0.8x for 32-bit or \%#0.16lX / \%#0.16lx for 64-bit
+ *         long pointers).
  *
  *  - b Print value as unsigned binary number. Prefix is not printed by
@@ -776 +784 @@
                         case 'p':
                                 flags |= __PRINTF_FLAG_PREFIX;
+                                flags |= __PRINTF_FLAG_ZEROPADDED;
                                 base = 16;
                                 qualifier = PrintfQualifierPointer;
@@ -838 +847 @@
                         case PrintfQualifierPointer:
                                 size = sizeof(void *);
-                                number = (uint64_t) (unsigned long) va_arg(ap, void *);
+                                precision = size << 1;
+                                number = (uint64_t) (uintptr_t) va_arg(ap, void *);
                                 break;
                         default:

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

@@ -34 +34 @@
 
 #include <io/style.h>
+#include <io/screenbuffer.h>
 #include <malloc.h>
 #include <unistd.h>
-#include "screenbuffer.h"
 
 /** Store one character to screenbuffer.
@@ -67 +67 @@
  *
  */
-screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, size_t size_x, size_t size_y)
+screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, ipcarg_t size_x,
+    ipcarg_t size_y)
 {
         scr->buffer = (keyfield_t *) malloc(sizeof(keyfield_t) * size_x * size_y);
@@ -109 +110 @@
  *
  */
-void screenbuffer_clear_line(screenbuffer_t *scr, size_t line)
+void screenbuffer_clear_line(screenbuffer_t *scr, ipcarg_t line)
 {
-        size_t x;
+        ipcarg_t x;
         
         for (x = 0; x < scr->size_x; x++) {
@@ -140 +141 @@
  *
  */
-void screenbuffer_goto(screenbuffer_t *scr, size_t x, size_t y)
+void screenbuffer_goto(screenbuffer_t *scr, ipcarg_t x, ipcarg_t y)
 {
         scr->position_x = x % scr->size_x;
@@ -166 +167 @@
  *
  */
-void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color, uint8_t bg_color, uint8_t flags)
+void screenbuffer_set_color(screenbuffer_t *scr, uint8_t fg_color,
+    uint8_t bg_color, uint8_t flags)
 {
         scr->attrs.t = at_idx;
@@ -181 +183 @@
  *
  */
-void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color, uint32_t bg_color)
+void screenbuffer_set_rgb_color(screenbuffer_t *scr, uint32_t fg_color,
+    uint32_t bg_color)
 {
         scr->attrs.t = at_rgb;

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;
@@ -76 +76 @@
 int vfprintf(FILE *stream, const char *fmt, va_list ap)
 {
-        struct printf_spec ps = {
+        printf_spec_t ps = {
                 vprintf_str_write,
                 vprintf_wstr_write,

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/libc.c

@@ -62 +62 @@
 void __main(void *pcb_ptr)
 {
-        int retval;
-
+        /* Initialize user task run-time environment */
         __heap_init();
         __async_init();
@@ -75 +74 @@
         char **argv;
         
+        /* Get command line arguments and initialize
+           standard input and output */
         if (__pcb == NULL) {
                 argc = 0;
@@ -86 +87 @@
         }
         
-        retval = main(argc, argv);
-
-        __stdio_done();
-        (void) task_retval(retval);
+        /* Run main() and set task return value
+           according the result */
+        (void) task_retval(main(argc, argv));
 }
 
 void __exit(void)
 {
+        __stdio_done();
         fibril_teardown(__tcb_get()->fibril_data);
         _exit(0);

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

@@ -43 +43 @@
 #include <bitops.h>
 #include <mem.h>
+#include <futex.h>
 #include <adt/gcdlcm.h>
 
@@ -75 +76 @@
 #define NET_SIZE(size)  ((size) - STRUCT_OVERHEAD)
 
-
 /** Header of a heap block
  *
@@ -104 +104 @@
 extern char _heap;
 
+/** Futex for thread-safe heap manipulation */
+static futex_t malloc_futex = FUTEX_INITIALIZER;
+
 /** Address of heap start */
 static void *heap_start = 0;
@@ -119 +122 @@
  *
  * Fills in the structures related to a heap block.
+ * Should be called only inside the critical section.
  *
  * @param addr Address of the block.
@@ -144 +148 @@
  * Verifies that the structures related to a heap block still contain
  * the magic constants. This helps detect heap corruption early on.
+ * Should be called only inside the critical section.
  *
  * @param addr Address of the block.
@@ -161 +166 @@
 }
 
+/** Increase the heap area size
+ *
+ * Should be called only inside the critical section.
+ *
+ * @param size Number of bytes to grow the heap by.
+ *
+ */
 static bool grow_heap(size_t size)
 {
         if (size == 0)
+                return false;
+
+        if ((heap_start + size < heap_start) || (heap_end + size < heap_end))
                 return false;
         
@@ -186 +201 @@
 }
 
+/** Decrease the heap area
+ *
+ * Should be called only inside the critical section.
+ *
+ * @param size Number of bytes to shrink the heap by.
+ *
+ */
 static void shrink_heap(void)
 {
@@ -193 +215 @@
 /** Initialize the heap allocator
  *
- * Finds how much physical memory we have and creates
+ * Find how much physical memory we have and create
  * the heap management structures that mark the whole
  * physical memory as a single free block.
@@ -200 +222 @@
 void __heap_init(void)
 {
+        futex_down(&malloc_futex);
+        
         if (as_area_create((void *) &_heap, PAGE_SIZE,
             AS_AREA_WRITE | AS_AREA_READ)) {
@@ -210 +234 @@
                 block_init(heap_start, heap_end - heap_start, true);
         }
-}
-
+        
+        futex_up(&malloc_futex);
+}
+
+/** Get maximum heap address
+ *
+ */
 uintptr_t get_max_heap_addr(void)
 {
+        futex_down(&malloc_futex);
+        
         if (max_heap_size == (size_t) -1)
                 max_heap_size =
                     max((size_t) (heap_end - heap_start), MAX_HEAP_SIZE);
         
-        return ((uintptr_t) heap_start + max_heap_size);
-}
-
+        uintptr_t max_heap_addr = (uintptr_t) heap_start + max_heap_size;
+        
+        futex_up(&malloc_futex);
+        
+        return max_heap_addr;
+}
+
+/** Split heap block and mark it as used.
+ *
+ * Should be called only inside the critical section.
+ *
+ * @param cur  Heap block to split.
+ * @param size Number of bytes to split and mark from the beginning
+ *             of the block.
+ *
+ */
 static void split_mark(heap_block_head_t *cur, const size_t size)
 {
@@ -240 +284 @@
 
 /** Allocate a memory block
+ *
+ * Should be called only inside the critical section.
  *
  * @param size  The size of the block to allocate.
@@ -353 +399 @@
 }
 
+/** Allocate memory by number of elements
+ *
+ * @param nmemb Number of members to allocate.
+ * @param size  Size of one member in bytes.
+ *
+ * @return Allocated memory or NULL.
+ *
+ */
 void *calloc(const size_t nmemb, const size_t size)
 {
@@ -358 +412 @@
         if (block == NULL)
                 return NULL;
-
+        
         memset(block, 0, nmemb * size);
         return block;
 }
 
+/** Allocate memory
+ *
+ * @param size Number of bytes to allocate.
+ *
+ * @return Allocated memory or NULL.
+ *
+ */
 void *malloc(const size_t size)
 {
-        return malloc_internal(size, BASE_ALIGN);
-}
-
+        futex_down(&malloc_futex);
+        void *block = malloc_internal(size, BASE_ALIGN);
+        futex_up(&malloc_futex);
+        
+        return block;
+}
+
+/** Allocate memory with specified alignment
+ *
+ * @param align Alignment in byes.
+ * @param size  Number of bytes to allocate.
+ *
+ * @return Allocated memory or NULL.
+ *
+ */
 void *memalign(const size_t align, const size_t size)
 {
@@ -376 +449 @@
             1 << (fnzb(max(sizeof(void *), align) - 1) + 1);
         
-        return malloc_internal(size, palign);
-}
-
+        futex_down(&malloc_futex);
+        void *block = malloc_internal(size, palign);
+        futex_up(&malloc_futex);
+        
+        return block;
+}
+
+/** Reallocate memory block
+ *
+ * @param addr Already allocated memory or NULL.
+ * @param size New size of the memory block.
+ *
+ * @return Reallocated memory or NULL.
+ *
+ */
 void *realloc(const void *addr, const size_t size)
 {
         if (addr == NULL)
                 return malloc(size);
+        
+        futex_down(&malloc_futex);
         
         /* Calculate the position of the header. */
@@ -395 +482 @@
         
         void *ptr = NULL;
+        bool reloc = false;
         size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
         size_t orig_size = head->size;
@@ -412 +500 @@
         } else {
                 /* Look at the next block. If it is free and the size is
-                   sufficient then merge the two. */
+                   sufficient then merge the two. Otherwise just allocate
+                   a new block, copy the original data into it and
+                   free the original block. */
                 heap_block_head_t *next_head =
                     (heap_block_head_t *) (((void *) head) + head->size);
@@ -424 +514 @@
                         
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
-                } else {
-                        ptr = malloc(size);
-                        if (ptr != NULL) {
-                                memcpy(ptr, addr, NET_SIZE(orig_size));
-                                free(addr);
-                        }
+                } else
+                        reloc = true;
+        }
+        
+        futex_up(&malloc_futex);
+        
+        if (reloc) {
+                ptr = malloc(size);
+                if (ptr != NULL) {
+                        memcpy(ptr, addr, NET_SIZE(orig_size));
+                        free(addr);
                 }
         }
@@ -439 +534 @@
  *
  * @param addr The address of the block.
+ *
  */
 void free(const void *addr)
 {
+        futex_down(&malloc_futex);
+        
         /* Calculate the position of the header. */
         heap_block_head_t *head
@@ -480 +578 @@
         
         shrink_heap();
+        
+        futex_up(&malloc_futex);
 }
 

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) */
@@ -471 +471 @@
  * null-terminated and containing only complete characters.
  *
- * @param dest   Destination buffer.
+ * @param dest  Destination buffer.
  * @param count Size of the destination buffer (must be > 0).
  * @param src   Source string.
@@ -477 +477 @@
 void str_cpy(char *dest, size_t size, const char *src)
 {
-        wchar_t ch;
-        size_t src_off;
-        size_t dest_off;
-
         /* There must be space for a null terminator in the buffer. */
         assert(size > 0);
         
-        src_off = 0;
-        dest_off = 0;
-
+        size_t src_off = 0;
+        size_t dest_off = 0;
+        
+        wchar_t ch;
         while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
                 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
                         break;
         }
-
+        
         dest[dest_off] = '\0';
 }
@@ -505 +502 @@
  * have to be null-terminated.
  *
- * @param dest   Destination buffer.
+ * @param dest  Destination buffer.
  * @param count Size of the destination buffer (must be > 0).
  * @param src   Source string.
- * @param n     Maximum number of bytes to read from @a src.
+ * @param n     Maximum number of bytes to read from @a src.
  */
 void str_ncpy(char *dest, size_t size, const char *src, size_t n)
 {
-        wchar_t ch;
-        size_t src_off;
-        size_t dest_off;
-
         /* There must be space for a null terminator in the buffer. */
         assert(size > 0);
         
-        src_off = 0;
-        dest_off = 0;
-
+        size_t src_off = 0;
+        size_t dest_off = 0;
+        
+        wchar_t ch;
         while ((ch = str_decode(src, &src_off, n)) != 0) {
                 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
                         break;
         }
-
+        
         dest[dest_off] = '\0';
 }
@@ -896 +890 @@
 }
 
+/** Duplicate string.
+ *
+ * Allocate a new string and copy characters from the source
+ * string into it. The duplicate string is allocated via sleeping
+ * malloc(), thus this function can sleep in no memory conditions.
+ *
+ * The allocation cannot fail and the return value is always
+ * a valid pointer. The duplicate string is always a well-formed
+ * null-terminated UTF-8 string, but it can differ from the source
+ * string on the byte level.
+ *
+ * @param src Source string.
+ *
+ * @return Duplicate string.
+ *
+ */
 char *str_dup(const char *src)
 {
-        size_t size = str_size(src);
-        void *dest = malloc(size + 1);
-        
+        size_t size = str_size(src) + 1;
+        char *dest = (char *) malloc(size);
         if (dest == NULL)
                 return (char *) NULL;
         
-        return (char *) memcpy(dest, src, size + 1);
-}
-
-char *str_ndup(const char *src, size_t max_size)
+        str_cpy(dest, size, src);
+        return dest;
+}
+
+/** Duplicate string with size limit.
+ *
+ * Allocate a new string and copy up to @max_size bytes from the source
+ * string into it. The duplicate string is allocated via sleeping
+ * malloc(), thus this function can sleep in no memory conditions.
+ * No more than @max_size + 1 bytes is allocated, but if the size
+ * occupied by the source string is smaller than @max_size + 1,
+ * less is allocated.
+ *
+ * The allocation cannot fail and the return value is always
+ * a valid pointer. The duplicate string is always a well-formed
+ * null-terminated UTF-8 string, but it can differ from the source
+ * string on the byte level.
+ *
+ * @param src Source string.
+ * @param n   Maximum number of bytes to duplicate.
+ *
+ * @return Duplicate string.
+ *
+ */
+char *str_ndup(const char *src, size_t n)
 {
         size_t size = str_size(src);
-        if (size > max_size)
-                size = max_size;
+        if (size > n)
+                size = n;
         
         char *dest = (char *) malloc(size + 1);
-        
         if (dest == NULL)
                 return (char *) NULL;
         
-        memcpy(dest, src, size);
-        dest[size] = 0;
+        str_ncpy(dest, size + 1, src, size);
         return dest;
 }
@@ -979 +1007 @@
 }
 
+void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
+{
+        if (val > 10000000000000000000ULL) {
+                *rv = val / 1000000000000000000ULL;
+                *suffix = 'Z';
+        } else if (val > 1000000000000000000ULL) {
+                *rv = val / 1000000000000000ULL;
+                *suffix = 'E';
+        } else if (val > 1000000000000000ULL) {
+                *rv = val / 1000000000000ULL;
+                *suffix = 'T';
+        } else if (val > 1000000000000ULL) {
+                *rv = val / 1000000000ULL;
+                *suffix = 'G';
+        } else if (val > 1000000000ULL) {
+                *rv = val / 1000000ULL;
+                *suffix = 'M';
+        } else if (val > 1000000ULL) {
+                *rv = val / 1000ULL;
+                *suffix = 'k';
+        } else {
+                *rv = val;
+                *suffix = ' ';
+        }
+}
+
 /** @}
  */

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>
@@ -70 +70 @@
  * loader API.
  *
- * @param path pathname of the binary to execute
- * @param argv command-line arguments
+ * @param path Pathname of the binary to execute.
+ * @param argv Command-line arguments.
+ * @param err  If not NULL, the error value is stored here.
  *
  * @return ID of the newly created task or zero on error.
  *
  */
-task_id_t task_spawn(const char *path, char *const args[])
+task_id_t task_spawn(const char *path, const char *const args[], int *err)
 {
         /* Connect to a program loader. */
         loader_t *ldr = loader_connect();
-        if (ldr == NULL)
+        if (ldr == NULL) {
+                if (err != NULL)
+                        *err = EREFUSED;
+                
                 return 0;
+        }
         
         /* Get task ID. */
@@ -143 +148 @@
         /* Success */
         free(ldr);
+        
+        if (err != NULL)
+                *err = EOK;
+        
         return task_id;
         
@@ -149 +158 @@
         loader_abort(ldr);
         free(ldr);
+        
+        if (err != NULL)
+                *err = rc;
         
         return 0;

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/tls.c

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

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>
@@ -434 +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;
 }
@@ -479 +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;
@@ -553 +556 @@
         if (!abs) {
                 free(dirp);
-                return ENOMEM;
+                return NULL;
         }