exec: free-list, allocator, task and memory bugfixes

RMortenB · RMortenB · commit 726faac4e46b · 2026-05-10T03:27:05.000+02:00
- switch HANDLE_MANAGED_MEM tests from #ifdef to #if
  (the macro is defined as 0 when disabled, so #ifdef was wrong)
- memory: free-list consistency, MEMF_MANAGED tests, pool fixes
- memory_nommu: round byteSize up to MEMCHUNK_TOTAL in AllocMem
- newaddtask: pass MemEntry list head correctly
- prepareexecbase: respect "nomungwall" arg, OR-in stacksnoop
  flag instead of clobbering, fix Preparation debug print
- remtask: Disable around list removal to protect against
  interrupt-level Signal moving the task between lists
- signal: priority comparison uses strict greater-than for
  preemption; corrected debug-print arguments
diff --git a/rom/exec/allocate.c b/rom/exec/allocate.c
@@ -84,7 +84,7 @@
 {
     AROS_LIBFUNC_INIT
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if ((freeList->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(freeList))
     {
         struct MemHeaderExt *mhe = (struct MemHeaderExt *)freeList;
diff --git a/rom/exec/allocpooled.c b/rom/exec/allocpooled.c
@@ -75,7 +75,7 @@
     if(!memSize)
         return NULL;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if (IsManagedMem(mhe))
     {
         ULONG poolrequirements = (ULONG)(IPTR)mhe->mhe_MemHeader.mh_First;
diff --git a/rom/exec/allocvecpooled.c b/rom/exec/allocvecpooled.c
@@ -56,7 +56,7 @@
     /* 0-sized allocation results in returning NULL (API guarantee) */
     if(!memSize)
         return NULL;
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if (IsManagedMem(mhe))
     {
         ULONG poolrequirements = (ULONG)(IPTR)mhe->mhe_MemHeader.mh_First;
diff --git a/rom/exec/createpool.c b/rom/exec/createpool.c
@@ -139,7 +139,7 @@
          * If the pool is in managed memory, don't bother any further setup. The
          * pool should do the rest self.
          */
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(firstPuddle))
         {
             D(bug("Managed pool\n");)
diff --git a/rom/exec/deallocate.c b/rom/exec/deallocate.c
@@ -58,7 +58,7 @@
 {
     AROS_LIBFUNC_INIT
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if ((freeList->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(freeList))
     {
         struct MemHeaderExt *mhe = (struct MemHeaderExt *)freeList;
diff --git a/rom/exec/deletepool.c b/rom/exec/deletepool.c
@@ -61,7 +61,7 @@
     {
         struct TraceLocation tp = CURRENT_LOCATION("DeletePool");
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(poolHeader))
         {
             /* Do nothing, everything is handled in FreeMemHeader */
diff --git a/rom/exec/freepooled.c b/rom/exec/freepooled.c
@@ -61,7 +61,7 @@
     if(!memSize || !memory)
         return;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if (IsManagedMem(mhe))
     {
         if (mhe->mhe_Free)
diff --git a/rom/exec/freevecpooled.c b/rom/exec/freevecpooled.c
@@ -57,7 +57,7 @@
     if(!memory)
         return;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if (IsManagedMem(mhe))
     {
         if (mhe->mhe_FreeVec)
diff --git a/rom/exec/memory.c b/rom/exec/memory.c
@@ -33,7 +33,7 @@ struct MemHeader *FindMem(APTR address, struct ExecBase *SysBase)
 
     while (mh->mh_Node.ln_Succ != NULL)
     {
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(mh))
         {
             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
@@ -376,7 +376,8 @@ void mhac_PoolMemHeaderSetup(struct MemHeader * mh, struct ProtectedPool * pool)
 #define mhac_PoolMemHeaderGetCtx(a)     ((struct MemHeaderAllocatorCtx *)(a->mh_Node.ln_Name))
 #define mhac_PoolMemHeaderGetPool(a)    (mhac_PoolMemHeaderGetCtx(a)->mhac_Data1)
 
-#endif
+#endif // defined(NO_ALLOCATOR_CONTEXT)
+
 
 
 #ifdef NO_CONSISTENCY_CHECKS
@@ -540,12 +541,8 @@ APTR stdAllocReverse(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, I
 			struct MemChunk * pp = p1;
 
 			/* Return the last bytes. */
-			p1->mc_Next=p2;
 			mc = (struct MemChunk *)(MK_UBYTEPTR(p2)+p2->mc_Bytes-byteSize);
-
-			p1 = p1->mc_Next;
-			p1->mc_Next  = p2->mc_Next;
-			p1->mc_Bytes = p2->mc_Bytes-byteSize;
+			p2->mc_Bytes -= byteSize;
 
 			mhac_MemChunkCreated(p1, pp, mhac);
 		}
@@ -556,7 +553,7 @@ APTR stdAllocReverse(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, I
 		if (requirements & MEMF_CLEAR)
 			memset(mc, 0, byteSize);
 	}
-
+#if !defined(NO_ALLOCATOR_CONTEXT)
 	else
 	{
 		if (!mhac_IsIndexEmpty(mhac))
@@ -569,6 +566,7 @@ APTR stdAllocReverse(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, I
 			mc = stdAlloc(mh, mhac, size, requirements, tp, SysBase);
 		}
 	}
+#endif
 	return mc;
 }
 
@@ -588,7 +586,7 @@ APTR stdAlloc(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, IPTR siz
      * The check has to be done for the second time. Exec uses stdAlloc on memheader
      * passed upon startup. This is bad, very bad. So here a temporary hack :)
      */
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if ((mh->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(mh))
     {
         struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
@@ -654,7 +652,6 @@ APTR stdAlloc(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, IPTR siz
         /* Something found? */
         if (mc != NULL)
         {
-            /* Remember: if MEMF_REVERSE is set p1 and p2 are now invalid. */
             p1 = mc;
             p2 = p1->mc_Next;
 
@@ -688,6 +685,7 @@ APTR stdAlloc(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, IPTR siz
             if (requirements & MEMF_CLEAR)
                 memset(mc, 0, byteSize);
         }
+#if !defined(NO_ALLOCATOR_CONTEXT)
         else
         {
             if (!mhac_IsIndexEmpty(mhac))
@@ -700,7 +698,8 @@ APTR stdAlloc(struct MemHeader *mh, struct MemHeaderAllocatorCtx *mhac, IPTR siz
                 mc = stdAlloc(mh, mhac, size, requirements, tp, SysBase);
             }
         }
-        return mc;
+#endif
+    		return mc;
     }
 }
 
@@ -716,7 +715,7 @@ void stdDealloc(struct MemHeader *freeList, struct MemHeaderAllocatorCtx *mhac,
     struct MemChunk *p1, *p2, *p3;
     UBYTE *p4;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if ((freeList->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(freeList))
     {
         struct MemHeaderExt *mhe = (struct MemHeaderExt *)freeList;
@@ -774,7 +773,7 @@ void stdDealloc(struct MemHeader *freeList, struct MemHeaderAllocatorCtx *mhac,
             /* Found a block with a higher address? */
             if (p2 >= p3)
             {
-#if !defined(NO_CONSISTENCY_CHECKS)
+// #if !defined(NO_CONSISTENCY_CHECKS)
                 /*
                 If the memory to be freed overlaps with the current
                 block something must be wrong.
@@ -788,7 +787,7 @@ void stdDealloc(struct MemHeader *freeList, struct MemHeaderAllocatorCtx *mhac,
                     Alert(AN_FreeTwice);
                     return;
                 }
-#endif
+// #endif
                 /* End the loop with p2 non-zero */
                 break;
             }
@@ -889,7 +888,7 @@ APTR AllocMemHeader(IPTR size, ULONG flags, struct TraceLocation *loc, struct Ex
     {
         struct MemHeader *orig = FindMem(mh, SysBase);
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
 		if (IsManagedMem(orig))
         {
             struct MemHeaderExt *mhe_orig = (struct MemHeaderExt *)orig;
@@ -964,7 +963,7 @@ void FreeMemHeader(APTR addr, struct TraceLocation *loc, struct ExecBase *SysBas
 
     IPTR size = (IPTR)mhe->mhe_MemHeader.mh_Upper - (IPTR)addr;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if (IsManagedMem(mhe))
     {
         if (mhe->mhe_DestroyPool)
@@ -1038,6 +1037,7 @@ APTR InternalAllocPooled(APTR poolHeader, IPTR memSize, ULONG flags, struct Trac
     if (pool->pool.PoolMagic != POOL_MAGIC)
     {
         PoolManagerAlert(PME_ALLOC_INV_POOL, AT_DeadEnd, memSize, NULL, NULL, poolHeader);
+        return NULL;
     }
 
     if (pool->pool.Requirements & MEMF_SEM_PROTECTED)
@@ -1207,11 +1207,13 @@ void InternalFreePooled(APTR poolHeader, APTR memory, IPTR memSize, struct Trace
         if (pool->pool.PoolMagic != POOL_MAGIC)
         {
             PoolManagerAlert(PME_FREE_INV_POOL, AT_DeadEnd, memSize, memory, poolHeaderMH, NULL);
+            return;
         }
 
         if (poolHeaderMH != poolHeader)
         {
             PoolManagerAlert(PME_FREE_MXD_POOL, 0, memSize, memory, poolHeaderMH, poolHeader);
+            return;
         }
 
         if (pool->pool.Requirements & MEMF_SEM_PROTECTED)
diff --git a/rom/exec/memory_nommu.c b/rom/exec/memory_nommu.c
@@ -25,6 +25,8 @@ APTR nommu_AllocMem(IPTR byteSize, ULONG flags, struct TraceLocation *loc, struc
     struct MemHeader *mh;
     ULONG requirements = flags & MEMF_PHYSICAL_MASK;
 
+	byteSize  = (byteSize + MEMCHUNK_TOTAL-1) & ~(MEMCHUNK_TOTAL-1);
+
     /* Protect memory list against other tasks */
     MEM_LOCK;
 
@@ -39,7 +41,7 @@ APTR nommu_AllocMem(IPTR byteSize, ULONG flags, struct TraceLocation *loc, struc
         if ((requirements & ~mh->mh_Attributes) || mh->mh_Free < byteSize)
             continue;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(mh))
         {
             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
@@ -73,15 +75,15 @@ APTR nommu_AllocAbs(APTR location, IPTR byteSize, struct ExecBase *SysBase)
     /* Loop over MemHeader structures */
     ForeachNode(&SysBase->MemList, mh)
     {
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(mh))
         {
             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
             if (mhe->mhe_InBounds(mhe, location, endlocation))
             {
                 if (mhe->mhe_AllocAbs)
                 {
-                    APTR ret = mhe->mhe_AllocAbs(mhe, byteSize, location);
+                    ret = mhe->mhe_AllocAbs(mhe, byteSize, location);
 
                     MEM_UNLOCK;
 
@@ -214,7 +216,7 @@ void nommu_FreeMem(APTR memoryBlock, IPTR byteSize, struct TraceLocation *loc, s
 
     ForeachNode(&SysBase->MemList, mh)
     {
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(mh))
         {
             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
@@ -280,7 +282,7 @@ IPTR nommu_AvailMem(ULONG attributes, struct ExecBase *SysBase)
             D(bug("[MM] Skipping (mh_Attributes = 0x%08X\n", mh->mh_Attributes);)
             continue;
         }
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
         if (IsManagedMem(mh))
         {
             struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
@@ -327,7 +329,7 @@ IPTR nommu_AvailMem(ULONG attributes, struct ExecBase *SysBase)
                         /*  2. The end (+1) of the current MemChunk must be lower than the start of the next one. */
                 if (mc->mc_Next && ((UBYTE *)mc + mc->mc_Bytes >= (UBYTE *)mc->mc_Next))
                 {
-                    bug("[MM] Chunk allocator error in MemHeader 0x%p\n");
+                    bug("[MM] Chunk allocator error in MemHeader 0x%p\n", mh);
                     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);
 
                     Alert(AN_MemoryInsane|AT_DeadEnd);
diff --git a/rom/exec/newaddtask.c b/rom/exec/newaddtask.c
@@ -126,7 +126,7 @@
     if (mlExtra)
         AddTail(&task->tc_MemEntry, &mlExtra->ml_Node);
 
-    DADDTASK("NewAddTask MemEntry head: 0x%p", GetHead(&task->tc_MemEntry.lh_Head));
+    DADDTASK("NewAddTask MemEntry head: 0x%p", GetHead(&task->tc_MemEntry));
 
     /* Set node type to NT_TASK if not set to something else. */
     if (!task->tc_Node.ln_Type)
diff --git a/rom/exec/prepareexecbase.c b/rom/exec/prepareexecbase.c
@@ -120,7 +120,7 @@ static APTR allocmem(struct MemHeader *mh, ULONG size, ULONG attributes)
 {
     APTR ret;
 
-#ifdef HANDLE_MANAGED_MEM
+#if HANDLE_MANAGED_MEM
     if (IsManagedMem(mh))
     {
         struct MemHeaderExt *mhe = (struct MemHeaderExt *)mh;
@@ -334,11 +334,16 @@ struct ExecBase *PrepareExecBase(struct MemHeader *mh, struct TagItem *msg)
 	 */
 	opts = strcasestr(args, "mungwall");
 	if (opts)
-	    PrivExecBase(SysBase)->IntFlags = EXECF_MungWall;
+	{
+		if(!strcasestr(args, "nomungwall"))
+		{
+	    	PrivExecBase(SysBase)->IntFlags = EXECF_MungWall;
+		}
+	}
 
 	opts = strcasestr(args, "stacksnoop");
 	if (opts)
-	    PrivExecBase(SysBase)->IntFlags = EXECF_StackSnoop;
+	    PrivExecBase(SysBase)->IntFlags |= EXECF_StackSnoop;
 
 	/*
 	 * Parse system runtime debug flags.
@@ -372,7 +377,7 @@ struct ExecBase *PrepareExecBase(struct MemHeader *mh, struct TagItem *msg)
     PrivExecBase(SysBase)->ExecLockBase = ExecLock__PrepareBase(mh);
 #endif
 
-    D(bug("[Exec] %s: Preperation complete.\n"));
+    D(bug("[Exec] %s: Preparation complete.\n", __func__));
 
     return SysBase;
 }
diff --git a/rom/exec/remtask.c b/rom/exec/remtask.c
@@ -95,10 +95,15 @@
             /*
              * Remove() here, before freeing the MemEntry list. Because
              * the MemEntry list might contain the task struct itself!
+             *
+             * Use Disable() to protect against interrupt-level Signal()
+             * which can move this task between lists concurrently.
             */
 #if !defined(EXEC_REMTASK_NEEDSSWITCH)
+            Disable();
             task->tc_State = TS_REMOVED;
             Remove(&task->tc_Node);
+            Enable();
 #else
             krnSysCallReschedTask(task, TS_REMOVED);
 #endif
diff --git a/rom/exec/signal.c b/rom/exec/signal.c
@@ -36,7 +36,7 @@ AROS_UFH3(IPTR, signal_hook,
     D(
         struct KernelBase *KernelBase = __kernelBase;
         int cpunum = KrnGetCPUNumber();
-        bug("[Exec] CPU%03d: Using IPI to do Signal(%p, %08x), SysBase=%p\n", cpunum, msg->target, msg->sigset, SysBase);
+        bug("[Exec] CPU%03d: Using IPI to do Signal(%p, %08x), SysBase=%p\n", cpunum, target, sigset, SysBase);
     );
     
     Signal(target, sigset);
@@ -203,7 +203,7 @@ AROS_UFH3(IPTR, signal_hook,
                 }
                 else
                 {
-                    (bug("[Exec] Signal: Raising Exception for 'running' Task on CPU %03u\n", IntETask(task->tc_UnionETask.tc_ETask)->iet_CpuNumber));
+                    D(bug("[Exec] Signal: Raising Exception for 'running' Task on CPU %03u\n", IntETask(task->tc_UnionETask.tc_ETask)->iet_CpuNumber));
                     KrnScheduleCPU(IntETask(task->tc_UnionETask.tc_ETask)->iet_CpuAffinity);
                 }
 #endif
@@ -236,7 +236,7 @@ AROS_UFH3(IPTR, signal_hook,
                 (!(PrivExecBase(SysBase)->IntFlags & EXECF_CPUAffinity) ||
                 (KrnCPUInMask(cpunum, IntETask(task->tc_UnionETask.tc_ETask)->iet_CpuAffinity))) &&
 #endif
-                (task->tc_Node.ln_Pri >= thisTask->tc_Node.ln_Pri))
+                (task->tc_Node.ln_Pri > thisTask->tc_Node.ln_Pri))
             {
                 /*
                     Yes. A taskswitch is necessary. Prepare one if possible.

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@`
`84`	`84`	`{`
`85`	`85`	`AROS_LIBFUNC_INIT`
`86`	`86`
`87`		`-#ifdef HANDLE_MANAGED_MEM`
	`87`	`+#if HANDLE_MANAGED_MEM`
`88`	`88`	`if ((freeList->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(freeList))`
`89`	`89`	`{`
`90`	`90`	`struct MemHeaderExt mhe = (struct MemHeaderExt )freeList;`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@`
`75`	`75`	`if(!memSize)`
`76`	`76`	`return NULL;`
`77`	`77`
`78`		`-#ifdef HANDLE_MANAGED_MEM`
	`78`	`+#if HANDLE_MANAGED_MEM`
`79`	`79`	`if (IsManagedMem(mhe))`
`80`	`80`	`{`
`81`	`81`	`ULONG poolrequirements = (ULONG)(IPTR)mhe->mhe_MemHeader.mh_First;`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@`
`56`	`56`	`/* 0-sized allocation results in returning NULL (API guarantee) */`
`57`	`57`	`if(!memSize)`
`58`	`58`	`return NULL;`
`59`		`-#ifdef HANDLE_MANAGED_MEM`
	`59`	`+#if HANDLE_MANAGED_MEM`
`60`	`60`	`if (IsManagedMem(mhe))`
`61`	`61`	`{`
`62`	`62`	`ULONG poolrequirements = (ULONG)(IPTR)mhe->mhe_MemHeader.mh_First;`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@`
`139`	`139`	`* If the pool is in managed memory, don't bother any further setup. The`
`140`	`140`	`* pool should do the rest self.`
`141`	`141`	`*/`
`142`		`-#ifdef HANDLE_MANAGED_MEM`
	`142`	`+#if HANDLE_MANAGED_MEM`
`143`	`143`	`if (IsManagedMem(firstPuddle))`
`144`	`144`	`{`
`145`	`145`	`D(bug("Managed pool\n");)`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@`
`58`	`58`	`{`
`59`	`59`	`AROS_LIBFUNC_INIT`
`60`	`60`
`61`		`-#ifdef HANDLE_MANAGED_MEM`
	`61`	`+#if HANDLE_MANAGED_MEM`
`62`	`62`	`if ((freeList->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(freeList))`
`63`	`63`	`{`
`64`	`64`	`struct MemHeaderExt mhe = (struct MemHeaderExt )freeList;`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@`
`61`	`61`	`{`
`62`	`62`	`struct TraceLocation tp = CURRENT_LOCATION("DeletePool");`
`63`	`63`
`64`		`-#ifdef HANDLE_MANAGED_MEM`
	`64`	`+#if HANDLE_MANAGED_MEM`
`65`	`65`	`if (IsManagedMem(poolHeader))`
`66`	`66`	`{`
`67`	`67`	`/* Do nothing, everything is handled in FreeMemHeader */`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@`
`57`	`57`	`if(!memory)`
`58`	`58`	`return;`
`59`	`59`
`60`		`-#ifdef HANDLE_MANAGED_MEM`
	`60`	`+#if HANDLE_MANAGED_MEM`
`61`	`61`	`if (IsManagedMem(mhe))`
`62`	`62`	`{`
`63`	`63`	`if (mhe->mhe_FreeVec)`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ struct MemHeader FindMem(APTR address, struct ExecBase SysBase)`
`33`	`33`
`34`	`34`	`while (mh->mh_Node.ln_Succ != NULL)`
`35`	`35`	`{`
`36`		`-#ifdef HANDLE_MANAGED_MEM`
	`36`	`+#if HANDLE_MANAGED_MEM`
`37`	`37`	`if (IsManagedMem(mh))`
`38`	`38`	`{`
`39`	`39`	`struct MemHeaderExt mhe = (struct MemHeaderExt )mh;`
`@@ -376,7 +376,8 @@ void mhac_PoolMemHeaderSetup(struct MemHeader * mh, struct ProtectedPool * pool)`
`376`	`376`	`#define mhac_PoolMemHeaderGetCtx(a) ((struct MemHeaderAllocatorCtx *)(a->mh_Node.ln_Name))`
`377`	`377`	`#define mhac_PoolMemHeaderGetPool(a) (mhac_PoolMemHeaderGetCtx(a)->mhac_Data1)`
`378`	`378`
`379`		`-#endif`
	`379`	`+#endif // defined(NO_ALLOCATOR_CONTEXT)`
	`380`	`+`
`380`	`381`
`381`	`382`
`382`	`383`	`#ifdef NO_CONSISTENCY_CHECKS`
`@@ -540,12 +541,8 @@ APTR stdAllocReverse(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, I`
`540`	`541`	`struct MemChunk * pp = p1;`
`541`	`542`
`542`	`543`	`/* Return the last bytes. */`
`543`		`- p1->mc_Next=p2;`
`544`	`544`	`mc = (struct MemChunk *)(MK_UBYTEPTR(p2)+p2->mc_Bytes-byteSize);`
`545`		`-`
`546`		`- p1 = p1->mc_Next;`
`547`		`- p1->mc_Next = p2->mc_Next;`
`548`		`- p1->mc_Bytes = p2->mc_Bytes-byteSize;`
	`545`	`+ p2->mc_Bytes -= byteSize;`
`549`	`546`
`550`	`547`	`mhac_MemChunkCreated(p1, pp, mhac);`
`551`	`548`	`}`
`@@ -556,7 +553,7 @@ APTR stdAllocReverse(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, I`
`556`	`553`	`if (requirements & MEMF_CLEAR)`
`557`	`554`	`memset(mc, 0, byteSize);`
`558`	`555`	`}`
`559`		`-`
	`556`	`+#if !defined(NO_ALLOCATOR_CONTEXT)`
`560`	`557`	`else`
`561`	`558`	`{`
`562`	`559`	`if (!mhac_IsIndexEmpty(mhac))`
`@@ -569,6 +566,7 @@ APTR stdAllocReverse(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, I`
`569`	`566`	`mc = stdAlloc(mh, mhac, size, requirements, tp, SysBase);`
`570`	`567`	`}`
`571`	`568`	`}`
	`569`	`+#endif`
`572`	`570`	`return mc;`
`573`	`571`	`}`
`574`	`572`
`@@ -588,7 +586,7 @@ APTR stdAlloc(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, IPTR siz`
`588`	`586`	`* The check has to be done for the second time. Exec uses stdAlloc on memheader`
`589`	`587`	`* passed upon startup. This is bad, very bad. So here a temporary hack :)`
`590`	`588`	`*/`
`591`		`-#ifdef HANDLE_MANAGED_MEM`
	`589`	`+#if HANDLE_MANAGED_MEM`
`592`	`590`	`if ((mh->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(mh))`
`593`	`591`	`{`
`594`	`592`	`struct MemHeaderExt mhe = (struct MemHeaderExt )mh;`
`@@ -654,7 +652,6 @@ APTR stdAlloc(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, IPTR siz`
`654`	`652`	`/* Something found? */`
`655`	`653`	`if (mc != NULL)`
`656`	`654`	`{`
`657`		`- /* Remember: if MEMF_REVERSE is set p1 and p2 are now invalid. */`
`658`	`655`	`p1 = mc;`
`659`	`656`	`p2 = p1->mc_Next;`
`660`	`657`
`@@ -688,6 +685,7 @@ APTR stdAlloc(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, IPTR siz`
`688`	`685`	`if (requirements & MEMF_CLEAR)`
`689`	`686`	`memset(mc, 0, byteSize);`
`690`	`687`	`}`
	`688`	`+#if !defined(NO_ALLOCATOR_CONTEXT)`
`691`	`689`	`else`
`692`	`690`	`{`
`693`	`691`	`if (!mhac_IsIndexEmpty(mhac))`
`@@ -700,7 +698,8 @@ APTR stdAlloc(struct MemHeader mh, struct MemHeaderAllocatorCtx mhac, IPTR siz`
`700`	`698`	`mc = stdAlloc(mh, mhac, size, requirements, tp, SysBase);`
`701`	`699`	`}`
`702`	`700`	`}`
`703`		`- return mc;`
	`701`	`+#endif`
	`702`	`+ return mc;`
`704`	`703`	`}`
`705`	`704`	`}`
`706`	`705`
`@@ -716,7 +715,7 @@ void stdDealloc(struct MemHeader freeList, struct MemHeaderAllocatorCtx mhac,`
`716`	`715`	`struct MemChunk p1, p2, *p3;`
`717`	`716`	`UBYTE *p4;`
`718`	`717`
`719`		`-#ifdef HANDLE_MANAGED_MEM`
	`718`	`+#if HANDLE_MANAGED_MEM`
`720`	`719`	`if ((freeList->mh_Node.ln_Type == NT_MEMORY) && IsManagedMem(freeList))`
`721`	`720`	`{`
`722`	`721`	`struct MemHeaderExt mhe = (struct MemHeaderExt )freeList;`
`@@ -774,7 +773,7 @@ void stdDealloc(struct MemHeader freeList, struct MemHeaderAllocatorCtx mhac,`
`774`	`773`	`/* Found a block with a higher address? */`
`775`	`774`	`if (p2 >= p3)`
`776`	`775`	`{`
`777`		`-#if !defined(NO_CONSISTENCY_CHECKS)`
	`776`	`+// #if !defined(NO_CONSISTENCY_CHECKS)`
`778`	`777`	`/*`
`779`	`778`	`If the memory to be freed overlaps with the current`
`780`	`779`	`block something must be wrong.`
`@@ -788,7 +787,7 @@ void stdDealloc(struct MemHeader freeList, struct MemHeaderAllocatorCtx mhac,`
`788`	`787`	`Alert(AN_FreeTwice);`
`789`	`788`	`return;`
`790`	`789`	`}`
`791`		`-#endif`
	`790`	`+// #endif`
`792`	`791`	`/* End the loop with p2 non-zero */`
`793`	`792`	`break;`
`794`	`793`	`}`
`@@ -889,7 +888,7 @@ APTR AllocMemHeader(IPTR size, ULONG flags, struct TraceLocation *loc, struct Ex`
`889`	`888`	`{`
`890`	`889`	`struct MemHeader *orig = FindMem(mh, SysBase);`
`891`	`890`
`892`		`-#ifdef HANDLE_MANAGED_MEM`
	`891`	`+#if HANDLE_MANAGED_MEM`
`893`	`892`	`if (IsManagedMem(orig))`
`894`	`893`	`{`
`895`	`894`	`struct MemHeaderExt mhe_orig = (struct MemHeaderExt )orig;`
`@@ -964,7 +963,7 @@ void FreeMemHeader(APTR addr, struct TraceLocation loc, struct ExecBase SysBas`
`964`	`963`
`965`	`964`	`IPTR size = (IPTR)mhe->mhe_MemHeader.mh_Upper - (IPTR)addr;`
`966`	`965`
`967`		`-#ifdef HANDLE_MANAGED_MEM`
	`966`	`+#if HANDLE_MANAGED_MEM`
`968`	`967`	`if (IsManagedMem(mhe))`
`969`	`968`	`{`
`970`	`969`	`if (mhe->mhe_DestroyPool)`
`@@ -1038,6 +1037,7 @@ APTR InternalAllocPooled(APTR poolHeader, IPTR memSize, ULONG flags, struct Trac`
`1038`	`1037`	`if (pool->pool.PoolMagic != POOL_MAGIC)`
`1039`	`1038`	`{`
`1040`	`1039`	`PoolManagerAlert(PME_ALLOC_INV_POOL, AT_DeadEnd, memSize, NULL, NULL, poolHeader);`
	`1040`	`+ return NULL;`
`1041`	`1041`	`}`
`1042`	`1042`
`1043`	`1043`	`if (pool->pool.Requirements & MEMF_SEM_PROTECTED)`
`@@ -1207,11 +1207,13 @@ void InternalFreePooled(APTR poolHeader, APTR memory, IPTR memSize, struct Trace`
`1207`	`1207`	`if (pool->pool.PoolMagic != POOL_MAGIC)`
`1208`	`1208`	`{`
`1209`	`1209`	`PoolManagerAlert(PME_FREE_INV_POOL, AT_DeadEnd, memSize, memory, poolHeaderMH, NULL);`
	`1210`	`+ return;`
`1210`	`1211`	`}`
`1211`	`1212`
`1212`	`1213`	`if (poolHeaderMH != poolHeader)`
`1213`	`1214`	`{`
`1214`	`1215`	`PoolManagerAlert(PME_FREE_MXD_POOL, 0, memSize, memory, poolHeaderMH, poolHeader);`
	`1216`	`+ return;`
`1215`	`1217`	`}`
`1216`	`1218`
`1217`	`1219`	`if (pool->pool.Requirements & MEMF_SEM_PROTECTED)`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,8 @@ APTR nommu_AllocMem(IPTR byteSize, ULONG flags, struct TraceLocation *loc, struc`
`25`	`25`	`struct MemHeader *mh;`
`26`	`26`	`ULONG requirements = flags & MEMF_PHYSICAL_MASK;`
`27`	`27`
	`28`	`+ byteSize = (byteSize + MEMCHUNK_TOTAL-1) & ~(MEMCHUNK_TOTAL-1);`
	`29`	`+`
`28`	`30`	`/* Protect memory list against other tasks */`
`29`	`31`	`MEM_LOCK;`
`30`	`32`
`@@ -39,7 +41,7 @@ APTR nommu_AllocMem(IPTR byteSize, ULONG flags, struct TraceLocation *loc, struc`
`39`	`41`	`if ((requirements & ~mh->mh_Attributes) \|\| mh->mh_Free < byteSize)`
`40`	`42`	`continue;`
`41`	`43`
`42`		`-#ifdef HANDLE_MANAGED_MEM`
	`44`	`+#if HANDLE_MANAGED_MEM`
`43`	`45`	`if (IsManagedMem(mh))`
`44`	`46`	`{`
`45`	`47`	`struct MemHeaderExt mhe = (struct MemHeaderExt )mh;`
`@@ -73,15 +75,15 @@ APTR nommu_AllocAbs(APTR location, IPTR byteSize, struct ExecBase *SysBase)`
`73`	`75`	`/* Loop over MemHeader structures */`
`74`	`76`	`ForeachNode(&SysBase->MemList, mh)`
`75`	`77`	`{`
`76`		`-#ifdef HANDLE_MANAGED_MEM`
	`78`	`+#if HANDLE_MANAGED_MEM`
`77`	`79`	`if (IsManagedMem(mh))`
`78`	`80`	`{`
`79`	`81`	`struct MemHeaderExt mhe = (struct MemHeaderExt )mh;`
`80`	`82`	`if (mhe->mhe_InBounds(mhe, location, endlocation))`
`81`	`83`	`{`
`82`	`84`	`if (mhe->mhe_AllocAbs)`
`83`	`85`	`{`
`84`		`- APTR ret = mhe->mhe_AllocAbs(mhe, byteSize, location);`
	`86`	`+ ret = mhe->mhe_AllocAbs(mhe, byteSize, location);`
`85`	`87`
`86`	`88`	`MEM_UNLOCK;`
`87`	`89`
`@@ -214,7 +216,7 @@ void nommu_FreeMem(APTR memoryBlock, IPTR byteSize, struct TraceLocation *loc, s`
`214`	`216`
`215`	`217`	`ForeachNode(&SysBase->MemList, mh)`
`216`	`218`	`{`
`217`		`-#ifdef HANDLE_MANAGED_MEM`
	`219`	`+#if HANDLE_MANAGED_MEM`
`218`	`220`	`if (IsManagedMem(mh))`
`219`	`221`	`{`
`220`	`222`	`struct MemHeaderExt mhe = (struct MemHeaderExt )mh;`
`@@ -280,7 +282,7 @@ IPTR nommu_AvailMem(ULONG attributes, struct ExecBase *SysBase)`
`280`	`282`	`D(bug("[MM] Skipping (mh_Attributes = 0x%08X\n", mh->mh_Attributes);)`
`281`	`283`	`continue;`
`282`	`284`	`}`
`283`		`-#ifdef HANDLE_MANAGED_MEM`
	`285`	`+#if HANDLE_MANAGED_MEM`
`284`	`286`	`if (IsManagedMem(mh))`
`285`	`287`	`{`
`286`	`288`	`struct MemHeaderExt mhe = (struct MemHeaderExt )mh;`
`@@ -327,7 +329,7 @@ IPTR nommu_AvailMem(ULONG attributes, struct ExecBase *SysBase)`
`327`	`329`	`/* 2. The end (+1) of the current MemChunk must be lower than the start of the next one. */`
`328`	`330`	`if (mc->mc_Next && ((UBYTE )mc + mc->mc_Bytes >= (UBYTE )mc->mc_Next))`
`329`	`331`	`{`
`330`		`- bug("[MM] Chunk allocator error in MemHeader 0x%p\n");`
	`332`	`+ bug("[MM] Chunk allocator error in MemHeader 0x%p\n", mh);`
`331`	`333`	`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);`
`332`	`334`
`333`	`335`	`Alert(AN_MemoryInsane\|AT_DeadEnd);`