rom/exec/memory_nommu.c

   1 /*
   2     Copyright � 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: System memory allocator for MMU-less systems.
   6           Used also as boot-time memory allocator on systems with MMU.
   7     Lang: english
   8 */
   9
  10 #include <aros/debug.h>
  11 #include <exec/execbase.h>
  12 #include <exec/memory.h>
  13 #include <exec/memheaderext.h>
  14 #include <proto/exec.h>
  15
  16 #include <string.h>
  17
  18 #include "exec_intern.h"
  19 #include "exec_util.h"
  20 #include "memory.h"
  21
  22 APTR nommu_AllocMem(IPTR byteSize, ULONG flags, struct TraceLocation *loc, struct ExecBase *SysBase)
  23 {
  24     APTR res = NULL;
  25     struct MemHeader *mh, *mhn;
  26     ULONG requirements = flags & MEMF_PHYSICAL_MASK;
  27
  28     /* Protect memory list against other tasks */
  29     MEM_LOCK;
  30
  31     if (flags & MEMF_REVERSE)
  32         mhn = (struct MemHeader *)GetTail(&SysBase->MemList);
  33     else
  34         mhn = (struct MemHeader *)GetHead(&SysBase->MemList);
  35
  36     /* Loop over MemHeader structures */
  37     while (mhn)
  38     {
  39         mh = mhn;
  40
  41         if (flags & MEMF_REVERSE)
  42             mhn = (struct MemHeader *)(((struct Node *)(mh))->ln_Pred);
  43         else
  44             mhn = (struct MemHeader *)(((struct Node *)(mh))->ln_Succ);
  45
  46         /*
  47          * Check for the right requirements and enough free memory.
  48          * The requirements are OK if there's no bit in the
  49          * 'attributes' that isn't set in the 'mh->mh_Attributes'.
  50          */
  51         if ((requirements & ~mh->mh_Attributes)
  52                 || mh->mh_Free < byteSize)
  53             continue;
  54
  55         if (IsManagedMem(mh))
  56         {
  57             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
  58
  59             if (mhe->mhe_Alloc)
  60                 res = mhe->mhe_Alloc(mhe, byteSize, &flags);
  61         }
  62         else
  63         {
  64             res = stdAlloc(mh, mhac_GetSysCtx(mh, SysBase), byteSize, flags, loc, SysBase);
  65         }
  66         if (res)
  67             break;
  68     }
  69
  70     MEM_UNLOCK;
  71
  72     return res;
  73 }
  74
  75 APTR nommu_AllocAbs(APTR location, IPTR byteSize, struct ExecBase *SysBase)
  76 {
  77     struct MemHeader *mh;
  78     APTR ret = NULL;
  79     APTR endlocation = location + byteSize;
  80
  81     /* Protect the memory list from access by other tasks. */
  82     MEM_LOCK;
  83
  84     /* Loop over MemHeader structures */
  85     ForeachNode(&SysBase->MemList, mh)
  86     {
  87         if (IsManagedMem(mh))
  88         {
  89             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
  90             if (mhe->mhe_InBounds(mhe, location, endlocation))
  91             {
  92                 if (mhe->mhe_AllocAbs)
  93                 {
  94                     void * ret = mhe->mhe_AllocAbs(mhe, byteSize, location);
  95
  96                     MEM_UNLOCK;
  97
  98                     return ret;
  99                 }
 100             }
 101         }
 102         else
 103             if (mh->mh_Lower <= location && mh->mh_Upper >= endlocation)
 104                 break;
 105     }
 106
 107     /* If no header was found which matched the requirements, just give up. */
 108     if (mh->mh_Node.ln_Succ)
 109     {
 110         struct MemChunk *p1, *p2, *p3, *p4;
 111
 112         /* Align size to the requirements */
 113         byteSize += (IPTR)location&(MEMCHUNK_TOTAL - 1);
 114         byteSize  = (byteSize + MEMCHUNK_TOTAL-1) & ~(MEMCHUNK_TOTAL-1);
 115
 116         /* Align the location as well */
 117         location=(APTR)((IPTR)location & ~(MEMCHUNK_TOTAL-1));
 118
 119         /* Start and end(+1) of the block */
 120         p3=(struct MemChunk *)location;
 121         p4=(struct MemChunk *)((UBYTE *)p3+byteSize);
 122
 123         /*
 124             The free memory list is only single linked, i.e. to remove
 125             elements from the list I need the node's predessor. For the
 126             first element I can use freeList->mh_First instead of a real
 127             predecessor.
 128         */
 129         p1 = (struct MemChunk *)&mh->mh_First;
 130         p2 = p1->mc_Next;
 131
 132         /* Follow the list to find a chunk with our memory. */
 133         while (p2 != NULL)
 134         {
 135 #if !defined(NO_CONSISTENCY_CHECKS)
 136             /*
 137              * Memory list consistency checks.
 138              * 1. Check alignment restrictions
 139              */
 140             if (((IPTR)p2|(IPTR)p2->mc_Bytes) & (MEMCHUNK_TOTAL-1))
 141             {
 142                 if (SysBase && SysBase->DebugAROSBase)
 143                 {
 144                     bug("[MM] Chunk allocator error\n");
 145                     bug("[MM] Attempt to allocate %lu bytes at 0x%p from MemHeader 0x%p\n", byteSize, location, mh);
 146                     bug("[MM] Misaligned chunk at 0x%p (%u bytes)\n", p2, p2->mc_Bytes);
 147
 148                     Alert(AN_MemoryInsane|AT_DeadEnd);
 149                 }
 150                 break;
 151             }
 152
 153             /* 2. Check against overlapping blocks */
 154             if (p2->mc_Next && ((UBYTE *)p2 + p2->mc_Bytes >= (UBYTE *)p2->mc_Next))
 155             {
 156                 if (SysBase && SysBase->DebugAROSBase)
 157                 {
 158                     bug("[MM] Chunk allocator error\n");
 159                     bug("[MM] Attempt to allocate %lu bytes at 0x%p from MemHeader 0x%p\n", byteSize, location, mh);
 160                     bug("[MM] Overlapping chunks 0x%p (%u bytes) and 0x%p (%u bytes)\n", p2, p2->mc_Bytes, p2->mc_Next, p2->mc_Next->mc_Bytes);
 161
 162                     Alert(AN_MemoryInsane|AT_DeadEnd);
 163                 }
 164                 break;
 165             }
 166 #endif
 167
 168             /* Found a chunk that fits? */
 169             if((UBYTE *)p2+p2->mc_Bytes>=(UBYTE *)p4&&p2<=p3)
 170             {
 171                 /* Since AllocAbs allocations never allocate/update a ctx, they need to clear it if it exists */
 172                 mhac_ClearSysCtx(mh, SysBase);
 173
 174                 /* Check if there's memory left at the end. */
 175                 if((UBYTE *)p2+p2->mc_Bytes!=(UBYTE *)p4)
 176                 {
 177                     /* Yes. Add it to the list */
 178                     p4->mc_Next  = p2->mc_Next;
 179                     p4->mc_Bytes = (UBYTE *)p2+p2->mc_Bytes-(UBYTE *)p4;
 180                     p2->mc_Next  = p4;
 181                 }
 182
 183                 /* Check if there's memory left at the start. */
 184                 if(p2!=p3)
 185                     /* Yes. Adjust the size */
 186                     p2->mc_Bytes=(UBYTE *)p3-(UBYTE *)p2;
 187                 else
 188                     /* No. Skip the old chunk */
 189                     p1->mc_Next=p2->mc_Next;
 190
 191                 /* Adjust free memory count */
 192                 mh->mh_Free-=byteSize;
 193
 194                 /* Return the memory */
 195                 ret = p3;
 196                 break;
 197             }
 198             /* goto next chunk */
 199
 200             p1=p2;
 201             p2=p2->mc_Next;
 202         }
 203     }
 204
 205     MEM_UNLOCK;
 206
 207     return ret;
 208 }
 209
 210 void nommu_FreeMem(APTR memoryBlock, IPTR byteSize, struct TraceLocation *loc, struct ExecBase *SysBase)
 211 {
 212     struct MemHeader *mh;
 213     APTR blockEnd;
 214
 215     /* It is legal to free zero bytes */
 216     if (!byteSize)
 217         return;
 218
 219     blockEnd = memoryBlock + byteSize;
 220
 221     /* Protect the memory list from access by other tasks. */
 222     MEM_LOCK;
 223
 224     ForeachNode(&SysBase->MemList, mh)
 225     {
 226         if (IsManagedMem(mh))
 227         {
 228             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
 229
 230             /* Test if the memory belongs to this MemHeader. */
 231             if (!mhe->mhe_InBounds(mhe, memoryBlock, blockEnd))
 232                 continue;
 233
 234             if (mhe->mhe_Free)
 235                 mhe->mhe_Free(mhe, memoryBlock, byteSize);
 236
 237         }
 238         else
 239         {
 240             /* Test if the memory belongs to this MemHeader. */
 241             if (mh->mh_Lower > memoryBlock || mh->mh_Upper < blockEnd)
 242                 continue;
 243
 244             stdDealloc(mh, mhac_GetSysCtx(mh, SysBase), memoryBlock, byteSize, loc, SysBase);
 245         }
 246
 247         MEM_UNLOCK;
 248         ReturnVoid ("nommu_FreeMem");
 249     }
 250
 251     MEM_UNLOCK;
 252
 253 #if !defined(NO_CONSISTENCY_CHECKS)
 254     /* Some memory that didn't fit into any MemHeader? */
 255     bug("[MM] Chunk allocator error\n");
 256     bug("[MM] Attempt to free %u bytes at 0x%p\n", byteSize, memoryBlock);
 257     bug("[MM] The block does not belong to any MemHeader\n");
 258
 259     Alert(AN_BadFreeAddr);
 260 #endif
 261
 262     ReturnVoid ("nommu_FreeMem");
 263 }
 264
 265 IPTR nommu_AvailMem(ULONG attributes, struct ExecBase *SysBase)
 266 {
 267     IPTR ret = 0;
 268     struct MemHeader *mh;
 269     ULONG physFlags = attributes & MEMF_PHYSICAL_MASK;
 270
 271     D(bug("[MM] nommu_AvailMem(0x%08X)\n", attributes));
 272     D(bug("[MM] physical memory flags: 0x%08X\n", physFlags));
 273
 274     /* Nobody else should access the memory lists now. */
 275     MEM_LOCK_SHARED;
 276
 277     ForeachNode(&SysBase->MemList, mh)
 278     {
 279         D(bug("[MM] Checking MemHeader 0x%p\n", mh));
 280
 281         /*
 282          * The current memheader is OK if there's no bit in the
 283          * 'physFlags' that isn't set in the 'mh->mh_Attributes'.
 284          */
 285         if (physFlags & ~mh->mh_Attributes)
 286         {
 287             D(bug("[MM] Skipping (mh_Attributes = 0x%08X\n", mh->mh_Attributes));
 288             continue;
 289         }
 290
 291         if (IsManagedMem(mh))
 292         {
 293             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
 294
 295             if (mhe->mhe_Avail)
 296             {
 297                 IPTR val = mhe->mhe_Avail(mhe, attributes);
 298
 299                 if (attributes & MEMF_LARGEST)
 300                 {
 301                     if (val > ret)
 302                         ret = val;
 303                 }
 304                 else
 305                     ret += val;
 306
 307                 continue;
 308             }
 309         }
 310
 311         /* Find largest chunk? */
 312         if (attributes & MEMF_LARGEST)
 313         {
 314             /*
 315              * Yes. Follow the list of MemChunks and set 'ret' to
 316              * each value that is bigger than all previous ones.
 317              */
 318             struct MemChunk *mc;
 319
 320             for (mc = mh->mh_First; mc; mc = mc->mc_Next)
 321             {
 322 #if !defined(NO_CONSISTENCY_CHECKS)
 323                 /*
 324                  * Do some constistency checks:
 325                  * 1. All MemChunks must be aligned to MEMCHUNK_TOTAL.
 326                  */
 327                 if (((IPTR)mc | mc->mc_Bytes) & (MEMCHUNK_TOTAL-1))
 328                 {
 329                     bug("[MM] Chunk allocator error in MemHeader 0x%p\n", mh);
 330                     bug("[MM] Misaligned chunk at 0x%p (%u bytes)\n", mc, mc->mc_Bytes);
 331
 332                     Alert(AN_MemoryInsane|AT_DeadEnd);
 333                 }
 334                         /*  2. The end (+1) of the current MemChunk must be lower than the start of the next one. */
 335                 if (mc->mc_Next && ((UBYTE *)mc + mc->mc_Bytes >= (UBYTE *)mc->mc_Next))
 336                 {
 337                     bug("[MM] Chunk allocator error in MemHeader 0x%p\n");
 338                     bug("[MM] Overlapping chunks 0x%p (%u bytes) and 0x%p (%u bytes)\n", mc, mc->mc_Bytes, mc->mc_Next, mc->mc_Next->mc_Bytes);
 339
 340                     Alert(AN_MemoryInsane|AT_DeadEnd);
 341                 }
 342 #endif
 343                 if (mc->mc_Bytes>ret)
 344                     ret=mc->mc_Bytes;
 345             }
 346         }
 347         else if (attributes & MEMF_TOTAL)
 348             /* Determine total size. */
 349             ret += (IPTR)mh->mh_Upper - (IPTR)mh->mh_Lower;
 350         else
 351             /* Sum up free memory. */
 352             ret += mh->mh_Free;
 353     }
 354
 355     /* All done */
 356     MEM_UNLOCK;
 357
 358     return ret;
 359 }