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 { | |
22 | u32 flags; | |
23 | u32 base; | |
24 | u32 size; | |
25 | } *alloc_tbl; | |
26 | ||
27 | static u32 tbl_entries; | |
28 | static u32 alloc_min; | |
29 | static u32 next_base; | |
30 | static u32 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(u32 size) | |
38 | { | |
39 | u32 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 | u32 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) && (p->base == (u32)ptr)) | |
77 | return p; | |
78 | } | |
79 | return NULL; | |
80 | } | |
81 | ||
82 | static void simple_free(void *ptr) | |
83 | { | |
84 | struct alloc_info *p = simple_find_entry(ptr); | |
85 | ||
86 | if (p != NULL) | |
87 | p->flags &= ~ENTRY_IN_USE; | |
88 | } | |
89 | ||
90 | /* | |
91 | * Change size of area pointed to by 'ptr' to 'size'. | |
92 | * If 'ptr' is NULL, then its a malloc(). If 'size' is 0, then its a free(). | |
93 | * 'ptr' must be NULL or a pointer to a non-freed area previously returned by | |
94 | * simple_realloc() or simple_malloc(). | |
95 | */ | |
96 | static void *simple_realloc(void *ptr, unsigned long size) | |
97 | { | |
98 | struct alloc_info *p; | |
99 | void *new; | |
100 | ||
101 | if (size == 0) { | |
102 | simple_free(ptr); | |
103 | return NULL; | |
104 | } | |
105 | ||
106 | if (ptr == NULL) | |
107 | return simple_malloc(size); | |
108 | ||
109 | p = simple_find_entry(ptr); | |
110 | if (p == NULL) /* ptr not from simple_malloc/simple_realloc */ | |
111 | return NULL; | |
112 | if (size <= p->size) /* fits in current block */ | |
113 | return ptr; | |
114 | ||
115 | new = simple_malloc(size); | |
116 | memcpy(new, ptr, p->size); | |
117 | simple_free(ptr); | |
118 | return new; | |
119 | } | |
120 | ||
121 | /* | |
122 | * Returns addr of first byte after heap so caller can see if it took | |
123 | * too much space. If so, change args & try again. | |
124 | */ | |
125 | void *simple_alloc_init(char *base, u32 heap_size, u32 granularity, | |
126 | u32 max_allocs) | |
127 | { | |
128 | u32 heap_base, tbl_size; | |
129 | ||
130 | heap_size = _ALIGN_UP(heap_size, granularity); | |
131 | alloc_min = granularity; | |
132 | tbl_entries = max_allocs; | |
133 | ||
134 | tbl_size = tbl_entries * sizeof(struct alloc_info); | |
135 | ||
136 | alloc_tbl = (struct alloc_info *)_ALIGN_UP((unsigned long)base, 8); | |
137 | memset(alloc_tbl, 0, tbl_size); | |
138 | ||
139 | heap_base = _ALIGN_UP((u32)alloc_tbl + tbl_size, alloc_min); | |
140 | ||
141 | next_base = heap_base; | |
142 | space_left = heap_size; | |
143 | ||
144 | platform_ops.malloc = simple_malloc; | |
145 | platform_ops.free = simple_free; | |
146 | platform_ops.realloc = simple_realloc; | |
147 | ||
148 | return (void *)(heap_base + heap_size); | |
149 | } |