Desktop/xinu_mips-1.0.2.tar/xinu_mips-1.0.2/system/freemem.c

Go to the documentation of this file.

/* Embedded XINU, Copyright (C) 2007.  All rights reserved. */

#include <kernel.h>
#include <platform.h>
#include <memory.h>

extern void *end;

syscall freemem(void *pmem)
{
        struct memblock *block, *next, *prev;
        irqmask ps;
        ulong top, size;

        /* block points at the memblock we want to free */ 
        block = (struct memblock *)pmem;
        /* back up to accounting information */
        block--;

        /* Simple check to make sure block is in heap */
        ASSERT( (ulong)block >= (ulong)minheap );
        ASSERT( (ulong)block < (ulong)platform.maxaddr );

        ps = disable();

    /* consistency checks for block, set up in getmem */
        if ( (block->next != block) || (block->length == 0) )
        {
                restore(ps);
                return SYSERR;
        }

        size = block->length;

        /* In order to keep the freelist well-ordered */
        /* position prev < block && block < next      */
        prev = &freelist;
        next = freelist.next;
        while ( (next != NULL) && (next < block) )
        {
                prev = next;
                next = next->next;
        }

        /* find top of previous memblock */
        /* top is meaningless if prev is the freelist, so set  */
        /* top to a meaningless value (which will fail all tests)    */
        /* otherwise, top is the previous pointer + length of ptr    */
        if (prev == &freelist) { top = NULL; }
        else { top = (ulong)prev + prev->length; }

        /* make sure block is not overlapping on prev or next blocks */
        /* next == NULL is a special case (end of the freelist)      */
        if ( ( top > (ulong)block )
          || ( (next != NULL) && ((ulong)block + size) > (ulong)next ) )
        {
                restore(ps);
                return SYSERR;
        }

        /* maintain freelist length */
        freelist.length += block->length;

        /* Now for some simple memblock coalescing */
        /* are prev and block contiguous? */
        if ( top == (ulong)block )
        {
                /* yes, then coalesce prev & block */
                prev->length += size;

                /* sanitize the coalesced block */
                block->next   = NULL;
                block->length = 0;

                /* set block to prev for block&next coalesce check */
                block = prev;
        }
        else 
        {
                /* no, return block to free list */
                block->next = next;
                prev->next = block;
        }

        /* are block and next contiguous? */
        if ( (ulong)((ulong)block + block->length) == (ulong)next ) 
        {
                /* yes, coalesce block & next */
                block->length += next->length;
                block->next    = next->next;

                /* sanitize next */
                next->next   = NULL;
                next->length = 0;
        }

        restore(ps);
        return OK;
}

---