memory.c

一个微型操作系统源码

/* 
    based on creatOS MM
 */

#include <mm.h>

memlink *pFree = NULL;         // points to the first free link
memlink *pUsed = NULL;         // points to last allocated link


void setupMemory(ulong available,ulong used)
{
   /* initialize starting memlinks */
   pUsed = NULL;

   pFree = (memlink*)used;
   pFree->pPrev = NULL;
   pFree->pNext  = NULL;
   pFree->size  = available - used;
   pFree->owner = OWNER_NOBODY;
}

void *physAlloc(size_t allocsize, ulong client)
{
   memlink* pNewLink = NULL;
   memlink* pLink = pFree;

   while (pLink != NULL) {

      /* is there a larger block? */
      if (pLink->size >= (allocsize + sizeof(memlink)) ) {

         /* divide the free space */
         pNewLink = (memlink*) ((ulong)pLink + sizeof(memlink) + allocsize);
         pNewLink->pNext = pLink->pNext;
         pNewLink->pPrev = pLink->pPrev;
         pNewLink->size  = (pLink->size) - (allocsize + sizeof(memlink));
         pNewLink->owner = OWNER_NOBODY;

         /* correct pNext of previous memlink */
         if (pNewLink->pPrev == NULL) { 
            /* new base link */                                
            pFree = pNewLink;
         } else {                
            /* point to our new link */                                
            (pNewLink->pPrev)->pNext = pNewLink;
         }

         /* prepare pLink for usage and    */
         /* move it to start of pUsed-list */
         pLink->pPrev = NULL;
         pLink->pNext = pUsed;
         pLink->size  = allocsize;
         pLink->owner = client;

         /* if there is an allocated block, it should */
         /* point back to us */
         if (pUsed != NULL) pUsed->pPrev = pLink;

         /* Now we are the base link! */
         pUsed = pLink;
         /* return with valid pointer */
         return( (void *) ((ulong)pLink+sizeof(memlink)) );
      } /* if */
      pLink = pLink->pNext; /* goto the next free block */
   } /* while */
   return(NULL); /* no memory available */
}        

/* alpha free() function*/
void physFree(void *pointer)
{
   memlink* pLink = (memlink*) ((ulong)pointer - sizeof(memlink));
   memlink* pPrevLink = pLink->pPrev;
   memlink* pNextLink = pLink->pNext;
   memlink* pFreeLink = NULL;
   /* remove pLink from "used"-list */
   if (pPrevLink == NULL) {
      /* we are the base link, change it*/
      pUsed = pNextLink;
   } else {
       /* change link that points to us */
       pPrevLink->pNext = pNextLink;
   }

   if (pNextLink != NULL) {
      pNextLink->pPrev = pPrevLink;
   }

   /* add pLink to "free"-list */

   if (pFree == NULL) {
      /* There is no free block available, so we are the first one */
      pFree = pLink;
      pFree->pPrev = NULL;
      pFree->pNext = NULL;
      pFree->owner = OWNER_NOBODY;
   } else {
      /* go through the list and find a between two other links */
      pFreeLink = pFree;

      while ((pFreeLink->pNext != NULL) && (pFreeLink < pLink)) {
         pFreeLink = pFreeLink->pNext;
      }

      pLink->pPrev = pFreeLink->pPrev;
      pLink->pNext = pFreeLink;
      pLink->owner = OWNER_NOBODY;

      if (pFreeLink->pPrev == NULL) {  // have to change base link?
         pFree = pLink;
      } else {
         (pFreeLink->pPrev)->pNext = pLink;
      }

      if (pFreeLink != NULL) {
         pFreeLink->pPrev = pLink;
      }


      /* --------------------------------- */
      /* try to put memory blocks together */
      /* --------------------------------- */

      pPrevLink = pLink->pPrev;
      pNextLink = pLink->pNext;

      /* check if pNextLink block lies directly */
      /* behind the pLink block                 */
      if (((ulong)pLink+sizeof(memlink)+pLink->size) == ((ulong)pNextLink)) {
         pLink->pNext = pNextLink->pNext;
         if (pNextLink->pNext != NULL) { 
            /* set back link */
            (pNextLink->pNext)->pPrev = pLink;
         }
         pLink->size = (pLink->size) + sizeof(memlink) + (pNextLink->size);

      }

      /* check if pLink block lies directly     */
      /* behind the pPrevLink block             */

      if (pPrevLink != NULL)
         if (((ulong)pPrevLink+sizeof(memlink)+pPrevLink->size)==((ulong)pLink) ) {
            pPrevLink->pNext = pLink->pNext;
            if (pLink->pNext != NULL) {
               /* set back link */
               (pLink->pNext)->pPrev = pPrevLink;
            }
            pPrevLink->size = (pPrevLink->size) + sizeof(memlink) + (pLink->size);

      }

   } // else 
}

void *kmalloc(size_t allocsize) {
   void *ptr;
   if ((ptr=physAlloc(PAGE_ROUND_UP(allocsize),OWNER_KERNEL)) == NULL) 
      return NULL;
   vmMapRange((void *)PD,ptr,allocsize,VMM_BUSY);
   return ptr; 
}

void kfree(void *pointer) {
   int result;
   memlink *pLink = (memlink*) ((ulong)pointer - sizeof(memlink));
   size_t size = pLink->size;
   if ((result=vmUnmapRange((void *)PD,pointer,size))==0)
      physFree(pointer);
}