* This file is part of the libpayload project.
*
* Copyright (C) 2008 Advanced Micro Devices, Inc.
+ * Copyright (C) 2008-2010 coresystems GmbH
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* your buffers, kids!).
*/
+#define IN_MALLOC_C
#include <libpayload.h>
extern char _heap, _eheap; /* Defined in the ldscript. */
static int free_aligned(void* addr);
void print_malloc_map(void);
-static void setup(void)
+#ifdef CONFIG_DEBUG_MALLOC
+static int heap_initialized = 0;
+static int minimal_free = 0;
+#endif
+
+static void setup(hdrtype_t volatile *start, int size)
{
- int size = (unsigned int)(&_eheap - &_heap) - HDRSIZE;
+ *start = FREE_BLOCK(size);
- *((hdrtype_t *) hstart) = FREE_BLOCK(size);
+#ifdef CONFIG_DEBUG_MALLOC
+ heap_initialized = 1;
+ minimal_free = size;
+#endif
}
static void *alloc(int len)
{
hdrtype_t header;
- void *ptr = hstart;
+ hdrtype_t volatile *ptr = (hdrtype_t volatile *) hstart;
/* Align the size. */
len = (len + 3) & ~3;
return (void *)NULL;
/* Make sure the region is setup correctly. */
- if (!HAS_MAGIC(*((hdrtype_t *) ptr)))
- setup();
+ if (!HAS_MAGIC(*ptr))
+ setup(ptr, (int)((&_eheap - &_heap) - HDRSIZE));
/* Find some free space. */
do {
- header = *((hdrtype_t *) ptr);
+ header = *ptr;
int size = SIZE(header);
if (!HAS_MAGIC(header) || size == 0) {
- printf("memory allocator panic.\n");
+ printf("memory allocator panic. (%s%s)\n",
+ !HAS_MAGIC(header) ? " no magic " : "",
+ size == 0 ? " size=0 " : "");
halt();
}
if (header & FLAG_FREE) {
if (len <= size) {
- void *nptr = ptr + (HDRSIZE + len);
+ hdrtype_t volatile *nptr = (hdrtype_t volatile *)((int)ptr + HDRSIZE + len);
int nsize = size - (HDRSIZE + len);
- /* Mark the block as used. */
- *((hdrtype_t *) ptr) = USED_BLOCK(len);
-
/* If there is still room in this block,
- * then mark it as such.
+ * then mark it as such otherwise account
+ * the whole space for that block.
*/
- if (nsize > 0)
- *((hdrtype_t *) nptr) =
- FREE_BLOCK(nsize);
+ if (nsize > 0) {
+ /* Mark the block as used. */
+ *ptr = USED_BLOCK(len);
- return (void *)(ptr + HDRSIZE);
+ /* Create a new free block. */
+ *nptr = FREE_BLOCK(nsize);
+ } else {
+ /* Mark the block as used. */
+ *ptr = USED_BLOCK(size);
+ }
+
+ return (void *)((int)ptr + HDRSIZE);
}
}
- ptr += HDRSIZE + size;
+ ptr = (hdrtype_t volatile *)((int)ptr + HDRSIZE + size);
- } while (ptr < hend);
+ } while (ptr < (hdrtype_t *) hend);
/* Nothing available. */
return (void *)NULL;
static struct align_region_t* align_regions = 0;
-static struct align_region_t *allocate_region(struct align_region_t *old_first, int alignment, int num_elements)
+static struct align_region_t *allocate_region(int alignment, int num_elements)
{
- struct align_region_t *new_region = malloc(sizeof(struct align_region_t));
+ struct align_region_t *new_region;
+#ifdef CONFIG_DEBUG_MALLOC
+ printf("%s(old align_regions=%p, alignment=%u, num_elements=%u)\n",
+ __func__, align_regions, alignment, num_elements);
+#endif
+
+ new_region = malloc(sizeof(struct align_region_t));
+
+ if (!new_region)
+ return NULL;
new_region->alignment = alignment;
new_region->start = malloc((num_elements+1) * alignment + num_elements);
+ if (!new_region->start) {
+ free(new_region);
+ return NULL;
+ }
new_region->start_data = (void*)((u32)(new_region->start + num_elements + alignment - 1) & (~(alignment-1)));
new_region->size = num_elements * alignment;
new_region->free = num_elements;
- new_region->next = old_first;
+ new_region->next = align_regions;
memset(new_region->start, 0, num_elements);
+ align_regions = new_region;
return new_region;
}
if (size == 0) return 0;
if (align_regions == 0) {
align_regions = malloc(sizeof(struct align_region_t));
+ if (align_regions == NULL)
+ return NULL;
memset(align_regions, 0, sizeof(struct align_region_t));
}
struct align_region_t *reg = align_regions;
-look_further:
+look_further:
while (reg != 0)
{
if ((reg->alignment == align) && (reg->free >= (size + align - 1)/align))
{
+#ifdef CONFIG_DEBUG_MALLOC
+ printf(" found memalign region. %x free, %x required\n", reg->free, (size + align - 1)/align);
+#endif
break;
}
reg = reg->next;
}
if (reg == 0)
{
- align_regions = allocate_region(align_regions, align, (size/align<99)?100:((size/align)+1));
- reg = align_regions;
+#ifdef CONFIG_DEBUG_MALLOC
+ printf(" need to allocate a new memalign region\n");
+#endif
+ /* get align regions */
+ reg = allocate_region(align, (size<1024)?(1024/align):(((size-1)/align)+1));
+#ifdef CONFIG_DEBUG_MALLOC
+ printf(" ... returned %p\n", align_regions);
+#endif
}
+ if (reg == 0) {
+ /* Nothing available. */
+ return (void *)NULL;
+ }
+
int i, count = 0, target = (size+align-1)/align;
for (i = 0; i < (reg->size/align); i++)
{
}
/* This is for debugging purposes. */
-#ifdef TEST
+#ifdef CONFIG_DEBUG_MALLOC
void print_malloc_map(void)
{
void *ptr = hstart;
+ int free_memory = 0;
while (ptr < hend) {
hdrtype_t hdr = *((hdrtype_t *) ptr);
if (!HAS_MAGIC(hdr)) {
- printf("Poisoned magic - we're toast\n");
+ if (heap_initialized)
+ printf("Poisoned magic - we're toast\n");
+ else
+ printf("No magic yet - going to initialize\n");
break;
}
(unsigned int)(ptr - hstart),
hdr & FLAG_FREE ? "FREE" : "USED", SIZE(hdr));
+ if (hdr & FLAG_FREE)
+ free_memory += SIZE(hdr);
+
ptr += HDRSIZE + SIZE(hdr);
}
+
+ if (free_memory && (minimal_free > free_memory))
+ minimal_free = free_memory;
+ printf("Maximum memory consumption: %d bytes\n",
+ (unsigned int)(&_eheap - &_heap) - HDRSIZE - minimal_free);
}
#endif
projects / coreboot.git / blobdiff