malloc.c

#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
typedef char ALIGN[16];
typedef union header {
  struct {
    size_t size;
    bool is_free;
    union header *next;
  } s;
  ALIGN stub;

} header_t;

pthread_mutex_t global_malloc_lock;

header_t *head, *tail;

header_t *get_free_block(size_t size) {
  header_t *current = head;
  while (current) {
    if (current->s.is_free && current->s.size >= size)
      return current;
    current = current->s.next;
  }
  return NULL;
}

void *mem_malloc(size_t size) {
  void *memblock;
  header_t *header;
  if (!size)
    return NULL;

  pthread_mutex_lock(&global_malloc_lock);
  header = get_free_block(size);
  if (header) {
    header->s.is_free = 0;
    pthread_mutex_unlock(&global_malloc_lock);
    return (void *)(header + 1);
  }
  size_t totalsize = sizeof(header_t) + size;
  memblock = sbrk(totalsize);
  if (memblock == (void *)-1) {
    pthread_mutex_unlock(&global_malloc_lock);
    return NULL;
  }

  header = memblock;
  header->s.size = size;
  header->s.is_free = false;
  header->s.next = NULL;
  if (!head) {
    head = header;
  }
  if (tail)
    tail->s.next = header;
  tail = header;
  pthread_mutex_unlock(&global_malloc_lock);
  return (void *)(header + 1);
}

void mem_free(void *memblock) {
  header_t *header, *tmp;
  void *prog_break;

  if (!memblock)
    return;
  pthread_mutex_lock(&global_malloc_lock);
  header = (header_t *)memblock - 1;

  prog_break = sbrk(0);
  if ((char *)memblock + header->s.size == prog_break) {
    if (head == tail) {
      head = tail = NULL;
    } else {
      tmp = head;
      while (tmp) {
        if (tmp->s.next == tail) {
          tmp->s.next = NULL;
          tail = tmp;
        }
        tmp = tmp->s.next;
      }
    }
    sbrk(0 - sizeof(header_t) - header->s.size);
    pthread_mutex_unlock(&global_malloc_lock);
    return;
  }
  header->s.is_free = true;
  pthread_mutex_unlock(&global_malloc_lock);
}

void *mem_calloc(size_t num, size_t size) {
  size_t tsize;
  void *memblock;

  if (!num || !size)
    return NULL;

  tsize = num * size;

  if (size != tsize / num)
    return NULL;

  memblock = mem_malloc(tsize);
  if (!memblock)
    return NULL;

  memset(memblock, 0, size);
  return memblock;
}

void *mem_realloc(void *memblock, size_t size) {
  header_t *header;
  void *ret; // unknown
  if (!memblock || !size)
    return mem_malloc(size);
  header = (header_t *)memblock - 1;
  if (header->s.size >= size) {
    return memblock;
  }
  ret = mem_malloc(size);
  if (ret) {
    memcpy(ret, memblock, header->s.size);
    mem_free(memblock);
  }
  return ret;
}