Changeset 955f2a5 in mainline

Timestamp:

2011-05-21T11:26:23Z (13 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

1b3e854

Parents:

0c33b1d5

Message:

implement assert_static() as a safer replacement to malloc_assert()

Location:

uspace/lib/c

Files:

• generic/assert.c (modified) (2 diffs)
• generic/malloc.c (modified) (10 diffs)
• include/assert.h (modified) (2 diffs)

uspace/lib/c/generic/assert.c

@@ -33 +33 @@
 #include <assert.h>
 #include <stdio.h>
+#include <io/klog.h>
 #include <stdlib.h>
 #include <stacktrace.h>
@@ -44 +45 @@
 }
 
+void assert_static_abort(const char *msg)
+{
+        klog_write(msg, str_size(msg));
+        abort();
+}
+
 /** @}
  */

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.
  *
@@ -237 +228 @@
         heap_block_head_t *head = (heap_block_head_t *) addr;
         
-        malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
+        assert_static(head->magic == HEAP_BLOCK_HEAD_MAGIC);
         
         heap_block_foot_t *foot = BLOCK_FOOT(head);
         
-        malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
-        malloc_assert(head->size == foot->size);
+        assert_static(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
+        assert_static(head->size == foot->size);
 }
 
@@ -256 +247 @@
         heap_area_t *area = (heap_area_t *) addr;
         
-        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);
+        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);
 }
 
@@ -391 +382 @@
         
         block_check((void *) last_head);
-        malloc_assert(last_head->area == area);
+        assert_static(last_head->area == area);
         
         if (last_head->free) {
@@ -404 +395 @@
                 
                 block_check((void *) first_head);
-                malloc_assert(first_head->area == area);
+                assert_static(first_head->area == area);
                 
                 size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
@@ -506 +497 @@
 static void split_mark(heap_block_head_t *cur, const size_t size)
 {
-        malloc_assert(cur->size >= size);
+        assert_static(cur->size >= size);
         
         /* See if we should split the block. */
@@ -542 +533 @@
 {
         area_check((void *) area);
-        malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        malloc_assert((void *) first_block < area->end);
+        assert_static((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        assert_static((void *) first_block < area->end);
         
         for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
@@ -670 +661 @@
 static void *malloc_internal(const size_t size, const size_t align)
 {
-        malloc_assert(first_heap_area != NULL);
+        assert_static(first_heap_area != NULL);
         
         if (align == 0)
@@ -795 +786 @@
         
         block_check(head);
-        malloc_assert(!head->free);
+        assert_static(!head->free);
         
         heap_area_t *area = head->area;
         
         area_check(area);
-        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        malloc_assert((void *) head < area->end);
+        assert_static((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        assert_static((void *) head < area->end);
         
         void *ptr = NULL;
@@ -872 +863 @@
         
         block_check(head);
-        malloc_assert(!head->free);
+        assert_static(!head->free);
         
         heap_area_t *area = head->area;
         
         area_check(area);
-        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
-        malloc_assert((void *) head < area->end);
+        assert_static((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        assert_static((void *) head < area->end);
         
         /* Mark the block itself as free. */

uspace/lib/c/include/assert.h

@@ -55 +55 @@
         } while (0)
 
+#define assert_static(expr) \
+        do { \
+                if (!(expr)) \
+                        assert_static_abort("Assertion failed (" #expr \
+                            ") in file \"" __FILE__ "\".\n"); \
+        } while (0)
+
 #else /* NDEBUG */
 
 #define assert(expr)
+#define assert_static(expr)
 
 #endif /* NDEBUG */
@@ -63 +71 @@
 extern void assert_abort(const char *, const char *, unsigned int)
     __attribute__((noreturn));
+extern void assert_static_abort(const char *);
+
 
 #endif