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