X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=payloads%2Flibpayload%2Flibc%2Fmalloc.c;h=3c5a3fd2a2c7b4b9a29fa4b2051a8926ca10f43b;hb=ccee6256b48ad619d16c4479a25937fa95b93efc;hp=24daf0e680470259372c3e567ac379faf1676e69;hpb=1ff26a777835c740610f549f00bcd450ae571c0e;p=coreboot.git diff --git a/payloads/libpayload/libc/malloc.c b/payloads/libpayload/libc/malloc.c index 24daf0e68..3c5a3fd2a 100644 --- a/payloads/libpayload/libc/malloc.c +++ b/payloads/libpayload/libc/malloc.c @@ -2,6 +2,7 @@ * 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 @@ -38,6 +39,7 @@ * your buffers, kids!). */ +#define IN_MALLOC_C #include extern char _heap, _eheap; /* Defined in the ldscript. */ @@ -66,17 +68,25 @@ typedef unsigned int hdrtype_t; 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; @@ -85,42 +95,49 @@ static void *alloc(int len) 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; @@ -262,16 +279,30 @@ struct align_region_t 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; } @@ -303,23 +334,39 @@ void *memalign(size_t align, size_t size) 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++) { @@ -344,16 +391,20 @@ look_further: } /* 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; } @@ -363,7 +414,15 @@ void print_malloc_map(void) (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