Question

Using below code I’m trying to write a wrapper for calloc() so that I can keep trace of allocated heap memory by storing the size in 1st 2/4bytes of the allocated memory. When I tested this alone seems its okay. But when I replace this as my system calloc() then its creating problems.. means some times its returning NULL, even though lot of heap available.

I’m running this on ARM board using IAR compiler:

void *MyCalloc(size_t size) {
    size_t new_size = ((size + 3) & ~0x3); 
    size_t *result = calloc(1,new_size + sizeof(size_t)); 
    if ( result ) { 
        printf("MyCalloc addr: %p\n", result);
        *result = (new_size + sizeof(size_t));
        result = result + sizeof(size_t);
    } 
return result;
}

Any idea why this is causing problem?

Answer 1

There are several problems with your code:

1. When writing heap functions, or heap wrappers, just don’t use pointer arithmetic for storing heap headers. Use structures. That’s what they’re for.

2. You’ve introduced a number of integer overflow bugs into your code. If someone asks your calloc() for 0xfffffffe bytes, you’ll return them 4 bytes. If they write more than 4 bytes to that allocation, there’ll be a heap overflow.

3. Your calloc() doesn’t have the same signature as calloc(). Depending on how you’re swapping out calloc(), this is likely to become a problem.

4. calloc() and malloc() naturally return aligned pointers. In x86 they need to return a pointer to the application that is aligned to at least 8 bytes, and in x64 they need to return a pointer that is at least 16-byte aligned.

   In your code, you’re using the real calloc to do the "heavy lifting" (i.e. as the "raw allocator"), which is fine and that will return an 8 or 16-byte aligned pointer, but when you return a pointer 4-bytes into that structure, your calloc ends up returning a non-aligned pointer to the caller, which is likely to cause problems to people calling your calloc replacement.

Try some code a bit more like this:

 typedef struct 
 {
    size_t cbSize;
 } MyAwesomeHeapHeader;
 // TODO: ensure that MyAwesomeHeapHeader is 8-byte aligned on x86 and 16-byte aligned on x64 (or just 16-byte aligned on both).

 void* MyAwesomeMalloc(size_t cbSize)
 {
    MyAwesomeHeapHeader* header;
    void* internalAllocatorPtr;
    size_t cbAlloc;
    // TODO: Maybe I want a heap footer as well?

    // TODO: I should really check the following for an integer overflow:
    cbAlloc = sizeof(MyAwesomeHeapHeader) + cbSize; 
    internalAllocatorPtr = MyAwesomeRawAllocator(cbAlloc); // at the moment you're using the real calloc for this, but you could use malloc or write your own raw allocator
    // TODO: Check for null

    header = (MyAwesomeHeapHeader*)internalAllocatorPtr;
    header->heapSize = cbSize;
    // TODO: other fields here.

    return (uint8_t*)(internalAllocatorPtr) + sizeof(MyAwesomeHeapHeader);
 }