Wsrtjtyk

What is the reason for this error? I am creating a personal version of malloc and free for my C class and but encountering the following issue: I split a free spot into 2 nodes using the best fit method to insert a value into my linked list, however it's returning the incorrect value to the testing program. The value of currentBlock + sizeof(struct Block) is 6299672 but when I print it out from the testing program it prints 6300251. This leads to a seg fault due to the pointer being incorrect when I free it later in the program. Is this an issue from incorrect casting or am I missing something else?

Thank you! The relevant sections of my code are below:

Below is my my_malloc and my_free methods:

#include <stdlib.h>

#include <unistd.h>

#include <stdio.h>

#include <assert.h>



struct Block {

  int occ;              // whether block is occupied

  int size;             // size of block (including header)

  struct Block *prev;   // pointer to previous block

  struct Block *next;   // pointer to next block

};



static struct Block *head = NULL;       // head of list



void *my_malloc(int size)

{



  struct Block *currentBlock = head;

  struct Block *bestFitBlock = NULL;

  int bestFit = 0;



  void *offset = sbrk(0);

  void *ending = offset + size + sizeof(struct Block);

  int success = brk(ending);



  struct Block *newBlock = offset;

  newBlock -> occ = 1;

  newBlock -> size = size + sizeof(struct Block);



  while(head != NULL && currentBlock != NULL){

    //If the block you're currently looking at is free and either the same or larger size than the incoming block,

    //then split the block and take up the block and have a free block

    if(currentBlock -> occ == 0){

      if(currentBlock -> size  >= newBlock -> size){

        //If the incoming block and the free block are the same size, just fill it in

        if(currentBlock -> size == newBlock -> size){

          currentBlock -> occ = 1;

          int removeExtra = 0 - newBlock -> size;

          sbrk(removeExtra);

          return currentBlock + sizeof(struct Block);

        }

        //If they're bigger sizes, split it into 2 blocks and fill 1 in. Must also leave room for another block to the right

        else if(currentBlock -> size >= newBlock -> size + sizeof(struct Block)){

          //Set the integer to 1 to denote that there is a place for it to go if no blocks match size

          bestFit = 1;

          //Save the block in which it would fit best if no blocks match size

          if(bestFitBlock == NULL){

            bestFitBlock = currentBlock;

          }

          else if(currentBlock -> size > bestFitBlock -> size){

            bestFitBlock = currentBlock;

          }

        }

      }

    }

    //Go to the next block

    currentBlock = currentBlock -> next;

  }



  //Split the block into a taken and free slot

  if(bestFit == 1){

    currentBlock = bestFitBlock;

    int freeSize = currentBlock -> size - newBlock -> size;



    currentBlock -> occ = 1;

    currentBlock -> size = newBlock -> size;



    void *tempPointer = (int)currentBlock + (int)currentBlock -> size;

    struct Block *newFreeBlock = tempPointer;

    newFreeBlock -> occ = 0;

    newFreeBlock -> size = freeSize;

    newFreeBlock -> next = currentBlock -> next;

    newFreeBlock -> prev = currentBlock;

    newFreeBlock -> next -> prev = newFreeBlock;



    currentBlock -> next = newFreeBlock;



    //TROUBLESHOOTING: PRINT WHAT IS SUPPOSED TO BE RETURNED

    printf("%d ", (int)currentBlock + (int)sizeof(struct Block));



    int removeExtra = 0 - newBlock -> size;

    sbrk(removeExtra);

    return (int)currentBlock + (int)sizeof(struct Block);

  }



  if(head == NULL){

    head = newBlock;

  }

  else{

    currentBlock = head;

    while(currentBlock -> next != NULL){

      currentBlock = currentBlock -> next;

    }

    currentBlock -> next = newBlock;

    newBlock -> prev = currentBlock;

  }



  if(success == 0){

    return offset + sizeof(struct Block);

  }

  else{

    printf("Error - Malloc not completedn");

    return (int *)-1;

  }

}





void my_free(void *data)

{

  struct Block *currentBlock = head;

  void *lookingFor = data - sizeof(struct Block);

  while(lookingFor != currentBlock){

    currentBlock = currentBlock -> next;

  }

  currentBlock -> occ = 0;





  //If the block after the one being freed is empty, coalesce these two together

  if(currentBlock -> next != NULL && currentBlock -> next -> occ == 0){

    currentBlock -> size = currentBlock -> size + currentBlock -> next -> size;

    currentBlock -> next = currentBlock -> next -> next;

    if(currentBlock -> next != NULL){

      struct Block *tempBlock = currentBlock -> next;

      tempBlock -> prev = currentBlock;

    }

  }



  //If the block before the one being freed is empty, change the current block to the previous one

  //and do the same procedure as above to coalesce the two together

  if(currentBlock != head && currentBlock -> prev -> occ == 0){

    currentBlock = currentBlock -> prev;

    currentBlock -> size = currentBlock -> size + currentBlock -> next -> size;

    currentBlock -> next = currentBlock -> next -> next;

    if(currentBlock -> next != NULL){

      currentBlock -> next -> prev = currentBlock;

    }

  }



  //If the free block is next to the end of the heap, decrease the size of the heap

  //by disbanding the last block

  if(currentBlock -> next == NULL){

    int sizeDecrease = 0 - currentBlock -> size;

    sbrk(sizeDecrease);

    if(currentBlock == head){

      brk(head);

      head = NULL;

    }

    else{

      currentBlock -> prev -> next == NULL;

    }

  }

}

and my testing program:

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>



void *my_malloc(int size);

void my_free(void *data);



//include your code





//replace malloc here with the appropriate version of my_malloc

#define MALLOC my_malloc

//replace free here with the appropriate version of my_free

#define FREE my_free

//define DUMP_HEAP() to be dump_heap() when you are done

#define DUMP_HEAP()



int main()

{

  char *dummy = MALLOC(23 + 24 * 5);

  FREE(dummy);

  DUMP_HEAP();



  char *this = MALLOC(5);

  char *is = MALLOC(3);

  char *a = MALLOC(2);

  char *test = MALLOC(5);

  char *program = MALLOC(8);

  DUMP_HEAP();



  strcpy(this, "this");

  strcpy(is, "is");

  strcpy(a, "a");

  strcpy(test, "test");

  strcpy(program, "program");

  printf("%s %s %s %s %sn", this, is, a, test, program);

  DUMP_HEAP();



  FREE(is);

  FREE(test);

  printf("%s %s %s %s %sn", this, "*", a, "*", program);

  DUMP_HEAP();



  FREE(this);

  printf("%s %s %s %s %sn", "*", "*", a, "*", program);

  DUMP_HEAP();



  this = MALLOC(5);

//TROUBLESHOOTING: PRINT WHAT'S ACTUALLY BEING RETURNED

printf("%d ", (char *)this);

  strcpy(this, "this");

  printf("%s %s %s %s %sn", this, "*", a, "*", program);

  DUMP_HEAP();



  is = MALLOC(3);

  test = MALLOC(5);

//MORE TROUBLESHOOTING

printf("%d ", (char *)test);

  strcpy(is, "is");

  strcpy(test, "test");

  printf("%s %s %s %s %sn", this, is, a, test, program);

  DUMP_HEAP();



  FREE(test);

  FREE(is);

  FREE(a);

  FREE(this);

  FREE(program);

  printf("%s %s %s %s %sn", "*", "*", "*", "*", "*");

  DUMP_HEAP();



  return 0;

}

The issue I'm having here is a seg fault when the line FREE(this) runs at the end of the program. I assume this is because of the wrong pointer being returned from my my_malloc function. I apologize for the code not being super concise, thanks in advance for any help though!