Return to malloc.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / lib / libc / stdlib

Annotation of qemu/roms/SLOF/lib/libc/stdlib/malloc.c, revision 1.1

1.1     ! root        1: /******************************************************************************
        !             2:  * Copyright (c) 2004, 2008 IBM Corporation
        !             3:  * All rights reserved.
        !             4:  * This program and the accompanying materials
        !             5:  * are made available under the terms of the BSD License
        !             6:  * which accompanies this distribution, and is available at
        !             7:  * http://www.opensource.org/licenses/bsd-license.php
        !             8:  *
        !             9:  * Contributors:
        !            10:  *     IBM Corporation - initial implementation
        !            11:  *****************************************************************************/
        !            12: 
        !            13: 
        !            14: #include "stddef.h"
        !            15: #include "stdlib.h"
        !            16: #include "unistd.h"
        !            17: #include "malloc_defs.h"
        !            18: 
        !            19: 
        !            20: static int clean(void);
        !            21: 
        !            22: 
        !            23: /* act points to the end of the initialized heap and the start of uninitialized heap */
        !            24: static char *act;
        !            25: 
        !            26: /* Pointers to start and end of heap: */
        !            27: static char *heap_start, *heap_end;
        !            28: 
        !            29: 
        !            30: /*
        !            31:  * Standard malloc function
        !            32:  */
        !            33: void *
        !            34: malloc(size_t size)
        !            35: {
        !            36:        char *header;
        !            37:        void *data;
        !            38:        size_t blksize;         /* size of memory block including the chunk */
        !            39: 
        !            40:        blksize = size + sizeof(struct chunk);
        !            41: 
        !            42:        /* has malloc been called for the first time? */
        !            43:        if (act == 0) {
        !            44:                size_t initsize;
        !            45:                /* add some space so we have a good initial playground */
        !            46:                initsize = (blksize + 0x1000) & ~0x0fff;
        !            47:                /* get initial memory region with sbrk() */
        !            48:                heap_start = sbrk(initsize);
        !            49:                if (heap_start == (void*)-1)
        !            50:                        return NULL;
        !            51:                heap_end = heap_start + initsize;
        !            52:                act = heap_start;
        !            53:        }
        !            54: 
        !            55:        header = act;
        !            56:        data = act + sizeof(struct chunk);
        !            57: 
        !            58:        /* Check if there is space left in the uninitialized part of the heap */
        !            59:        if (act + blksize > heap_end) {
        !            60:                //search at begin of heap
        !            61:                header = heap_start;
        !            62: 
        !            63:                while ((((struct chunk *) header)->inuse != 0
        !            64:                        || ((struct chunk *) header)->length < size)
        !            65:                       && header < act) {
        !            66:                        header = header + sizeof(struct chunk)
        !            67:                                 + ((struct chunk *) header)->length;
        !            68:                }
        !            69: 
        !            70:                // check if heap is full
        !            71:                if (header >= act) {
        !            72:                        if (clean()) {
        !            73:                                // merging of free blocks succeeded, so try again
        !            74:                                return malloc(size);
        !            75:                        } else if (sbrk(blksize) == heap_end) {
        !            76:                                // succeeded to get more memory, so try again
        !            77:                                heap_end += blksize;
        !            78:                                return malloc(size);
        !            79:                        } else {
        !            80:                                // No more memory available
        !            81:                                return 0;
        !            82:                        }
        !            83:                }
        !            84: 
        !            85:                // Check if we need to split this memory block into two
        !            86:                if (((struct chunk *) header)->length > blksize) {
        !            87:                        //available memory is too big
        !            88:                        int alt;
        !            89: 
        !            90:                        alt = ((struct chunk *) header)->length;
        !            91:                        ((struct chunk *) header)->inuse = 1;
        !            92:                        ((struct chunk *) header)->length = size;
        !            93:                        data = header + sizeof(struct chunk);
        !            94: 
        !            95:                        //mark the rest of the heap
        !            96:                        header = data + size;
        !            97:                        ((struct chunk *) header)->inuse = 0;
        !            98:                        ((struct chunk *) header)->length =
        !            99:                            alt - blksize;
        !           100:                } else {
        !           101:                        //new memory matched exactly in available memory
        !           102:                        ((struct chunk *) header)->inuse = 1;
        !           103:                        data = header + sizeof(struct chunk);
        !           104:                }
        !           105: 
        !           106:        } else {
        !           107: 
        !           108:                ((struct chunk *) header)->inuse = 1;
        !           109:                ((struct chunk *) header)->length = size;
        !           110: 
        !           111:                act += blksize;
        !           112:        }
        !           113: 
        !           114:        return data;
        !           115: }
        !           116: 
        !           117: 
        !           118: /*
        !           119:  * Merge free memory blocks in initialized heap if possible
        !           120:  */
        !           121: static int
        !           122: clean(void)
        !           123: {
        !           124:        char *header;
        !           125:        char *firstfree = 0;
        !           126:        char check = 0;
        !           127: 
        !           128:        header = heap_start;
        !           129:        //if (act == 0)         // This should never happen
        !           130:        //      act = heap_end;
        !           131: 
        !           132:        while (header < act) {
        !           133: 
        !           134:                if (((struct chunk *) header)->inuse == 0) {
        !           135:                        if (firstfree == 0) {
        !           136:                                /* First free block in a row, only save address */
        !           137:                                firstfree = header;
        !           138: 
        !           139:                        } else {
        !           140:                                /* more than one free block in a row, merge them! */
        !           141:                                ((struct chunk *) firstfree)->length +=
        !           142:                                    ((struct chunk *) header)->length +
        !           143:                                    sizeof(struct chunk);
        !           144:                                check = 1;
        !           145:                        }
        !           146:                } else {
        !           147:                        firstfree = 0;
        !           148: 
        !           149:                }
        !           150: 
        !           151:                header = header + sizeof(struct chunk)
        !           152:                         + ((struct chunk *) header)->length;
        !           153: 
        !           154:        }
        !           155: 
        !           156:        return check;
        !           157: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.