Changeset 3292623 in mainline

Timestamp:

2010-04-17T01:16:55Z (15 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

e1da7ec

Parents:

596d65c

Message:

thread-safe heap allocator

Location:

uspace/lib/c/generic

Files:

• libc.c (modified) (3 diffs)
• malloc.c (modified) (19 diffs)

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/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)
 {
@@ -189 +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)
 {
@@ -196 +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.
@@ -203 +222 @@
 void __heap_init(void)
 {
+        futex_down(&malloc_futex);
+        
         if (as_area_create((void *) &_heap, PAGE_SIZE,
             AS_AREA_WRITE | AS_AREA_READ)) {
@@ -213 +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)
 {
@@ -243 +284 @@
 
 /** Allocate a memory block
+ *
+ * Should be called only inside the critical section.
  *
  * @param size  The size of the block to allocate.
@@ -356 +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)
 {
@@ -361 +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)
 {
@@ -379 +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. */
@@ -398 +482 @@
         
         void *ptr = NULL;
+        bool reloc = false;
         size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
         size_t orig_size = head->size;
@@ -415 +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);
@@ -427 +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);
                 }
         }
@@ -442 +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
@@ -483 +578 @@
         
         shrink_heap();
+        
+        futex_up(&malloc_futex);
 }