Commit | Line | Data |
---|---|---|
01a63720 MG |
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 { | |
4ca478e6 GU |
22 | unsigned long flags; |
23 | unsigned long base; | |
24 | unsigned long size; | |
01a63720 MG |
25 | } *alloc_tbl; |
26 | ||
4ca478e6 GU |
27 | static unsigned long tbl_entries; |
28 | static unsigned long alloc_min; | |
29 | static unsigned long next_base; | |
30 | static unsigned long space_left; | |
01a63720 MG |
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 | */ | |
4ca478e6 | 37 | static void *simple_malloc(unsigned long size) |
01a63720 | 38 | { |
4ca478e6 | 39 | unsigned long i; |
01a63720 MG |
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 | { | |
4ca478e6 | 70 | unsigned long i; |
01a63720 MG |
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; | |
4ca478e6 GU |
76 | if ((p->flags & ENTRY_IN_USE) && |
77 | (p->base == (unsigned long)ptr)) | |
01a63720 MG |
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 | */ | |
4ca478e6 GU |
126 | void *simple_alloc_init(char *base, unsigned long heap_size, |
127 | unsigned long granularity, unsigned long max_allocs) | |
01a63720 | 128 | { |
4ca478e6 | 129 | unsigned long heap_base, tbl_size; |
01a63720 MG |
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 | ||
4ca478e6 | 140 | heap_base = _ALIGN_UP((unsigned long)alloc_tbl + tbl_size, alloc_min); |
01a63720 MG |
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 | } |