Fix cmpctmalloc for large allocations

src/freertos/cmpctmalloc.c

 // Copyright (c) 2016, the Dartino project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 // This code is ported from the LK repository. To keep the code in
 // sync the define DARTINO_TARGET_OS_LK provides the code from the LK
 // repository. Without the define DARTINO_TARGET_OS_LK this code will
 // build and link for the disco_dartino project.
 #ifdef DARTINO_TARGET_OS_LK
 
@@ skipping 606 matching lines @@
 }
 
 static void *large_alloc(size_t size)
 {
 #ifdef CMPCT_DEBUG
     size_t requested_size = size;
 #endif
     size = ROUNDUP(size, 8);
     free_t *free_area = NULL;
     lock();
-    heap_grow(size, &free_area);
+    if (heap_grow(size, &free_area) < 0) {
+      return 0;
+    }
     void *result =
         create_allocation_header(free_area, 0, free_area->header.size, free_area->header.left);
     // Normally the 'remaining free space' counter would be decremented when we
     // unlink the free area from its bucket.  However in this case the free
     // area was too big to go in any bucket and we had it in our own
     // "free_area" variable so there is no unlinking and we have to adjust the
     // counter here.
     theheap.remaining -= free_area->header.size;
     unlock();
 #ifdef CMPCT_DEBUG
     memset(result, ALLOC_FILL, requested_size);
-    memset((char *)result + requested_size, PADDING_FILL, free_area->header.size - requested_size);
+    memset((char *)result + requested_size, PADDING_FILL,
+        free_area->header.size - (requested_size + sizeof(header_t)));
 #endif
     return result;
 }
 
 void cmpct_trim(void)
 {
     // Look at free list entries that are at least as large as one page plus a
     // header. They might be at the start or the end of a block, so we can trim
     // them and free the page(s).
     lock();
@@ skipping 211 matching lines @@
 
 // Create a new free-list entry of at least size bytes (including the
 // allocation header).  Called with the lock, apart from during init.
 static ssize_t heap_grow(size_t size, free_t **bucket)
 {
     // The new free list entry will have a header on each side (the
     // sentinels) so we need to grow the gross heap size by this much more.
     size += 2 * sizeof(header_t);
     size = ROUNDUP(size, PAGE_SIZE);
     void *ptr = page_alloc(size >> PAGE_SIZE_SHIFT, ANY_ARENA);
+    if (ptr == NULL) return -1;
     theheap.size += size;
-    if (ptr == NULL) return -1;
     LTRACEF("growing heap by 0x%zx bytes, new ptr %p\n", size, ptr);
     add_to_heap(ptr, size, bucket);
     return size;
 }
 
 void cmpct_init(void)
 {
     LTRACE_ENTRY;
 
     // Create a mutex.
 #ifdef DARTINO_TARGET_OS_LK
     mutex_init(&theheap.lock);
 #endif
 
     // Initialize the free list.
     for (int i = 0; i < NUMBER_OF_BUCKETS; i++) {
         theheap.free_lists[i] = NULL;
     }
     for (int i = 0; i < BUCKET_WORDS; i++) {
         theheap.free_list_bits[i] = 0;
     }
 
     size_t initial_alloc = HEAP_GROW_SIZE - 2 * sizeof(header_t);
 
     theheap.remaining = 0;
 
     heap_grow(initial_alloc, NULL);
 }