core/mem/malloc.c

   1 /*
   2  * malloc.c
   3  *
   4  * Very simple linked-list based malloc()/free().
   5  */
   6
   7 #include <stdlib.h>
   8 #include <errno.h>
   9 #include <string.h>
  10 #include <dprintf.h>
  11 #include "malloc.h"
  12
  13 static void *__malloc_from_block(struct free_arena_header *fp,
  14                                  size_t size, malloc_tag_t tag)
  15 {
  16     size_t fsize;
  17     struct free_arena_header *nfp, *na;
  18     unsigned int heap = ARENA_HEAP_GET(fp->a.attrs);
  19
  20     fsize = ARENA_SIZE_GET(fp->a.attrs);
  21
  22     /* We need the 2* to account for the larger requirements of a free block */
  23     if ( fsize >= size+2*sizeof(struct arena_header) ) {
  24         /* Bigger block than required -- split block */
  25         nfp = (struct free_arena_header *)((char *)fp + size);
  26         na = fp->a.next;
  27
  28         ARENA_TYPE_SET(nfp->a.attrs, ARENA_TYPE_FREE);
  29         ARENA_HEAP_SET(nfp->a.attrs, heap);
  30         ARENA_SIZE_SET(nfp->a.attrs, fsize-size);
  31         nfp->a.tag = MALLOC_FREE;
  32         ARENA_TYPE_SET(fp->a.attrs, ARENA_TYPE_USED);
  33         ARENA_SIZE_SET(fp->a.attrs, size);
  34         fp->a.tag = tag;
  35
  36         /* Insert into all-block chain */
  37         nfp->a.prev = fp;
  38         nfp->a.next = na;
  39         na->a.prev = nfp;
  40         fp->a.next = nfp;
  41
  42         /* Replace current block on free chain */
  43         nfp->next_free = fp->next_free;
  44         nfp->prev_free = fp->prev_free;
  45         fp->next_free->prev_free = nfp;
  46         fp->prev_free->next_free = nfp;
  47     } else {
  48         /* Allocate the whole block */
  49         ARENA_TYPE_SET(fp->a.attrs, ARENA_TYPE_USED);
  50         fp->a.tag = tag;
  51
  52         /* Remove from free chain */
  53         fp->next_free->prev_free = fp->prev_free;
  54         fp->prev_free->next_free = fp->next_free;
  55     }
  56
  57     return (void *)(&fp->a + 1);
  58 }
  59
  60 static void *_malloc(size_t size, enum heap heap, malloc_tag_t tag)
  61 {
  62     struct free_arena_header *fp;
  63     struct free_arena_header *head = &__malloc_head[heap];
  64     void *p = NULL;
  65
  66     dprintf("_malloc(%zu, %u, %u) @ %p = ",
  67             size, heap, tag, __builtin_return_address(0));
  68
  69     if (size) {
  70         /* Add the obligatory arena header, and round up */
  71         size = (size + 2 * sizeof(struct arena_header) - 1) & ARENA_SIZE_MASK;
  72
  73         for ( fp = head->next_free ; fp != head ; fp = fp->next_free ) {
  74             if ( ARENA_SIZE_GET(fp->a.attrs) >= size ) {
  75                 /* Found fit -- allocate out of this block */
  76                 p = __malloc_from_block(fp, size, tag);
  77                 break;
  78             }
  79         }
  80     }
  81
  82     dprintf("%p\n", p);
  83     return p;
  84 }
  85
  86 void *malloc(size_t size)
  87 {
  88     return _malloc(size, HEAP_MAIN, MALLOC_CORE);
  89 }
  90
  91 void *lmalloc(size_t size)
  92 {
  93     return _malloc(size, HEAP_LOWMEM, MALLOC_CORE);
  94 }
  95
  96 void *pmapi_lmalloc(size_t size)
  97 {
  98     return _malloc(size, HEAP_LOWMEM, MALLOC_MODULE);
  99 }