Changeset 13f2461 in mainline for uspace/lib/c/generic/malloc.c

Timestamp:

2011-05-21T15:45:48Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

9d47440, e06e2716

Parents:

faeb7cc

Message:

Merge the functionality of assert_abort() and assert_static_abort() into
assert_abort().

Print the unexpanded message to klog first. Then try to print the
message and the stack trace to standard output using printf. Use the
same unabbreviated message wording for both klog and stdout. If a
nested or a parallel assert is detected, send the message only to klog
and then abort.

Re-introduce malloc_assert() to up the malloc_futex. This appears to be
inevitable if we want to print to stdout. To prevent undesired macro
expansion, call assert_abort() from malloc_assert() directly.

File:

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

uspace/lib/c/generic/malloc.c

@@ -188 +188 @@
 static futex_t malloc_futex = FUTEX_INITIALIZER;
 
+#ifndef NDEBUG
+
+#define malloc_assert(expr) \
+        do { \
+                if (!(expr)) {\
+                        futex_up(&malloc_futex); \
+                        assert_abort(#expr, __FILE__, STR2(__LINE__)); \
+                } \
+        } while (0)
+
+#else /* NDEBUG */
+
+#define malloc_assert(expr)
+
+#endif /* NDEBUG */
+
 /** Initialize a heap block
  *
@@ -228 +244 @@
         heap_block_head_t *head = (heap_block_head_t *) addr;
         
-        assert_static(head->magic == HEAP_BLOCK_HEAD_MAGIC);
+        malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
         
         heap_block_foot_t *foot = BLOCK_FOOT(head);
         
-        assert_static(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
-        assert_static(head->size == foot->size);
+        malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
+        malloc_assert(head->size == foot->size);
 }
 
@@ -247 +263 @@
         heap_area_t *area = (heap_area_t *) addr;
         
-        assert_static(area->magic == HEAP_AREA_MAGIC);
-        assert_static(addr == area->start);
-        assert_static(area->start < area->end);
-        assert_static(((uintptr_t) area->start % PAGE_SIZE) == 0);
-        assert_static(((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 +398 @@
         
         block_check((void *) last_head);
-        assert_static(last_head->area == area);
+        malloc_assert(last_head->area == area);
         
         if (last_head->free) {
@@ -395 +411 @@
                 
                 block_check((void *) first_head);
-                assert_static(first_head->area == area);
+                malloc_assert(first_head->area == area);
                 
                 size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
@@ -497 +513 @@
 static void split_mark(heap_block_head_t *cur, const size_t size)
 {
-        assert_static(cur->size >= size);
+        malloc_assert(cur->size >= size);
         
         /* See if we should split the block. */
@@ -533 +549 @@
 {
         area_check((void *) area);
-        assert_static((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        assert_static((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 +677 @@
 static void *malloc_internal(const size_t size, const size_t align)
 {
-        assert_static(first_heap_area != NULL);
+        malloc_assert(first_heap_area != NULL);
         
         if (align == 0)
@@ -786 +802 @@
         
         block_check(head);
-        assert_static(!head->free);
+        malloc_assert(!head->free);
         
         heap_area_t *area = head->area;
         
         area_check(area);
-        assert_static((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        assert_static((void *) head < area->end);
+        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) head < area->end);
         
         void *ptr = NULL;
@@ -863 +879 @@
         
         block_check(head);
-        assert_static(!head->free);
+        malloc_assert(!head->free);
         
         heap_area_t *area = head->area;
         
         area_check(area);
-        assert_static((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        assert_static((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. */