Thread: Naive Realloc Implementation Seg faults

I need to use a re-sizable buffer. For academic reasons I am not allowed to use realloc, not yet anyway, so I made a simple naive local implementation that simply uses malloc to allocate a new memory area of size n, and copies the bytes of the old buffer to it. Then frees the old memory, and returns a pointer to the newly created buffer.

I know this is far from optimal and causes memory fragmentation but it's all I can do for now.

I increase my buffer by calling my realloc and doubling it's size on each iteration. e.g I start with a buffer of 32 bytes, if I need more space, I call realloc and double that to 64 and so on.

The problem is that my realloc always crashes on the second call, right after trying to free the old memory.

Why could this be? I'd appreciate any help. Thanks

Code:

static void     *my_realloc(void *mem, size_t size)
{
        char    *new_mem;
        char    *old_mem;


        if (!mem || !size)
                return ((void*)0);
        new_mem = (char*)ft_memalloc(size * sizeof(char));
        if (!new_mem)
                return ((void*)0);
        old_mem = mem;
        while (*old_mem)
                *new_mem++ = *old_mem++;
        free(mem);
        return (new_mem);
}

Crash occurs on free(mem), always on the second call.

To further illustrate, this is an example context of how I'm using the function:

Code:

....
const size_t buffer_size = 32;
char *buffer = (char*)malloc(buffer_size * sizeof(char) + 1);
while (...)
{
    buffer = (char*)my_realloc(buffer, current_buff_size += buffer_size);
    ....
}

Your copy loop assumes \0 terminated strings, but doesn't even copy the \0.

Originally Posted by Salem

Your copy loop assumes \0 terminated strings, but doesn't even copy the \0.

I don't copy the null because the new memory area is already filled with /0. Courtesy of the proxy function I use instead of malloc; basically it calls malloc and does a bzero on the result, before returning.
For more information, this is the instruction the debugger stops at: addq $0x88, %rsp and this is the exact error I get munmap_chunk(): invalid pointer

But in your example, your initial bootstrap function is malloc, which has undefined contents.
It could be a long while in the copy loop before it stumbles into a \0.

A proper realloc KNOWS the old size of memory. It doesn't have to guess the size by looking at the contents.

> current_buff_size += buffer_size
1. Don't try and make your code too cute by compressing lines like this.
2. You need to make it consistent with the original allocation, which has a mysterious +1, that is lost.

Code:

const size_t buffer_size = 32;
size_t current_buff_size = buffer_size;
char *buffer = (char*)malloc(current_buff_size);
while (...)
{
    temp = (char*)my_realloc(buffer, current_buff_size + buffer_size);
    if ( temp != NULL ) {
        // only update the size on success.
        buffer = temp;
        current_buff_size += buffer_size;
    } else {
        // do something with buffer and the original value of current_buff_size
    }
    ....
}