Ticket #668: allocator.patch

uspace/Makefile.common

@@ -205 +205 @@
 ifeq ($(CONFIG_OPTIMIZE_FOR_SIZE),y)
         OPTIMIZATION = s
 else
-        OPTIMIZATION = 3
+        OPTIMIZATION = 0 
 endif
 
 # PCUT-based unit tests

uspace/app/fdisk/fdisk.c

@@ -1031 +1031 @@
 
 int main(int argc, char *argv[])
 {
-        service_id_t svcid;
+        service_id_t svcid = 0;
         fdisk_dev_t *dev;
         int rc;
 

uspace/lib/c/generic/io/log.c

@@ -242 +242 @@
         if (message_buffer == NULL)
                 return;
 
-        vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
+        int cnt;
+
+        cnt = vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
+
+        assert(cnt <= MESSAGE_BUFFER_SIZE);
         logger_message(logger_session, ctx, level, message_buffer);
         free(message_buffer);
 }

uspace/lib/c/generic/libc.c

@@ -138 +138 @@
 
 void abort(void)
 {
+        *(int *)0x123 = 0x456;
         __SYSCALL1(SYS_TASK_EXIT, true);
         
         /* Unreachable */

uspace/lib/c/generic/malloc.c

@@ -296 +296 @@
         head->area = area;
         head->magic = HEAP_BLOCK_HEAD_MAGIC;
         
+        if (free)
+                memset((void *) &head[1], 0xee, NET_SIZE(size));
+
         heap_block_foot_t *foot = BLOCK_FOOT(head);
         
         foot->size = size;
@@ -311 +314 @@
  * @param addr Address of the block.
  *
  */
+#include <io/kio.h>
 static void block_check(void *addr)
 {
         heap_block_head_t *head = (heap_block_head_t *) addr;
@@ -320 +324 @@
         heap_block_foot_t *foot = BLOCK_FOOT(head);
         
         malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
+        if (head->size != foot->size) {
+                kio_printf("head=%p, foot=%p, foot-head=%u, head->size=%u, foot->size=%u\n", head, foot, (void *) foot - (void *) head, head->size, foot->size);
+        }
         malloc_assert(head->size == foot->size);
 }
 
@@ -353 +360 @@
         /* Align the heap area size on page boundary */
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
         void *astart = as_area_create(AS_AREA_ANY, asize,
-            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
+            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE | AS_AREA_GUARD);
         if (astart == AS_MAP_FAILED)
                 return false;
         
@@ -394 +401 @@
  */
 static bool area_grow(heap_area_t *area, size_t size)
 {
+        return false;
         if (size == 0)
                 return true;
         
@@ -792 +800 @@
          */
         size_t gross_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
         
+#if 0
         /* Try the next fit approach */
         heap_block_head_t *split = next_fit;
         
@@ -815 +824 @@
                 if (addr != NULL)
                         return addr;
         }
+#endif
         
         /* Finally, try to grow heap space and allocate in the new area. */
         return heap_grow_and_alloc(gross_size, falign);
@@ -851 +861 @@
 {
         heap_lock();
         void *block = malloc_internal(size, BASE_ALIGN);
+        memset(block, 0xde, size);
         heap_unlock();
 
         return block;
@@ -874 +885 @@
 
         heap_lock();
         void *block = malloc_internal(size, palign);
+        memset(block, 0xde, size);
         heap_unlock();
 
         return block;
@@ -891 +903 @@
 {
         if (addr == NULL)
                 return malloc(size);
-        
         heap_lock();
         
         /* Calculate the position of the header. */
@@ -908 +919 @@
         malloc_assert((void *) head < area->end);
         
         void *ptr = NULL;
-        bool reloc = false;
-        size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
+//      bool reloc = false;
+//      size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
         size_t orig_size = head->size;
+#if 0   
         
         if (orig_size > real_size) {
                 /* Shrink */
@@ -949 +961 @@
                         reloc = true;
         }
         
+#endif
         heap_unlock();
-        
-        if (reloc) {
+//      if (reloc) {
                 ptr = malloc(size);
                 if (ptr != NULL) {
                         memcpy(ptr, addr, NET_SIZE(orig_size));
                         free(addr);
                 }
-        }
+//      }
         
         return ptr;
 }

uspace/srv/devman/devtree.c

@@ -43 +43 @@
 
 static inline size_t handle_key_hash(void *key)
 {
-        devman_handle_t handle = *(devman_handle_t*)key;
+        devman_handle_t handle = *((devman_handle_t *) key);
         return handle;
 }
 
@@ -61 +61 @@
 
 static bool devman_devices_key_equal(void *key, const ht_link_t *item)
 {
-        devman_handle_t handle = *(devman_handle_t*)key;
+        devman_handle_t handle = *((devman_handle_t *) key);
         dev_node_t *dev = hash_table_get_inst(item, dev_node_t, devman_dev);
         return dev->handle == handle;
 }
 
 static bool devman_functions_key_equal(void *key, const ht_link_t *item)
 {
-        devman_handle_t handle = *(devman_handle_t*)key;
+        devman_handle_t handle = *((devman_handle_t *) key);
         fun_node_t *fun = hash_table_get_inst(item, fun_node_t, devman_fun);
         return fun->handle == handle;
 }
 
 static inline size_t service_id_key_hash(void *key)
 {
-        service_id_t service_id = *(service_id_t*)key;
+        service_id_t service_id = *((service_id_t *) key);
         return service_id;
 }
 
@@ -87 +87 @@
 
 static bool loc_functions_key_equal(void *key, const ht_link_t *item)
 {
-        service_id_t service_id = *(service_id_t*)key;
+        service_id_t service_id = *((service_id_t *) key);
         fun_node_t *fun = hash_table_get_inst(item, fun_node_t, loc_fun);
         return fun->service_id == service_id;
 }