Changeset 0c33b1d5 in mainline for uspace/lib/c/generic/malloc.c

Timestamp:

2011-05-20T23:58:26Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

955f2a5

Parents:

c263c77

Message:

The malloc_futex should be up'ed when an assert is hit inside malloc().

File:

• uspace/lib/c/generic/malloc.c (modified) (10 diffs)

uspace/lib/c/generic/malloc.c

@@ -119 +119 @@
             (((uintptr_t) (head)) + (head)->size - sizeof(heap_block_foot_t)))
 
+#define malloc_assert(expr) \
+        do { \
+                if (!(expr)) {\
+                        futex_up(&malloc_futex); \
+                        assert((expr)); \
+                } \
+        } while (0)
+
+
 /** Heap area.
  *
@@ -228 +237 @@
         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);
 }
 
@@ -247 +256 @@
         heap_area_t *area = (heap_area_t *) addr;
         
-        assert(area->magic == HEAP_AREA_MAGIC);
-        assert(addr == area->start);
-        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);
 }
 
@@ -382 +391 @@
         
         block_check((void *) last_head);
-        assert(last_head->area == area);
+        malloc_assert(last_head->area == area);
         
         if (last_head->free) {
@@ -395 +404 @@
                 
                 block_check((void *) first_head);
-                assert(first_head->area == area);
+                malloc_assert(first_head->area == area);
                 
                 size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
@@ -497 +506 @@
 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. */
@@ -533 +542 @@
 {
         area_check((void *) area);
-        assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        assert((void *) first_block < 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;
@@ -661 +670 @@
 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)
@@ -786 +795 @@
         
         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_HEAD(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;
@@ -863 +872 @@
         
         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_HEAD(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. */