Deacresed Heap Crashes (Reopen PR)

source/Cosmos.Core_Plugs/CosmosRuntimeType.cs → source/Cosmos.Core/CosmosRuntimeType.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Globalization;
 using System.Reflection;
-using Cosmos.IL2CPU;
 
 namespace Cosmos.Core
 {

source/Cosmos.Core/Memory/HeapLarge.cs

@@ -35,8 +35,8 @@ public static void Init()
             var xPtr = (uint*)RAT.AllocPages(aType, xPages);
             if (xPtr == null)
             {
-                Debugger.SendKernelPanic(0x67); // out of pages
-                while (true) { }
+                Debugger.DoFail(0x67); // out of pages
+
             }
             xPtr[0] = xPages * RAT.PageSize - PrefixBytes; // Allocated data size
             xPtr[1] = aSize; // Actual data size
@@ -52,7 +52,13 @@ public static void Init()
         /// <exception cref="Exception">Thrown if page type is not found.</exception>
         public static void Free(void* aPtr)
         {
+            var heapObject = (uint*)aPtr;
             var xPageIdx = RAT.GetFirstRATIndex(aPtr);
+            if (heapObject[-4] == 0 && xPageIdx == 0)
+            {
+                // The object is not allocated
+                return;
+            }
             RAT.Free(xPageIdx);
         }
     }

source/Cosmos.Core/Memory/HeapSmall.cs

@@ -230,8 +230,7 @@ private static void AddRootSMTBlock(SMTPage* aPage, uint aSize)
                 // we cant later add a block with a size smaller than an earlier block. That would break the algorithm
                 Debugger.DoSendNumber(aSize);
                 Debugger.DoSendNumber(ptr->Size);
-                Debugger.SendKernelPanic(0x83);
-                while (true) { }
+                Debugger.DoFail(0x83);
             }
 
             if (ptr->Size == 0)
@@ -367,8 +366,7 @@ static void CreatePage(SMTPage* aPage, uint aItemSize)
                 smtBlock = NextFreeBlock();
                 if (smtBlock == null)
                 {
-                    Debugger.SendKernelPanic(0x93);
-                    while (true) { };
+                    Debugger.DoFail(0x93);
                 }
             }
 
@@ -389,29 +387,51 @@ static void CreatePage(SMTPage* aPage, uint aItemSize)
             smtBlock->PagePtr = xPtr;
         }
 
+
+
+        /// <summary>
+        /// Get the first block for this size, which has space left to allocate to And get the root block
+        /// </summary>
+        /// <param name="aSize">The size</param>
+        /// <param name="block">the Output block</param>
+        /// <returns>The parent of the block</returns>
+        private static RootSMTBlock* GetFirstWithSpaceAndParent(uint aSize, out SMTBlock* block)
+        {
+            var page = SMT;
+            RootSMTBlock* rootblock = null;
+            do
+            {
+                rootblock = GetFirstBlock(page, aSize);
+                block = GetFirstWithSpace(aSize, rootblock);
+
+                page = page->Next;
+            } while (rootblock == null && page != null);
+            return rootblock;
+        }
+
         /// <summary>
         /// Alloc memory block, of a given size.
         /// </summary>
         /// <param name="aSize">A size of block to alloc, in bytes.</param>
         /// <returns>Byte pointer to the start of the block.</returns>
         public static byte* Alloc(ushort aSize)
         {
-            var pageBlock = GetFirstWithSpace(aSize);
+            var smtblock = GetFirstWithSpaceAndParent(aSize, out SMTBlock* pageBlock);
             if (pageBlock == null) // This happens when the page is full and we need to allocate a new page for this size
             {
-                CreatePage(GetLastPage(), GetRoundedSize(aSize));
+                CreatePage(GetLastPage(), smtblock->Size);
                 pageBlock = GetFirstWithSpace(aSize);
                 if (pageBlock == null)
                 {
                     //this means that we cant allocate another page
-                    Debugger.SendKernelPanic(0x121);
+                    Debugger.DoAssert(0x121);
                 }
             }
 
             //now find position in the block
-            ushort* page = (ushort*)pageBlock->PagePtr;
-            uint elementSize = GetRoundedSize(aSize) + PrefixItemBytes;
-            uint positions = RAT.PageSize / elementSize;
+            var page = (ushort*)pageBlock->PagePtr;
+            var elementSize = smtblock->Size + PrefixItemBytes;
+            var positions = RAT.PageSize / elementSize;
             for (int i = 0; i < positions; i++)
             {
                 if (page[i * elementSize / 2] == 0)
@@ -434,8 +454,8 @@ static void CreatePage(SMTPage* aPage, uint aItemSize)
             // if we get here, RAM is corrupted, since we know we had a space but it turns out we didnt
             Debugger.DoSendNumber((uint)pageBlock);
             Debugger.DoSendNumber(aSize);
-            Debugger.SendKernelPanic(0x122);
-            while (true) { }
+            Debugger.DoFail(0x122);
+            return null;
         }
 
         /// <summary>
@@ -449,9 +469,10 @@ public static void Free(void* aPtr)
             if (size == 0)
             {
                 // double free, this object has already been freed
-                Debugger.DoBochsBreak();
+                //Debugger.DoBochsBreak();
                 Debugger.DoSendNumber((uint)heapObject);
-                Debugger.SendKernelPanic(0x99);
+                Debugger.DoAssert(true, 0x99, true);
+                return;
             }
 
             var allocated = (uint*)aPtr;
@@ -483,7 +504,7 @@ public static void Free(void* aPtr)
                 {
                     blockPtr = blockPtr->NextBlock;
                 }
-                if(blockPtr->PagePtr == allocatedOnPage)
+                if (blockPtr != null && blockPtr->PagePtr == allocatedOnPage)
                 {
                     break;
                 }
@@ -495,8 +516,7 @@ public static void Free(void* aPtr)
                 // this shouldnt happen
                 Debugger.DoSendNumber((uint)aPtr);
                 Debugger.DoSendNumber((uint)SMT);
-                Debugger.SendKernelPanic(0x98);
-                while (true) { }
+                Debugger.DoFail(0x98);
             }
             blockPtr->SpacesLeft++;
         }
@@ -559,4 +579,5 @@ private static int GetAllocatedObjectCount(SMTPage* aPage, uint aSize)
 
         #endregion
     }
+
 }

source/Cosmos.Core/Memory/RAT.cs

@@ -123,8 +123,9 @@ public static void Init(byte* aStartPtr, uint aSize)
 
             if (aSize % PageSize != 0)
             {
-                Debugger.DoSendNumber(aSize % PageSize);
-                Debugger.SendKernelPanic(11);
+
+                Debugger.DoSendNumber((aSize % PageSize));
+                Debugger.DoAssert(11);
                 throw new Exception("RAM size must be page aligned.");
             }
 

source/Cosmos.Core/VTablesImpl.cs

@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Cosmos.Debug.Kernel;
 
 namespace Cosmos.Core
@@ -158,8 +154,7 @@ public static uint GetMethodAddressForType(uint aType, uint aMethodId)
                 EnableDebug = true;
                 DebugHex("Type", aType);
                 DebugHex("MethodId", aMethodId);
-                Debugger.SendKernelPanic(KernelPanics.VMT_TypeIdInvalid);
-                while (true) ;
+                Debugger.DoFail(KernelPanics.VMT_TypeIdInvalid);
             }
             var xCurrentType = aType;
             do
@@ -172,15 +167,13 @@ public static uint GetMethodAddressForType(uint aType, uint aMethodId)
                 {
                     EnableDebug = true;
                     DebugHex("MethodIndexes is null for type", aType);
-                    Debugger.SendKernelPanic(KernelPanics.VMT_MethodIndexesNull);
-                    while (true) ;
+                    Debugger.DoFail(KernelPanics.VMT_MethodIndexesNull);
                 }
                 if (xCurrentTypeInfo.MethodAddresses == null)
                 {
                     EnableDebug = true;
                     DebugHex("MethodAddresses is null for type", aType);
-                    Debugger.SendKernelPanic(KernelPanics.VMT_MethodAddressesNull);
-                    while (true) ;
+                    Debugger.DoFail(KernelPanics.VMT_MethodAddressesNull);
                 }
 
                 for (int i = 0; i < xCurrentTypeInfo.MethodIndexes.Length; i++)
@@ -198,9 +191,8 @@ public static uint GetMethodAddressForType(uint aType, uint aMethodId)
                             DebugHex("MethodCount", xCurrentTypeInfo.MethodCount);
                             DebugHex("MethodAddresses.Length", (uint)xCurrentTypeInfo.MethodAddresses.Length);
                             Debug("Method found, but address is invalid!");
-                            Debugger.SendKernelPanic(KernelPanics.VMT_MethodFoundButAddressInvalid);
-                            while (true)
-                                ;
+                            Debugger.DoFail(KernelPanics.VMT_MethodFoundButAddressInvalid);
+
                         }
                         Debug("Found.");
                         return xResult;
@@ -220,8 +212,7 @@ public static uint GetMethodAddressForType(uint aType, uint aMethodId)
             DebugHex("MethodId", aMethodId);
             Debug("Not FOUND!");
 
-            Debugger.SendKernelPanic(KernelPanics.VMT_MethodNotFound);
-            while (true) ;
+            Debugger.DoFail(KernelPanics.VMT_MethodNotFound);
             throw new Exception("Cannot find virtual method!");
         }
 
@@ -254,8 +245,8 @@ public static uint GetDeclaringTypeOfMethodForType(uint aType, uint aMethodId)
             DebugHex("MethodId", aMethodId);
             Debug("Not FOUND Declaring TYPE!");
             Debugger.DoBochsBreak();
-            Debugger.SendKernelPanic(KernelPanics.VMT_MethodNotFound);
-            while (true) ;
+            Debugger.DoFail(KernelPanics.VMT_MethodNotFound);
+            return 0;
         }
 
         public static uint GetMethodAddressForInterfaceType(uint aType, uint aInterfaceMethodId)
@@ -265,8 +256,7 @@ public static uint GetMethodAddressForInterfaceType(uint aType, uint aInterfaceM
                 EnableDebug = true;
                 DebugHex("Type", aType);
                 DebugHex("InterfaceMethodId", aInterfaceMethodId);
-                Debugger.SendKernelPanic(KernelPanics.VMT_TypeIdInvalid);
-                while (true) ;
+                Debugger.DoFail(KernelPanics.VMT_TypeIdInvalid);
             }
 
             var xTypeInfo = mTypes[aType];
@@ -275,16 +265,14 @@ public static uint GetMethodAddressForInterfaceType(uint aType, uint aInterfaceM
             {
                 EnableDebug = true;
                 DebugHex("InterfaceMethodIndexes is null for type", aType);
-                Debugger.SendKernelPanic(KernelPanics.VMT_MethodIndexesNull);
-                while (true) ;
+                Debugger.DoFail(KernelPanics.VMT_MethodIndexesNull);
             }
 
             if (xTypeInfo.TargetMethodIndexes == null)
             {
                 EnableDebug = true;
                 DebugHex("TargetMethodIndexes is null for type", aType);
-                Debugger.SendKernelPanic(KernelPanics.VMT_MethodAddressesNull);
-                while (true) ;
+                Debugger.DoFail(KernelPanics.VMT_MethodAddressesNull);
             }
 
             for (int i = 0; i < xTypeInfo.InterfaceMethodIndexes.Length; i++)
@@ -302,8 +290,8 @@ public static uint GetMethodAddressForInterfaceType(uint aType, uint aInterfaceM
             DebugHex("InterfaceMethodId", aInterfaceMethodId);
             Debug("Not FOUND!");
 
-            Debugger.SendKernelPanic(KernelPanics.VMT_MethodNotFound);
-            while (true) ;
+            Debugger.DoFail(KernelPanics.VMT_MethodNotFound);
+            return 0;
         }
 
         /// <summary>

source/Cosmos.Core_Plugs/System/ArrayImpl.cs

@@ -118,7 +118,7 @@ public static unsafe object GetValue(Array aThis, params int[] aIndices)
         }
 
         [PlugMethod(Signature = "System_Void__System_Array_SetValue_System_Object__System_Int32_")]
-        public static unsafe void SetValue([ObjectPointerAccess] uint* aThis, uint aValue, int aIndex)
+        public static unsafe void SetValue([ObjectPointerAccess] uint* aThis, [ObjectPointerAccess] uint* aValue, int aIndex)
         {
             aThis = (uint*) aThis[0];
             aThis += 3;
@@ -128,16 +128,16 @@ public static unsafe void SetValue([ObjectPointerAccess] uint* aThis, uint aValu
             switch (xElementSize)
             {
                 case 1:
-                    *(byte*) aThis = (byte) aValue;
+                    *(byte*) aThis = (byte) *aValue;
                     return;
                 case 2:
-                    *(ushort*) aThis = (ushort) aValue;
+                    *(ushort*) aThis = (ushort) *aValue;
                     return;
                 case 3:
-                    *(uint*) aThis = (uint) aValue;
+                    *(uint*) aThis = (uint) *aValue;
                     return;
                 case 4:
-                    *(uint*) aThis = (uint) aValue;
+                    *(uint*) aThis = (uint) *aValue;
                     return;
             }
             throw new NotSupportedException("SetValue not supported in this situation!");