Implemented memory tracker

Core/Memory/HeapAllocators/Xalloc.cpp

@@ -7,8 +7,8 @@ namespace Xalloc
         struct SpinLockData
         {
             uint64_t LockData = 0x0;
-            const char *CurrentHolder = "(nul)";
-            const char *AttemptingToGet = "(nul)";
+            const char *CurrentHolder = "(null)";
+            const char *AttemptingToGet = "(null)";
             uint64_t Count = 0;
         };
 

Core/Memory/Tracker.cpp

@@ -0,0 +1,53 @@
+#include <memory.hpp>
+#include <debug.h>
+
+namespace Memory
+{
+    uint64_t Tracker::GetAllocatedMemorySize()
+    {
+        uint64_t Size = 0;
+        foreach (auto var in AllocatedPagesList)
+            Size += var.PageCount;
+        return FROM_PAGES(Size);
+    }
+
+    void *Tracker::RequestPages(uint64_t Count)
+    {
+        void *Address = KernelAllocator.RequestPages(Count);
+        for (uint64_t i = 0; i < Count; i++)
+            Memory::Virtual(this->PageTable).Remap((void *)((uint64_t)Address + (i * PAGE_SIZE)), (void *)((uint64_t)Address + (i * PAGE_SIZE)), Memory::PTFlag::RW | Memory::PTFlag::US);
+        AllocatedPagesList.push_back({Address, Count});
+        return Address;
+    }
+
+    void Tracker::FreePages(void *Address, uint64_t Count)
+    {
+        KernelAllocator.FreePages(Address, Count);
+        for (uint64_t i = 0; i < Count; i++)
+            Memory::Virtual(this->PageTable).Remap((void *)((uint64_t)Address + (i * PAGE_SIZE)), (void *)((uint64_t)Address + (i * PAGE_SIZE)), Memory::PTFlag::RW);
+
+        for (uint64_t i = 0; i < AllocatedPagesList.size(); i++)
+            if (AllocatedPagesList[i].Address == Address)
+            {
+                AllocatedPagesList.remove(i);
+                break;
+            }
+    }
+
+    Tracker::Tracker(PageTable4 *PageTable)
+    {
+        this->PageTable = PageTable;
+        debug("Tracker initialized.");
+    }
+
+    Tracker::~Tracker()
+    {
+        foreach (auto var in AllocatedPagesList)
+        {
+            KernelAllocator.FreePages(var.Address, var.PageCount);
+            for (uint64_t i = 0; i < var.PageCount; i++)
+                Memory::Virtual(this->PageTable).Remap((void *)((uint64_t)var.Address + (i * PAGE_SIZE)), (void *)((uint64_t)var.Address + (i * PAGE_SIZE)), Memory::PTFlag::RW);
+        }
+        debug("Tracker destroyed.");
+    }
+}

Tasking/Task.cpp

@@ -94,6 +94,7 @@ namespace Tasking
                       Thread->Name, Thread->ID, Thread->Parent->Name, Thread->Parent->ID);
                 // Free memory
                 delete Thread->Stack;
+                delete Thread->Memory;
                 SecurityManager.DestroyToken(Thread->Security.UniqueToken);
                 delete Thread->Parent->Threads[i];
                 // Remove from the list
@@ -753,6 +754,7 @@ namespace Tasking
         case TaskTrustLevel::User:
         {
             Thread->Stack = new Memory::StackGuard(true, Parent->PageTable);
+            Thread->Memory = new Memory::Tracker(Parent->PageTable);
 #if defined(__amd64__)
             SecurityManager.TrustToken(Thread->Security.UniqueToken, TokenTrustLevel::Untrusted);
             Thread->GSBase = 0;

include/memory.hpp

@@ -4,6 +4,7 @@
 #ifdef __cplusplus
 #include <boot/binfo.h>
 #include <bitmap.hpp>
+#include <vector.hpp>
 #include <lock.hpp>
 #endif // __cplusplus
 #include <types.h>
@@ -625,6 +626,30 @@ namespace Memory
          */
         ~StackGuard();
     };
+
+    class Tracker
+    {
+    private:
+        Bitmap PageBitmap;
+        PageTable4 *PageTable;
+
+        struct AllocatedPages
+        {
+            void *Address;
+            uint64_t PageCount;
+        };
+
+        Vector<AllocatedPages> AllocatedPagesList;
+
+    public:
+        uint64_t GetAllocatedMemorySize();
+
+        void *RequestPages(uint64_t Count);
+        void FreePages(void *Address, uint64_t Count);
+
+        Tracker(PageTable4 *PageTable);
+        ~Tracker();
+    };
 }
 
 /**

include/task.hpp

@@ -89,6 +89,7 @@ namespace Tasking
         IPOffset Offset;
         int ExitCode;
         Memory::StackGuard *Stack;
+        Memory::Tracker *Memory;
         TaskStatus Status;
 #if defined(__amd64__)
         CPU::x64::TrapFrame Registers;