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  */
simple_malloc(unsigned long size)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 
simple_find_entry(void * ptr)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 
simple_free(void * ptr)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  */
simple_realloc(void * ptr,unsigned long size)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  */
simple_alloc_init(char * base,unsigned long heap_size,unsigned long granularity,unsigned long max_allocs)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 }
151