rom/exec/freepooled.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Free memory allocated by AllocPooled().
   6     Lang: english
   7 */
   8 #include "exec_intern.h"
   9 #include <aros/libcall.h>
  10 #include "memory.h"
  11 #include <exec/memory.h>
  12 #include <proto/exec.h>
  13
  14
  15 /*****************************************************************************
  16
  17     NAME */
  18
  19         AROS_LH3(void,FreePooled,
  20
  21 /*  SYNOPSIS */
  22         AROS_LHA(APTR, poolHeader,A0),
  23         AROS_LHA(APTR, memory,    A1),
  24         AROS_LHA(ULONG,memSize,   D0),
  25
  26 /* LOCATION */
  27         struct ExecBase *, SysBase, 119, Exec)
  28
  29 /*  FUNCTION
  30         Free memory allocated out of a private memory pool.
  31
  32     INPUTS
  33         poolHeader - Handle of the memory pool
  34         memory     - Pointer to the memory
  35         memSize    - Size of the memory chunk
  36
  37     RESULT
  38
  39     NOTES
  40
  41     EXAMPLE
  42
  43     BUGS
  44
  45     SEE ALSO
  46         CreatePool(), DeletePool(), AllocPooled()
  47
  48     INTERNALS
  49
  50 ******************************************************************************/
  51 {
  52     AROS_LIBFUNC_INIT
  53
  54     struct ProtectedPool *pool = (struct ProtectedPool *)poolHeader;
  55
  56     if (!memory || !memSize) return;
  57
  58     if (pool->pool.Requirements & MEMF_SEM_PROTECTED)
  59     {
  60         ObtainSemaphore(&pool->sem);
  61     }
  62
  63     /* If memSize is bigger than the ThreshSize it's allocated seperately. */
  64     if(memSize > pool->pool.ThreshSize)
  65     {
  66         struct Block *bl;
  67
  68         /* Get pointer to header */
  69         bl = (struct Block *)((UBYTE *)memory - BLOCK_TOTAL);
  70
  71         /* Remove it from the list */
  72         Remove((struct Node *)&bl->Node);
  73
  74         if (bl->Size != memSize + BLOCK_TOTAL)
  75         {
  76             kprintf("\nFreePooled: free size does not match alloc size: allocsize = %d freesize = %d!!!\n\n",
  77                        bl->Size - BLOCK_TOTAL,
  78                        memSize);
  79         }
  80
  81         /* And Free the memory */
  82         FreeMem(bl, bl->Size);
  83
  84     }
  85     else
  86     {
  87         /* Look for the right MemHeader */
  88         struct MemHeader *mh = (struct MemHeader *)pool->pool.PuddleList.mlh_Head;
  89
  90         for(;;)
  91         {
  92             #if !defined(NO_CONSISTENCY_CHECKS)
  93             if (!mh)
  94             {
  95                 /* memory block is not in pool. */
  96                 Alert(AT_Recovery | AN_MemCorrupt);
  97                 break;
  98             }
  99             #endif
 100
 101             /* The memory must be between the two borders */
 102             if(memory >= mh->mh_Lower && memory < mh->mh_Upper)
 103             {
 104                 /* Found the MemHeader. Free the memory. */
 105                 Deallocate(mh, memory, memSize);
 106
 107                 /* Is this MemHeader completely free now? */
 108                 if(mh->mh_Free == pool->pool.PuddleSize)
 109                 {
 110                     /* Yes. Remove it from the list. */
 111                     Remove(&mh->mh_Node);
 112
 113                     /* And free it. */
 114                     FreeMem(mh, pool->pool.PuddleSize + MEMHEADER_TOTAL);
 115                 }
 116                 /* All done. */
 117                 break;
 118             }
 119             /* Try next MemHeader */
 120             mh = (struct MemHeader *)mh->mh_Node.ln_Succ;
 121         }
 122     }
 123
 124     if (pool->pool.Requirements & MEMF_SEM_PROTECTED)
 125     {
 126         ReleaseSemaphore(&pool->sem);
 127     }
 128
 129     AROS_LIBFUNC_EXIT
 130
 131 } /* FreePooled */
 132