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

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)

File:

• uspace/lib/c/generic/malloc.c (moved) (moved from uspace/lib/libc/generic/malloc.c ) (19 diffs)

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);
 }