Changeset df29f24 in mainline for uspace/lib/c

Timestamp:

2011-06-01T09:04:08Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

0a7627b, c9f0975

Parents:

e51a514 (diff), 5d1b3aa (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

Conflicts - trivial to solve
In kernel/generic/src/mm/page.c - sys_page_find_mapping does
not use locking when accessing page tables (hope that is correct).

Location:

uspace/lib/c

Files:

• arch/ppc32/_link.ld.in (modified) (2 diffs)
• generic/assert.c (modified) (1 diff)
• generic/io/klog.c (modified) (2 diffs)
• generic/io/vprintf.c (modified) (1 diff)
• generic/malloc.c (modified) (30 diffs)
• generic/thread.c (modified) (1 diff)
• include/adt/list.h (modified) (6 diffs)
• include/as.h (modified) (1 diff)
• include/io/klog.h (modified) (1 diff)
• include/malloc.h (modified) (1 diff)

uspace/lib/c/arch/ppc32/_link.ld.in

@@ -10 +10 @@
 #endif
         data PT_LOAD FLAGS(6);
+        debug PT_NOTE;
 }
 
@@ -55 +56 @@
         } :data
         
+#ifdef CONFIG_LINE_DEBUG
+        .comment 0 : { *(.comment); } :debug
+        .debug_abbrev 0 : { *(.debug_abbrev); } :debug
+        .debug_aranges 0 : { *(.debug_aranges); } :debug
+        .debug_info 0 : { *(.debug_info); } :debug
+        .debug_line 0 : { *(.debug_line); } :debug
+        .debug_loc 0 : { *(.debug_loc); } :debug
+        .debug_pubnames 0 : { *(.debug_pubnames); } :debug
+        .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
+        .debug_ranges 0 : { *(.debug_ranges); } :debug
+        .debug_str 0 : { *(.debug_str); } :debug
+#endif
+        
         /DISCARD/ : {
                 *(*);

uspace/lib/c/generic/assert.c

@@ -33 +33 @@
 #include <assert.h>
 #include <stdio.h>
+#include <io/klog.h>
 #include <stdlib.h>
+#include <atomic.h>
 #include <stacktrace.h>
+#include <stdint.h>
+
+static atomic_t failed_asserts = {0};
 
 void assert_abort(const char *cond, const char *file, unsigned int line)
 {
+        /*
+         * Send the message safely to klog. Nested asserts should not occur.
+         */
+        klog_printf("Assertion failed (%s) in file \"%s\", line %u.\n",
+            cond, file, line);
+        
+        /*
+         * Check if this is a nested or parallel assert.
+         */
+        if (atomic_postinc(&failed_asserts))
+                abort();
+        
+        /*
+         * Attempt to print the message to standard output and display
+         * the stack trace. These operations can theoretically trigger nested
+         * assertions.
+         */
         printf("Assertion failed (%s) in file \"%s\", line %u.\n",
             cond, file, line);
         stacktrace_print();
+        
         abort();
 }

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

@@ -38 +38 @@
 #include <sys/types.h>
 #include <unistd.h>
+#include <errno.h>
 #include <io/klog.h>
+#include <io/printf_core.h>
 
 size_t klog_write(const void *buf, size_t size)
@@ -55 +57 @@
 }
 
+/** Print formatted text to klog.
+ *
+ * @param fmt Format string
+ *
+ * \see For more details about format string see printf_core.
+ *
+ */
+int klog_printf(const char *fmt, ...)
+{
+        va_list args;
+        va_start(args, fmt);
+        
+        int ret = klog_vprintf(fmt, args);
+        
+        va_end(args);
+        
+        return ret;
+}
+
+static int klog_vprintf_str_write(const char *str, size_t size, void *data)
+{
+        size_t wr = klog_write(str, size);
+        return str_nlength(str, wr);
+}
+
+static int klog_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
+{
+        size_t offset = 0;
+        size_t chars = 0;
+        
+        while (offset < size) {
+                char buf[STR_BOUNDS(1)];
+                size_t sz = 0;
+                
+                if (chr_encode(str[chars], buf, &sz, STR_BOUNDS(1)) == EOK)
+                        klog_write(buf, sz);
+                
+                chars++;
+                offset += sizeof(wchar_t);
+        }
+        
+        return chars;
+}
+
+/** Print formatted text to klog.
+ *
+ * @param fmt Format string
+ * @param ap  Format parameters
+ *
+ * \see For more details about format string see printf_core.
+ *
+ */
+int klog_vprintf(const char *fmt, va_list ap)
+{
+        printf_spec_t ps = {
+                klog_vprintf_str_write,
+                klog_vprintf_wstr_write,
+                NULL
+        };
+        
+        return printf_core(fmt, &ps, ap);
+}
+
 /** @}
  */

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

@@ -96 +96 @@
 /** Print formatted text to stdout.
  *
- * @param file Output stream
- * @param fmt  Format string
- * @param ap   Format parameters
+ * @param fmt Format string
+ * @param ap  Format parameters
  *
  * \see For more details about format string see printf_core.

uspace/lib/c/generic/malloc.c

@@ -65 +65 @@
 #define BASE_ALIGN  16
 
+/** Heap shrink granularity
+ *
+ * Try not to pump and stress the heap to much
+ * by shrinking and enlarging it too often.
+ * A heap area won't shrunk if it the released
+ * free block is smaller than this constant.
+ *
+ */
+#define SHRINK_GRANULARITY  (64 * PAGE_SIZE)
+
 /** Overhead of each heap block. */
 #define STRUCT_OVERHEAD \
         (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
 
+/** Overhead of each area. */
+#define AREA_OVERHEAD(size) \
+        (ALIGN_UP(size + sizeof(heap_area_t), BASE_ALIGN))
+
 /** Calculate real size of a heap block.
  *
@@ -86 +100 @@
  *
  */
-#define AREA_FIRST_BLOCK(area) \
+#define AREA_FIRST_BLOCK_HEAD(area) \
         (ALIGN_UP(((uintptr_t) (area)) + sizeof(heap_area_t), BASE_ALIGN))
+
+/** Get last block in heap area.
+ *
+ */
+#define AREA_LAST_BLOCK_FOOT(area) \
+        (((uintptr_t) (area)->end) - sizeof(heap_block_foot_t))
+
+/** Get header in heap block.
+ *
+ */
+#define BLOCK_HEAD(foot) \
+        ((heap_block_head_t *) \
+            (((uintptr_t) (foot)) + sizeof(heap_block_foot_t) - (foot)->size))
 
 /** Get footer in heap block.
@@ -94 +121 @@
 #define BLOCK_FOOT(head) \
         ((heap_block_foot_t *) \
-            (((uintptr_t) head) + head->size - sizeof(heap_block_foot_t)))
+            (((uintptr_t) (head)) + (head)->size - sizeof(heap_block_foot_t)))
 
 /** Heap area.
@@ -115 +142 @@
         void *end;
         
+        /** Previous heap area */
+        struct heap_area *prev;
+        
         /** Next heap area */
         struct heap_area *next;
@@ -157 +187 @@
 
 /** Next heap block to examine (next fit algorithm) */
-static heap_block_head_t *next = NULL;
+static heap_block_head_t *next_fit = NULL;
 
 /** Futex for thread-safe heap manipulation */
 static futex_t malloc_futex = FUTEX_INITIALIZER;
+
+#ifndef NDEBUG
+
+#define malloc_assert(expr) \
+        do { \
+                if (!(expr)) {\
+                        futex_up(&malloc_futex); \
+                        assert_abort(#expr, __FILE__, __LINE__); \
+                } \
+        } while (0)
+
+#else /* NDEBUG */
+
+#define malloc_assert(expr)
+
+#endif /* NDEBUG */
 
 /** Initialize a heap block
@@ -202 +248 @@
         heap_block_head_t *head = (heap_block_head_t *) addr;
         
-        assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
+        malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
         
         heap_block_foot_t *foot = BLOCK_FOOT(head);
         
-        assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
-        assert(head->size == foot->size);
+        malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
+        malloc_assert(head->size == foot->size);
 }
 
 /** Check a heap area structure
  *
+ * Should be called only inside the critical section.
+ *
  * @param addr Address of the heap area.
  *
@@ -219 +267 @@
         heap_area_t *area = (heap_area_t *) addr;
         
-        assert(area->magic == HEAP_AREA_MAGIC);
-        assert(area->start < area->end);
-        assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
-        assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
+        malloc_assert(area->magic == HEAP_AREA_MAGIC);
+        malloc_assert(addr == area->start);
+        malloc_assert(area->start < area->end);
+        malloc_assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
+        malloc_assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
 }
 
 /** Create new heap area
  *
- * @param start Preffered starting address of the new area.
- * @param size  Size of the area.
+ * Should be called only inside the critical section.
+ *
+ * @param size Size of the area.
  *
  */
@@ -248 +298 @@
         
         area->start = astart;
-        area->end = (void *)
-            ALIGN_DOWN((uintptr_t) astart + asize, BASE_ALIGN);
+        area->end = (void *) ((uintptr_t) astart + asize);
+        area->prev = NULL;
         area->next = NULL;
         area->magic = HEAP_AREA_MAGIC;
         
-        void *block = (void *) AREA_FIRST_BLOCK(area);
+        void *block = (void *) AREA_FIRST_BLOCK_HEAD(area);
         size_t bsize = (size_t) (area->end - block);
         
@@ -262 +312 @@
                 last_heap_area = area;
         } else {
+                area->prev = last_heap_area;
                 last_heap_area->next = area;
                 last_heap_area = area;
@@ -271 +322 @@
 /** Try to enlarge a heap area
  *
+ * Should be called only inside the critical section.
+ *
  * @param area Heap area to grow.
- * @param size Gross size of item to allocate (bytes).
+ * @param size Gross size to grow (bytes).
+ *
+ * @return True if successful.
  *
  */
@@ -282 +337 @@
         area_check(area);
         
-        size_t asize = ALIGN_UP((size_t) (area->end - area->start) + size,
-            PAGE_SIZE);
-        
         /* New heap area size */
-        void *end = (void *)
-            ALIGN_DOWN((uintptr_t) area->start + asize, BASE_ALIGN);
+        size_t gross_size = (size_t) (area->end - area->start) + size;
+        size_t asize = ALIGN_UP(gross_size, PAGE_SIZE);
+        void *end = (void *) ((uintptr_t) area->start + asize);
         
         /* Check for overflow */
@@ -299 +352 @@
         
         /* Add new free block */
-        block_init(area->end, (size_t) (end - area->end), true, area);
+        size_t net_size = (size_t) (end - area->end);
+        if (net_size > 0)
+                block_init(area->end, net_size, true, area);
         
         /* Update heap area parameters */
@@ -309 +364 @@
 /** Try to enlarge any of the heap areas
  *
+ * Should be called only inside the critical section.
+ *
  * @param size Gross size of item to allocate (bytes).
  *
@@ -318 +375 @@
         
         /* First try to enlarge some existing area */
-        heap_area_t *area;
-        for (area = first_heap_area; area != NULL; area = area->next) {
+        for (heap_area_t *area = first_heap_area; area != NULL;
+            area = area->next) {
                 if (area_grow(area, size))
                         return true;
@@ -325 +382 @@
         
         /* Eventually try to create a new area */
-        return area_create(AREA_FIRST_BLOCK(size));
-}
-
-/** Try to shrink heap space
- *
+        return area_create(AREA_OVERHEAD(size));
+}
+
+/** Try to shrink heap
+ *
+ * Should be called only inside the critical section.
  * In all cases the next pointer is reset.
  *
- */
-static void heap_shrink(void)
-{
-        next = NULL;
+ * @param area Last modified heap area.
+ *
+ */
+static void heap_shrink(heap_area_t *area)
+{
+        area_check(area);
+        
+        heap_block_foot_t *last_foot =
+            (heap_block_foot_t *) AREA_LAST_BLOCK_FOOT(area);
+        heap_block_head_t *last_head = BLOCK_HEAD(last_foot);
+        
+        block_check((void *) last_head);
+        malloc_assert(last_head->area == area);
+        
+        if (last_head->free) {
+                /*
+                 * The last block of the heap area is
+                 * unused. The area might be potentially
+                 * shrunk.
+                 */
+                
+                heap_block_head_t *first_head =
+                    (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(area);
+                
+                block_check((void *) first_head);
+                malloc_assert(first_head->area == area);
+                
+                size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
+                
+                if (first_head == last_head) {
+                        /*
+                         * The entire heap area consists of a single
+                         * free heap block. This means we can get rid
+                         * of it entirely.
+                         */
+                        
+                        heap_area_t *prev = area->prev;
+                        heap_area_t *next = area->next;
+                        
+                        if (prev != NULL) {
+                                area_check(prev);
+                                prev->next = next;
+                        } else
+                                first_heap_area = next;
+                        
+                        if (next != NULL) {
+                                area_check(next);
+                                next->prev = prev;
+                        } else
+                                last_heap_area = prev;
+                        
+                        as_area_destroy(area->start);
+                } else if (shrink_size >= SHRINK_GRANULARITY) {
+                        /*
+                         * Make sure that we always shrink the area
+                         * by a multiple of page size and update
+                         * the block layout accordingly.
+                         */
+                        
+                        size_t asize = (size_t) (area->end - area->start) - shrink_size;
+                        void *end = (void *) ((uintptr_t) area->start + asize);
+                        
+                        /* Resize the address space area */
+                        int ret = as_area_resize(area->start, asize, 0);
+                        if (ret != EOK)
+                                abort();
+                        
+                        /* Update heap area parameters */
+                        area->end = end;
+                        size_t excess = ((size_t) area->end) - ((size_t) last_head);
+                        
+                        if (excess > 0) {
+                                if (excess >= STRUCT_OVERHEAD) {
+                                        /*
+                                         * The previous block cannot be free and there
+                                         * is enough free space left in the area to
+                                         * create a new free block.
+                                         */
+                                        block_init((void *) last_head, excess, true, area);
+                                } else {
+                                        /*
+                                         * The excess is small. Therefore just enlarge
+                                         * the previous block.
+                                         */
+                                        heap_block_foot_t *prev_foot = (heap_block_foot_t *)
+                                            (((uintptr_t) last_head) - sizeof(heap_block_foot_t));
+                                        heap_block_head_t *prev_head = BLOCK_HEAD(prev_foot);
+                                        
+                                        block_check((void *) prev_head);
+                                        
+                                        block_init(prev_head, prev_head->size + excess,
+                                            prev_head->free, area);
+                                }
+                        }
+                }
+        }
+        
+        next_fit = NULL;
 }
 
@@ -362 +514 @@
 static void split_mark(heap_block_head_t *cur, const size_t size)
 {
-        assert(cur->size >= size);
+        malloc_assert(cur->size >= size);
         
         /* See if we should split the block. */
@@ -398 +550 @@
 {
         area_check((void *) area);
-        assert((void *) first_block >= (void *) AREA_FIRST_BLOCK(area));
-        assert((void *) first_block < area->end);
-        
-        heap_block_head_t *cur;
-        for (cur = first_block; (void *) cur < area->end;
+        malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) first_block < area->end);
+        
+        for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
             cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
                 block_check(cur);
@@ -425 +576 @@
                                 split_mark(cur, real_size);
                                 
-                                next = cur;
+                                next_fit = cur;
                                 return addr;
                         } else {
@@ -436 +587 @@
                                          * data in (including alignment).
                                          */
-                                        if ((void *) cur > (void *) AREA_FIRST_BLOCK(area)) {
+                                        if ((void *) cur > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
                                                 /*
                                                  * There is a block before the current block.
@@ -477 +628 @@
                                                 split_mark(next_head, real_size);
                                                 
-                                                next = next_head;
+                                                next_fit = next_head;
                                                 return aligned;
                                         } else {
@@ -496 +647 @@
                                                         size_t reduced_size = cur->size - excess;
                                                         cur = (heap_block_head_t *)
-                                                            (AREA_FIRST_BLOCK(area) + excess);
+                                                            (AREA_FIRST_BLOCK_HEAD(area) + excess);
                                                         
-                                                        block_init((void *) AREA_FIRST_BLOCK(area), excess,
-                                                            true, area);
+                                                        block_init((void *) AREA_FIRST_BLOCK_HEAD(area),
+                                                            excess, true, area);
                                                         block_init(cur, reduced_size, true, area);
                                                         split_mark(cur, real_size);
                                                         
-                                                        next = cur;
+                                                        next_fit = cur;
                                                         return aligned;
                                                 }
@@ -527 +678 @@
 static void *malloc_internal(const size_t size, const size_t align)
 {
-        assert(first_heap_area != NULL);
+        malloc_assert(first_heap_area != NULL);
         
         if (align == 0)
@@ -541 +692 @@
         
         /* Try the next fit approach */
-        split = next;
+        split = next_fit;
         
         if (split != NULL) {
@@ -552 +703 @@
         
         /* Search the entire heap */
-        heap_area_t *area;
-        for (area = first_heap_area; area != NULL; area = area->next) {
+        for (heap_area_t *area = first_heap_area; area != NULL;
+            area = area->next) {
                 heap_block_head_t *first = (heap_block_head_t *)
-                    AREA_FIRST_BLOCK(area);
+                    AREA_FIRST_BLOCK_HEAD(area);
                 
                 void *addr = malloc_area(area, first, split, real_size,
@@ -652 +803 @@
         
         block_check(head);
-        assert(!head->free);
+        malloc_assert(!head->free);
         
         heap_area_t *area = head->area;
         
         area_check(area);
-        assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
-        assert((void *) head < area->end);
+        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) head < area->end);
         
         void *ptr = NULL;
@@ -675 +826 @@
                         block_init((void *) head + real_size,
                             orig_size - real_size, true, area);
-                        heap_shrink();
+                        heap_shrink(area);
                 }
                 
@@ -697 +848 @@
                         
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
-                        next = NULL;
+                        next_fit = NULL;
                 } else
                         reloc = true;
@@ -729 +880 @@
         
         block_check(head);
-        assert(!head->free);
+        malloc_assert(!head->free);
         
         heap_area_t *area = head->area;
         
         area_check(area);
-        assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
-        assert((void *) head < area->end);
+        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) head < area->end);
         
         /* Mark the block itself as free. */
@@ -751 +902 @@
         
         /* Look at the previous block. If it is free, merge the two. */
-        if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) {
+        if ((void *) head > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
                 heap_block_foot_t *prev_foot =
                     (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
@@ -765 +916 @@
         }
         
-        heap_shrink();
+        heap_shrink(area);
         
         futex_up(&malloc_futex);
 }
 
+void *heap_check(void)
+{
+        futex_down(&malloc_futex);
+        
+        if (first_heap_area == NULL) {
+                futex_up(&malloc_futex);
+                return (void *) -1;
+        }
+        
+        /* Walk all heap areas */
+        for (heap_area_t *area = first_heap_area; area != NULL;
+            area = area->next) {
+                
+                /* Check heap area consistency */
+                if ((area->magic != HEAP_AREA_MAGIC) ||
+                    ((void *) area != area->start) ||
+                    (area->start >= area->end) ||
+                    (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
+                    (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
+                        futex_up(&malloc_futex);
+                        return (void *) area;
+                }
+                
+                /* Walk all heap blocks */
+                for (heap_block_head_t *head = (heap_block_head_t *)
+                    AREA_FIRST_BLOCK_HEAD(area); (void *) head < area->end;
+                    head = (heap_block_head_t *) (((void *) head) + head->size)) {
+                        
+                        /* Check heap block consistency */
+                        if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
+                                futex_up(&malloc_futex);
+                                return (void *) head;
+                        }
+                        
+                        heap_block_foot_t *foot = BLOCK_FOOT(head);
+                        
+                        if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
+                            (head->size != foot->size)) {
+                                futex_up(&malloc_futex);
+                                return (void *) foot;
+                        }
+                }
+        }
+        
+        futex_up(&malloc_futex);
+        
+        return NULL;
+}
+
 /** @}
  */

uspace/lib/c/generic/thread.c

@@ -44 +44 @@
 
 #ifndef THREAD_INITIAL_STACK_PAGES_NO
-#define THREAD_INITIAL_STACK_PAGES_NO 1
+#define THREAD_INITIAL_STACK_PAGES_NO   2 
 #endif
 

uspace/lib/c/include/adt/list.h

@@ -49 +49 @@
  *
  */
-#define LIST_INITIALIZE(name)  link_t name = { \
-        .prev = &name, \
-        .next = &name \
-}
+#define LIST_INITIALIZE(name) \
+        link_t name = { \
+                .prev = &name, \
+                .next = &name \
+        }
+
+#define list_get_instance(link, type, member) \
+        ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
+
+#define list_foreach(list, iterator) \
+        for (link_t *iterator = (list).next; \
+            iterator != &(list); iterator = iterator->next)
 
 /** Initialize doubly-linked circular list link
@@ -71 +79 @@
  * Initialize doubly-linked circular list.
  *
- * @param head Pointer to link_t structure representing head of the list.
- *
- */
-static inline void list_initialize(link_t *head)
-{
-        head->prev = head;
-        head->next = head;
+ * @param list Pointer to link_t structure representing the list.
+ *
+ */
+static inline void list_initialize(link_t *list)
+{
+        list->prev = list;
+        list->next = list;
 }
 
@@ -85 +93 @@
  *
  * @param link Pointer to link_t structure to be added.
- * @param head Pointer to link_t structure representing head of the list.
- *
- */
-static inline void list_prepend(link_t *link, link_t *head)
-{
-        link->next = head->next;
-        link->prev = head;
-        head->next->prev = link;
-        head->next = link;
+ * @param list Pointer to link_t structure representing the list.
+ *
+ */
+static inline void list_prepend(link_t *link, link_t *list)
+{
+        link->next = list->next;
+        link->prev = list;
+        list->next->prev = link;
+        list->next = link;
 }
 
@@ -101 +109 @@
  *
  * @param link Pointer to link_t structure to be added.
- * @param head Pointer to link_t structure representing head of the list.
- *
- */
-static inline void list_append(link_t *link, link_t *head)
-{
-        link->prev = head->prev;
-        link->next = head;
-        head->prev->next = link;
-        head->prev = link;
-}
-
-/** Insert item before another item in doubly-linked circular list. */
-static inline void list_insert_before(link_t *l, link_t *r)
-{
-        list_append(l, r);
-}
-
-/** Insert item after another item in doubly-linked circular list. */
-static inline void list_insert_after(link_t *r, link_t *l)
-{
-        list_prepend(l, r);
+ * @param list Pointer to link_t structure representing the list.
+ *
+ */
+static inline void list_append(link_t *link, link_t *list)
+{
+        link->prev = list->prev;
+        link->next = list;
+        list->prev->next = link;
+        list->prev = link;
+}
+
+/** Insert item before another item in doubly-linked circular list.
+ *
+ */
+static inline void list_insert_before(link_t *link, link_t *list)
+{
+        list_append(link, list);
+}
+
+/** Insert item after another item in doubly-linked circular list.
+ *
+ */
+static inline void list_insert_after(link_t *link, link_t *list)
+{
+        list_prepend(list, link);
 }
 
@@ -143 +155 @@
  * Query emptiness of doubly-linked circular list.
  *
- * @param head Pointer to link_t structure representing head of the list.
- *
- */
-static inline int list_empty(link_t *head)
-{
-        return ((head->next == head) ? 1 : 0);
+ * @param list Pointer to link_t structure representing the list.
+ *
+ */
+static inline int list_empty(link_t *list)
+{
+        return (list->next == list);
+}
+
+/** Get head item of a list.
+ *
+ * @param list Pointer to link_t structure representing the list.
+ *
+ * @return Head item of the list.
+ * @return NULL if the list is empty.
+ *
+ */
+static inline link_t *list_head(link_t *list)
+{
+        return ((list->next == list) ? NULL : list->next);
 }
 
@@ -205 +230 @@
 }
 
-#define list_get_instance(link, type, member) \
-        ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
-
-#define list_foreach(list, iterator) \
-        for (link_t *iterator = (list).next; \
-            iterator != &(list); iterator = iterator->next)
+/** Get n-th item of a list.
+ *
+ * @param list Pointer to link_t structure representing the list.
+ * @param n    Item number (indexed from zero).
+ *
+ * @return n-th item of the list.
+ * @return NULL if no n-th item found.
+ *
+ */
+static inline link_t *list_nth(link_t *list, unsigned int n)
+{
+        unsigned int cnt = 0;
+        
+        list_foreach(*list, link) {
+                if (cnt == n)
+                        return link;
+                
+                cnt++;
+        }
+        
+        return NULL;
+}
 
 extern int list_member(const link_t *, const link_t *);

uspace/lib/c/include/as.h

@@ -59 +59 @@
 extern int as_area_destroy(void *);
 extern void *set_maxheapsize(size_t);
-extern void * as_get_mappable_page(size_t);
+extern void *as_get_mappable_page(size_t);
 extern int as_get_physical_mapping(void *, uintptr_t *);
 

uspace/lib/c/include/io/klog.h

@@ -37 +37 @@
 
 #include <sys/types.h>
+#include <stdarg.h>
 
 extern size_t klog_write(const void *, size_t);
 extern void klog_update(void);
+extern int klog_printf(const char *, ...);
+extern int klog_vprintf(const char *, va_list);
 
 #endif

uspace/lib/c/include/malloc.h

@@ -46 +46 @@
 extern void *realloc(const void *addr, const size_t size);
 extern void free(const void *addr);
+extern void *heap_check(void);
 
 #endif