1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
* free.c
*
* Very simple linked-list based malloc()/free().
*/
#include <stdlib.h>
#include <dprintf.h>
#include "malloc.h"
static struct free_arena_header *
__free_block(struct free_arena_header *ah)
{
struct free_arena_header *pah, *nah;
struct free_arena_header *head =
&__malloc_head[ARENA_HEAP_GET(ah->a.attrs)];
pah = ah->a.prev;
nah = ah->a.next;
if ( ARENA_TYPE_GET(pah->a.attrs) == ARENA_TYPE_FREE &&
(char *)pah+ARENA_SIZE_GET(pah->a.attrs) == (char *)ah ) {
/* Coalesce into the previous block */
ARENA_SIZE_SET(pah->a.attrs, ARENA_SIZE_GET(pah->a.attrs) +
ARENA_SIZE_GET(ah->a.attrs));
pah->a.next = nah;
nah->a.prev = pah;
#ifdef DEBUG_MALLOC
ARENA_TYPE_SET(ah->a.attrs, ARENA_TYPE_DEAD);
#endif
ah = pah;
pah = ah->a.prev;
} else {
/* Need to add this block to the free chain */
ARENA_TYPE_SET(ah->a.attrs, ARENA_TYPE_FREE);
ah->a.tag = MALLOC_FREE;
ah->next_free = head->next_free;
ah->prev_free = head;
head->next_free = ah;
ah->next_free->prev_free = ah;
}
/* In either of the previous cases, we might be able to merge
with the subsequent block... */
if ( ARENA_TYPE_GET(nah->a.attrs) == ARENA_TYPE_FREE &&
(char *)ah+ARENA_SIZE_GET(ah->a.attrs) == (char *)nah ) {
ARENA_SIZE_SET(ah->a.attrs, ARENA_SIZE_GET(ah->a.attrs) +
ARENA_SIZE_GET(nah->a.attrs));
/* Remove the old block from the chains */
nah->next_free->prev_free = nah->prev_free;
nah->prev_free->next_free = nah->next_free;
ah->a.next = nah->a.next;
nah->a.next->a.prev = ah;
#ifdef DEBUG_MALLOC
ARENA_TYPE_SET(nah->a.attrs, ARENA_TYPE_DEAD);
#endif
}
/* Return the block that contains the called block */
return ah;
}
void free(void *ptr)
{
struct free_arena_header *ah;
dprintf("free(%p) @ %p\n", ptr, __builtin_return_address(0));
if ( !ptr )
return;
ah = (struct free_arena_header *)
((struct arena_header *)ptr - 1);
#ifdef DEBUG_MALLOC
assert( ARENA_TYPE_GET(ah->a.attrs) == ARENA_TYPE_USED );
#endif
__free_block(ah);
/* Here we could insert code to return memory to the system. */
}
/*
* This is used to insert a block which is not previously on the
* free list. Only the a.size field of the arena header is assumed
* to be valid.
*/
void __inject_free_block(struct free_arena_header *ah)
{
struct free_arena_header *head =
&__malloc_head[ARENA_HEAP_GET(ah->a.attrs)];
struct free_arena_header *nah;
size_t a_end = (size_t) ah + ARENA_SIZE_GET(ah->a.attrs);
size_t n_end;
dprintf("inject: %#zx bytes @ %p, heap %u (%p)\n",
ARENA_SIZE_GET(ah->a.attrs), ah,
ARENA_HEAP_GET(ah->a.attrs), head);
for (nah = head->a.next ; nah != head ; nah = nah->a.next) {
n_end = (size_t) nah + ARENA_SIZE_GET(nah->a.attrs);
/* Is nah entirely beyond this block? */
if ((size_t) nah >= a_end)
break;
/* Is this block entirely beyond nah? */
if ((size_t) ah >= n_end)
continue;
/* Otherwise we have some sort of overlap - reject this block */
return;
}
/* Now, nah should point to the successor block */
ah->a.next = nah;
ah->a.prev = nah->a.prev;
nah->a.prev = ah;
ah->a.prev->a.next = ah;
__free_block(ah);
}
/*
* Free all memory which is tagged with a specific tag.
*/
static void __free_tagged(malloc_tag_t tag) {
struct free_arena_header *fp, *head;
int i;
for (i = 0; i < NHEAP; i++) {
dprintf("__free_tagged(%u) heap %d\n", tag, i);
head = &__malloc_head[i];
for (fp = head ; fp != head ; fp = fp->a.next) {
if (ARENA_TYPE_GET(fp->a.attrs) == ARENA_TYPE_USED &&
fp->a.tag == tag)
fp = __free_block(fp);
}
}
dprintf("__free_tagged(%u) done\n", tag);
}
void comboot_cleanup_lowmem(com32sys_t *regs)
{
(void)regs;
__free_tagged(MALLOC_MODULE);
}
|
