My realloc function return Segmentation fault

Question

I wrote function - malloc, free and realloc The malloc function work fine. The problem is in the function of the realloc it returns me Segmentation fault and I do not know why this is happening. I would be happy if you help me to Understand why this is happening שand how I can fix it.

My code -

#include <unistd.h>
#include <stdio.h>

void *malloc (size_t size);
void *realloc (void *ptr, size_t size);
void free (void *ptr);

typedef struct metadata_block *p_block;
struct metadata_block
{
  size_t size;
  p_block next;
  int free;
};

p_block head = NULL;

int
main ()
{
  char *str;
  int *a;
  a = (int *) malloc (4);
  scanf ("%d", a);
  printf ("String = %d\n", *a);
  a = (int *) realloc (str, 25);
  scanf ("%d", a);
  printf ("String = %d\n", *a);

  return 0;
}

void *
malloc (size_t size)
{
  void *my_malloc;
  p_block tmp;

  if (size <= 0)
    {
      return NULL;
    }

  if (head == NULL)
    {
      head = (void *) sbrk (size + sizeof (struct metadata_block));
      head->size = size;
      head->free = 0;
      head->next = NULL;
      return (void *) head + sizeof (struct metadata_block);
    }
  else
    {
      p_block tmp = head;
      while (tmp->next != NULL)
        {
          tmp = tmp->next;
        }
      tmp->next = (void *) sbrk (size + sizeof (struct metadata_block));
      tmp->size = size;
      tmp->free = 1;
      tmp->next = NULL;
      return (void *) size + sizeof (struct metadata_block);
    }
}

void *
realloc (void *ptr, size_t size)
{
  void *newptr;

  if (ptr == NULL)
    {
      return malloc (size);
    }
  if (size == 0)
    {
      return (ptr);
    }

  newptr = malloc (size);
  return (newptr);

}

void
free (void *ptr)
{
  p_block tmp;

  if (tmp->free == 1)
    {
      tmp = 0;
    }
  ptr = NULL;
}

Answer 1

You realloc should behave like this:

• If ptr == NULL, then just malloc
• If ptr != NULL :
  • malloc new pointer (newPtr) of new size
  • memcpy contents from ptr to newPtr
  • free ptr
  • return newPtr

Remember that realloc needs a pointer which was given from call to malloc (or NULL).

IMHO, implementing behaviour of realloc, which tries to return the same address if possible is too complicated for your task.

Answer 2

OP's realloc(), let's call it realloc_gold() ( and malloc_gold() free_gold()), needs to copy the data contents and other fixes.

void *realloc_gold(void *ptr, size_t size) {

  if (ptr == NULL) {
    return malloc_gold(size);
  }

When the size is 0, free the current ptr and best to handle the same way as malloc_gold(0)

  if (size == 0) {
    free_gold(ptr);
    return malloc_gold(ptr);
  }

Detect OOM and copy data contents. Of course this leads to the problem, what is oldsize? the C standard malloc(), realloc() saves that info somehow, but user code, in general, does not have access to that info. So this code needs to save it. The usual solution is to allocate the size requested + the size of a size_t, and put the size info right before the returned pointer. Assume malloc_gold() does that.

  void *newptr = malloc_gold(size);
  if (newptr != NULL) {
    true
    size_t oldsize = ((struct metadata_block *) ptr)[-1].size;
    memcpy(newptr, ptr, size < oldsize : size : oldsize);
    free_gold(ptr);
  }

  return (newptr);
}

malloc_gold() and free_gold() need to account for the leading size - so some work left for OP.

Answer 3

The following is close to what you want, however, read all the commentary.

//#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

void *myMalloc  (size_t size);
void *myRealloc (void *ptr, size_t size);
void  myFree    (void *ptr);

//typedef struct metadata_block *p_block;
struct metadata_block
{
    size_t size;
    //p_block next;
    struct metadata_block * next;
    int free;
};

//p_block head = NULL;
struct metadata_block *head = NULL;

int main ()
{
    //char *str;
    char * str = NULL;
    int *a;

    //a = (int *) malloc (4);
    // following is not correct because myMalloc
    // returns parameter*sizeof(struct meta_block)
    // probably should call system malloc() instead of myMalloc()
    if( NULL == (a = myMalloc( sizeof(int) ) ) ) 
    { // myMalloc failed
        perror("myMalloc failed");
        exit( EXIT_FAILURE );
    }

    // implied else, myMalloc successful

    //scanf ("%d", a);
    if( 1 != scanf(" %d", a) ) 
    { // scanf failed
        perror("scanf 1 failed" );
        myFree( a );
        exit( EXIT_FAILURE );
    }

    // implied else, scanf successful

    printf ("String = %d\n", *a);

    //a = (int *) realloc (str, 25);
    int * b;
    if( NULL == (b = myRealloc( str, 25 ) ) )
    { // then, myRealloc failed
        perror( "myRealloc failed" );
        myFree(a);
        exit( EXIT_FAILURE );
    }

    // implied else, myRealloc successful

    a = b;

    //scanf ("%d", a);
    if( 1 != scanf(" %d", a ) )
    { // then, scanf failed
        perror( "scanf 2 failed" );
        exit( EXIT_FAILURE );
    }

    // implied else, scanf successful

    printf ("String = %d\n", *a);

    // <-- added following line so no memory leaks
    myFree( a );

    return 0;
} // end function: main


void *myMalloc (size_t size)
{
    //void *my_malloc;
    //p_block tmp;

    if (size <= 0)
    {
        return NULL;
    }

    if (head == NULL)
    {
        if( NULL == (head = malloc(sizeof(struct metadata_block)*(size))) )
        { // then, malloc failed
            perror( "malloc failed" );
            exit( EXIT_FAILURE);
        }

        // implied else, malloc successful

        head->size = size;
        head->free = 0;
        head->next = NULL;
        return (void *) head + sizeof (struct metadata_block);
    }

    else
    {
        struct metadata_block* tmp = head;

        // step through existing linked list
        while (tmp->next != NULL)
        {
            tmp = tmp->next;
        }

        // initialize new metadata_block instance
        //tmp->next = (void *) sbrk (size + sizeof (struct metadata_block));
        tmp->next = malloc(sizeof(struct metadata_block)*(size+1));
        tmp->size = size;
        tmp->free = 1;
        tmp->next = NULL;
        return (void *) size + sizeof (struct metadata_block);
    }
} // end function: myMalloc


void *realloc (void *ptr, size_t size)
{
    void *newptr;

    if (ptr == NULL)
    {
        return malloc (size);
    }

    if (size == 0)
    {
        return (ptr);
    }

    newptr = malloc (size);
    return (newptr);
} // end function: realloc


// <-- the function myFree fails to actually free anything
//     and tmp is being used without first being set to something
void myFree (void *ptr)
{
    //p_block tmp;
    struct metadata_block *tmp = ptr;

    if (tmp->free == 1)
    {
        tmp = 0; // <-- this looses the allocated memory pointer
                 //     without actually freeing the allocated memory
    }

    ptr = NULL;  // <-- this has no effect on the rest of the program allocated memory
                 //     because C passes by value, not by reference
} // end function: myFree