summaryrefslogtreecommitdiff
path: root/src/lib/malloc.c
blob: ddc7ea57398f1c80d6e5412ff3539b45647c7c0e (plain)
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
#include <stdlib.h>
#include <console/console.h>
#include <cpu/x86/smm.h>

#if CONFIG(DEBUG_MALLOC)
#define MALLOCDBG(x...) printk(BIOS_SPEW, x)
#else
#define MALLOCDBG(x...)
#endif

extern unsigned char _heap, _eheap;
static void *free_mem_ptr = &_heap;		/* Start of heap */
static void *free_mem_end_ptr = &_eheap;	/* End of heap */
static void *free_last_alloc_ptr = &_heap;	/* End of heap before
						   last allocation */

/* We don't restrict the boundary. This is firmware,
 * you are supposed to know what you are doing.
 */
void *memalign(size_t boundary, size_t size)
{
	void *p;

	MALLOCDBG("%s Enter, boundary %zu, size %zu, free_mem_ptr %p\n",
		__func__, boundary, size, free_mem_ptr);

	free_mem_ptr = (void *)ALIGN((unsigned long)free_mem_ptr, boundary);

	p = free_mem_ptr;
	free_mem_ptr += size;
	/*
	 * Store last allocation pointer after ALIGN, as malloc() will
	 * return it. This may cause n bytes of gap between allocations
	 * where n < boundary.
	 */
	free_last_alloc_ptr = p;

	if (free_mem_ptr >= free_mem_end_ptr) {
		printk(BIOS_ERR, "memalign(boundary=%zu, size=%zu): failed: ",
				boundary, size);
		printk(BIOS_ERR, "Tried to round up free_mem_ptr %p to %p\n",
				p, free_mem_ptr);
		printk(BIOS_ERR, "but free_mem_end_ptr is %p\n",
				free_mem_end_ptr);
		die("Error! memalign: Out of memory (free_mem_ptr >= free_mem_end_ptr)");
	}

	MALLOCDBG("memalign %p\n", p);

	return p;
}

void *malloc(size_t size)
{
	return memalign(sizeof(u64), size);
}

void free(void *ptr)
{
	if (ptr == NULL)
		return;

	if (ptr < (void *)&_heap || ptr >= free_mem_end_ptr) {
		printk(BIOS_WARNING, "Warning - Pointer passed to %s is not "
					"pointing to the heap\n", __func__);
		return;
	}

	/*
	 * Rewind the heap pointer to the end of heap
	 * before the last successful malloc().
	 */
	if (ptr == free_last_alloc_ptr) {
		free_mem_ptr = free_last_alloc_ptr;
		free_last_alloc_ptr = NULL;
	}
}