root/arch/powerpc/boot/simple_alloc.c

DEFINITIONS

1. simple_malloc
2. simple_find_entry
3. simple_free
4. simple_realloc
5. simple_alloc_init

   1 /*
   2  * Implement primitive realloc(3) functionality.
   3  *
   4  * Author: Mark A. Greer <mgreer@mvista.com>
   5  *
   6  * 2006 (c) MontaVista, Software, Inc.  This file is licensed under
   7  * the terms of the GNU General Public License version 2.  This program
   8  * is licensed "as is" without any warranty of any kind, whether express
   9  * or implied.
  10  */
  11 
  12 #include <stddef.h>
  13 #include "types.h"
  14 #include "page.h"
  15 #include "string.h"
  16 #include "ops.h"
  17 
  18 #define ENTRY_BEEN_USED 0x01
  19 #define ENTRY_IN_USE    0x02
  20 
  21 static struct alloc_info {
  22         unsigned long   flags;
  23         unsigned long   base;
  24         unsigned long   size;
  25 } *alloc_tbl;
  26 
  27 static unsigned long tbl_entries;
  28 static unsigned long alloc_min;
  29 static unsigned long next_base;
  30 static unsigned long space_left;
  31 
  32 /*
  33  * First time an entry is used, its base and size are set.
  34  * An entry can be freed and re-malloc'd but its base & size don't change.
  35  * Should be smart enough for needs of bootwrapper.
  36  */
  37 static void *simple_malloc(unsigned long size)
  38 {
  39         unsigned long i;
  40         struct alloc_info *p = alloc_tbl;
  41 
  42         if (size == 0)
  43                 goto err_out;
  44 
  45         size = _ALIGN_UP(size, alloc_min);
  46 
  47         for (i=0; i<tbl_entries; i++, p++)
  48                 if (!(p->flags & ENTRY_BEEN_USED)) { /* never been used */
  49                         if (size <= space_left) {
  50                                 p->base = next_base;
  51                                 p->size = size;
  52                                 p->flags = ENTRY_BEEN_USED | ENTRY_IN_USE;
  53                                 next_base += size;
  54                                 space_left -= size;
  55                                 return (void *)p->base;
  56                         }
  57                         goto err_out; /* not enough space left */
  58                 }
  59                 /* reuse an entry keeping same base & size */
  60                 else if (!(p->flags & ENTRY_IN_USE) && (size <= p->size)) {
  61                         p->flags |= ENTRY_IN_USE;
  62                         return (void *)p->base;
  63                 }
  64 err_out:
  65         return NULL;
  66 }
  67 
  68 static struct alloc_info *simple_find_entry(void *ptr)
  69 {
  70         unsigned long i;
  71         struct alloc_info *p = alloc_tbl;
  72 
  73         for (i=0; i<tbl_entries; i++,p++) {
  74                 if (!(p->flags & ENTRY_BEEN_USED))
  75                         break;
  76                 if ((p->flags & ENTRY_IN_USE) &&
  77                     (p->base == (unsigned long)ptr))
  78                         return p;
  79         }
  80         return NULL;
  81 }
  82 
  83 static void simple_free(void *ptr)
  84 {
  85         struct alloc_info *p = simple_find_entry(ptr);
  86 
  87         if (p != NULL)
  88                 p->flags &= ~ENTRY_IN_USE;
  89 }
  90 
  91 /*
  92  * Change size of area pointed to by 'ptr' to 'size'.
  93  * If 'ptr' is NULL, then its a malloc().  If 'size' is 0, then its a free().
  94  * 'ptr' must be NULL or a pointer to a non-freed area previously returned by
  95  * simple_realloc() or simple_malloc().
  96  */
  97 static void *simple_realloc(void *ptr, unsigned long size)
  98 {
  99         struct alloc_info *p;
 100         void *new;
 101 
 102         if (size == 0) {
 103                 simple_free(ptr);
 104                 return NULL;
 105         }
 106 
 107         if (ptr == NULL)
 108                 return simple_malloc(size);
 109 
 110         p = simple_find_entry(ptr);
 111         if (p == NULL) /* ptr not from simple_malloc/simple_realloc */
 112                 return NULL;
 113         if (size <= p->size) /* fits in current block */
 114                 return ptr;
 115 
 116         new = simple_malloc(size);
 117         memcpy(new, ptr, p->size);
 118         simple_free(ptr);
 119         return new;
 120 }
 121 
 122 /*
 123  * Returns addr of first byte after heap so caller can see if it took
 124  * too much space.  If so, change args & try again.
 125  */
 126 void *simple_alloc_init(char *base, unsigned long heap_size,
 127                         unsigned long granularity, unsigned long max_allocs)
 128 {
 129         unsigned long heap_base, tbl_size;
 130 
 131         heap_size = _ALIGN_UP(heap_size, granularity);
 132         alloc_min = granularity;
 133         tbl_entries = max_allocs;
 134 
 135         tbl_size = tbl_entries * sizeof(struct alloc_info);
 136 
 137         alloc_tbl = (struct alloc_info *)_ALIGN_UP((unsigned long)base, 8);
 138         memset(alloc_tbl, 0, tbl_size);
 139 
 140         heap_base = _ALIGN_UP((unsigned long)alloc_tbl + tbl_size, alloc_min);
 141 
 142         next_base = heap_base;
 143         space_left = heap_size;
 144 
 145         platform_ops.malloc = simple_malloc;
 146         platform_ops.free = simple_free;
 147         platform_ops.realloc = simple_realloc;
 148 
 149         return (void *)(heap_base + heap_size);
 150 }