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