Restructured and rewritten entire codebase

core/memory/heap_allocators/Xalloc/README.md

@@ -0,0 +1,154 @@
+# Xalloc
+
+Xalloc is a custom memory allocator designed for hobby operating systems.
+Written in C++ and provides a simple and efficient way to manage memory in your hobby OS.
+
+#### ❗ This project is still in development and is not ready for use in production environments. ❗
+
+---
+
+## Features
+
+- **Simple API** - Simple API for allocating and freeing memory.
+
+- **Efficient** - Uses a free-list to manage memory and is designed to be fast.
+
+- **No dependencies** - No dependencies and is designed to be easy to integrate into your OS.
+
+---
+
+## Getting Started
+
+### Implementing missing functions
+
+You will need to implement the following functions in your OS:
+
+##### Wrapper.cpp
+```cpp
+extern "C" void *Xalloc_REQUEST_PAGES(Xsize_t Pages)
+{
+    // ...
+}
+
+extern "C" void Xalloc_FREE_PAGES(void *Address, Xsize_t Pages)
+{
+    // ...
+}
+
+/* Mandatory only if Xalloc_MapPages is set to true */
+extern "C" void Xalloc_MAP_MEMORY(void *VirtualAddress, void *PhysicalAddress, Xsize_t Flags)
+{
+    // ...
+}
+
+/* Mandatory only if Xalloc_MapPages is set to true */
+extern "C" void Xalloc_UNMAP_MEMORY(void *VirtualAddress)
+{
+    // ...
+}
+```
+
+##### Xalloc.hpp
+```cpp
+#define Xalloc_StopOnFail <bool> /* Infinite loop on failure */
+#define Xalloc_MapPages <bool> /* Map pages on allocation */
+#define Xalloc_PAGE_SIZE <page size> /* <-- Replace with your page size */
+#define Xalloc_trace(m, ...) <trace function>
+#define Xalloc_warn(m, ...) <warning function>
+#define Xalloc_err(m, ...) <error function>
+
+#define XallocV1_def <define a lock> /* eg. std::mutex Xalloc_lock; */
+#define XallocV1_lock <lock function>
+#define XallocV1_unlock <unlock function>
+
+/* Same as above */
+#define XallocV2_def <define a lock> 
+#define XallocV2_lock <lock function>
+#define XallocV2_unlock <unlock function>
+```
+
+### Typical usage
+
+```cpp
+#include "Xalloc.hpp"
+
+Xalloc::V1 *XallocV1Allocator = nullptr;
+
+int main()
+{
+    /*                                            Virtual Base     User   SMAP */
+    XallocV1Allocator = new Xalloc::V1((void *)0xFFFFA00000000000, false, false);
+
+    void *p = XallocV1Allocator->malloc(1234);
+    /* ... */
+    XallocV1Allocator->free(p);
+    delete XallocV1Allocator;
+    return 0;
+}
+```
+
+or
+
+```cpp
+#include "Xalloc.hpp"
+
+int main()
+{
+    /*                                      Virtual Base     User   SMAP */
+    Xalloc::V1 XallocV1Allocator((void *)0xFFFFA00000000000, false, false);
+
+    void *p = XallocV1Allocator.malloc(1234);
+    /* ... */
+    XallocV1Allocator.free(p);
+    return 0;
+}
+```
+
+---
+
+## API
+
+### Xalloc::V1
+
+```cpp
+void *malloc(Xsize_t Size);
+```
+Allocates a block of memory of size `Size` bytes.
+If `Size` is 0, then `nullptr` is returned.
+- `Size` - The size of the block to allocate in bytes.
+
+<br><br>
+
+```cpp
+void free(void *Address);
+```
+Frees the memory block pointed to by `Address`.
+If `Address` is `nullptr`, then no operation is performed.
+- `Address` - The address of the memory block to free.
+
+<br><br>
+
+```cpp
+void *calloc(Xsize_t NumberOfBlocks, Xsize_t Size);
+```
+Allocates a block of memory for an array of `NumberOfBlocks` elements, each of them `Size` bytes long.
+If `NumberOfBlocks` or `Size` is 0, then `nullptr` is returned.
+- `NumberOfBlocks` - The number of elements to allocate.
+- `Size` - The size of each element in bytes.
+
+<br><br>
+
+```cpp
+void *realloc(void *Address, Xsize_t Size);
+```
+Changes the size of the memory block pointed to by `Address` to `Size` bytes.
+If `Address` is `nullptr`, then the call is equivalent to `malloc(Size)`.
+If `Size` is equal to zero, and `Address` is not `nullptr`, then the call is equivalent to `free(Address)`.
+- `Address` - The address of the memory block to resize.
+- `Size` - The new size of the memory block in bytes.
+
+---
+
+## To-do
+
+- [ ] Multiple free-lists for different block sizes

core/memory/heap_allocators/Xalloc/Wrapper.cpp

@@ -0,0 +1,40 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "Xalloc.hpp"
+
+#include <memory.hpp>
+
+extern "C" void *Xalloc_REQUEST_PAGES(Xsize_t Pages)
+{
+	return KernelAllocator.RequestPages(Pages);
+}
+
+extern "C" void Xalloc_FREE_PAGES(void *Address, Xsize_t Pages)
+{
+	KernelAllocator.FreePages(Address, Pages);
+}
+
+extern "C" void Xalloc_MAP_MEMORY(void *VirtualAddress, void *PhysicalAddress, Xsize_t Flags)
+{
+	Memory::Virtual(KernelPageTable).Map(VirtualAddress, PhysicalAddress, Flags);
+}
+
+extern "C" void Xalloc_UNMAP_MEMORY(void *VirtualAddress)
+{
+	Memory::Virtual(KernelPageTable).Unmap(VirtualAddress);
+}

core/memory/heap_allocators/Xalloc/Xalloc.hpp

@@ -0,0 +1,236 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef __FENNIX_KERNEL_Xalloc_H__
+#define __FENNIX_KERNEL_Xalloc_H__
+
+#include <memory.hpp>
+#include <lock.hpp>
+#include <debug.h>
+
+typedef __UINT8_TYPE__ Xuint8_t;
+typedef __SIZE_TYPE__ Xsize_t;
+typedef __UINTPTR_TYPE__ Xuintptr_t;
+
+#define Xalloc_StopOnFail true
+#define Xalloc_MapPages true
+#define Xalloc_PAGE_SIZE PAGE_SIZE
+#define Xalloc_trace(m, ...) trace(m, ##__VA_ARGS__)
+#define Xalloc_warn(m, ...) warn(m, ##__VA_ARGS__)
+#define Xalloc_err(m, ...) error(m, ##__VA_ARGS__)
+
+#define XallocV1_def NewLock(XallocV1Lock)
+#define XallocV1_lock XallocV1Lock.Lock(__FUNCTION__)
+#define XallocV1_unlock XallocV1Lock.Unlock()
+
+#define XallocV2_def NewLock(XallocV2Lock)
+#define XallocV2_lock XallocV2Lock.Lock(__FUNCTION__)
+#define XallocV2_unlock XallocV2Lock.Unlock()
+
+namespace Xalloc
+{
+	class V1
+	{
+	private:
+		void *BaseVirtualAddress = nullptr;
+		void *FirstBlock = nullptr;
+		void *LastBlock = nullptr;
+
+		bool UserMapping = false;
+		bool SMAPUsed = false;
+
+	public:
+		/** @brief Execute "stac" instruction if the kernel has SMAP enabled */
+		void Xstac();
+
+		/** @brief Execute "clac" instruction if the kernel has SMAP enabled */
+		void Xclac();
+
+		/**
+		 * @brief Arrange the blocks to optimize the memory usage
+		 * The allocator is not arranged by default
+		 * to avoid performance issues.
+		 * This function will defragment the memory
+		 * and free the unused blocks.
+		 *
+		 * You should call this function when the
+		 * kernel is idle or when is not using
+		 * the allocator.
+		 */
+		void Arrange();
+
+		/**
+		 * @brief Allocate a new memory block
+		 *
+		 * @param Size Size of the block to allocate.
+		 * @return void* Pointer to the allocated block.
+		 */
+		void *malloc(Xsize_t Size);
+
+		/**
+		 * @brief Free a previously allocated block
+		 *
+		 * @param Address Address of the block to free.
+		 */
+		void free(void *Address);
+
+		/**
+		 * @brief Allocate a new memory block
+		 *
+		 * @param NumberOfBlocks Number of blocks to allocate.
+		 * @param Size Size of the block to allocate.
+		 * @return void* Pointer to the allocated block.
+		 */
+		void *calloc(Xsize_t NumberOfBlocks, Xsize_t Size);
+
+		/**
+		 * @brief Reallocate a previously allocated block
+		 *
+		 * @param Address Address of the block to reallocate.
+		 * @param Size New size of the block.
+		 * @return void* Pointer to the reallocated block.
+		 */
+		void *realloc(void *Address, Xsize_t Size);
+
+		/**
+		 * @brief Construct a new Allocator object
+		 *
+		 * @param BaseVirtualAddress Virtual address to map the pages.
+		 * @param UserMode Map the new pages with USER flag?
+		 * @param SMAPEnabled Does the kernel has Supervisor Mode Access Prevention enabled?
+		 */
+		V1(void *BaseVirtualAddress, bool UserMode, bool SMAPEnabled);
+
+		/**
+		 * @brief Destroy the Allocator object
+		 *
+		 */
+		~V1();
+	};
+
+	class V2
+	{
+	private:
+		class Block
+		{
+		public:
+			int Sanity = 0xA110C;
+			Block *Next = nullptr;
+			bool IsFree = true;
+			V2 *ctx = nullptr;
+
+			Xuint8_t *Data = nullptr;
+			Xsize_t DataSize = 0;
+
+			void Check();
+			Block(Xsize_t Size, V2 *ctx);
+			~Block();
+			void *operator new(Xsize_t);
+			void operator delete(void *Address);
+		} __attribute__((packed, aligned((16))));
+
+		/* The base address of the virtual memory */
+		Xuintptr_t BaseVirtualAddress = 0x0;
+
+		/* The size of the heap */
+		Xsize_t HeapSize = 0x0;
+
+		/* The used size of the heap */
+		Xsize_t HeapUsed = 0x0;
+
+		Block *FirstBlock = nullptr;
+
+		Xuint8_t *AllocateHeap(Xsize_t Size);
+		void FreeHeap(Xuint8_t *At, Xsize_t Size);
+
+		Xsize_t Align(Xsize_t Size);
+		void *FindFreeBlock(Xsize_t Size,
+							Block *&CurrentBlock);
+
+	public:
+		/**
+		 * Arrange the blocks to optimize the memory
+		 * usage.
+		 * The allocator is not arranged by default
+		 * to avoid performance issues.
+		 * This function will defragment the memory
+		 * and free the unused blocks.
+		 *
+		 * You should call this function when the
+		 * kernel is idle or when is not using the
+		 * allocator.
+		 */
+		void Arrange();
+
+		/**
+		 * Allocate a new memory block
+		 *
+		 * @param Size Size of the block to allocate.
+		 * @return void* Pointer to the allocated
+		 * block.
+		 */
+		void *malloc(Xsize_t Size);
+
+		/**
+		 * Free a previously allocated block
+		 *
+		 * @param Address Address of the block to
+		 * free.
+		 */
+		void free(void *Address);
+
+		/**
+		 * Allocate a new memory block
+		 *
+		 * @param NumberOfBlocks Number of blocks
+		 * to allocate.
+		 * @param Size Size of the block to allocate.
+		 * @return void* Pointer to the allocated
+		 * block.
+		 */
+		void *calloc(Xsize_t NumberOfBlocks,
+					 Xsize_t Size);
+
+		/**
+		 * Reallocate a previously allocated block
+		 *
+		 * @param Address Address of the block
+		 * to reallocate.
+		 * @param Size New size of the block.
+		 * @return void* Pointer to the reallocated
+		 * block.
+		 */
+		void *realloc(void *Address, Xsize_t Size);
+
+		/**
+		 * Construct a new Allocator object
+		 *
+		 * @param VirtualBase Virtual address
+		 * to map the pages.
+		 */
+		V2(void *VirtualBase);
+
+		/**
+		 * Destroy the Allocator object
+		 */
+		~V2();
+
+		friend class Block;
+	};
+}
+
+#endif // !__FENNIX_KERNEL_Xalloc_H__

core/memory/heap_allocators/Xalloc/XallocV1.cpp

@@ -0,0 +1,290 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "Xalloc.hpp"
+
+XallocV1_def;
+
+#define XALLOC_CONCAT(x, y) x##y
+#define XStoP(d) (((d) + PAGE_SIZE - 1) / PAGE_SIZE)
+#define XPtoS(d) ((d)*PAGE_SIZE)
+#define Xalloc_BlockSanityKey 0xA110C
+
+extern "C" void *Xalloc_REQUEST_PAGES(Xsize_t Pages);
+extern "C" void Xalloc_FREE_PAGES(void *Address, Xsize_t Pages);
+extern "C" void Xalloc_MAP_MEMORY(void *VirtualAddress, void *PhysicalAddress, Xsize_t Flags);
+extern "C" void Xalloc_UNMAP_MEMORY(void *VirtualAddress);
+
+// TODO: Change memcpy with an optimized version
+void *Xmemcpy(void *__restrict__ Destination, const void *__restrict__ Source, Xsize_t Length)
+{
+	unsigned char *dst = (unsigned char *)Destination;
+	const unsigned char *src = (const unsigned char *)Source;
+	for (Xsize_t i = 0; i < Length; i++)
+		dst[i] = src[i];
+	return Destination;
+}
+
+// TODO: Change memset with an optimized version
+void *Xmemset(void *__restrict__ Destination, int Data, Xsize_t Length)
+{
+	unsigned char *Buffer = (unsigned char *)Destination;
+	for (Xsize_t i = 0; i < Length; i++)
+		Buffer[i] = (unsigned char)Data;
+	return Destination;
+}
+
+namespace Xalloc
+{
+	class Block
+	{
+	public:
+		void *Address = nullptr;
+
+		int Sanity = Xalloc_BlockSanityKey;
+		Xsize_t Size = 0;
+		Block *Next = nullptr;
+		Block *Last = nullptr;
+		bool IsFree = true;
+
+		bool Check()
+		{
+			if (this->Sanity != Xalloc_BlockSanityKey)
+				return false;
+			return true;
+		}
+
+		Block(Xsize_t Size)
+		{
+			this->Address = Xalloc_REQUEST_PAGES(XStoP(Size + 1));
+			this->Size = Size;
+			Xmemset(this->Address, 0, Size);
+		}
+
+		~Block()
+		{
+			Xalloc_FREE_PAGES(this->Address, XStoP(this->Size + 1));
+		}
+
+		/**
+		 * @brief Overload new operator to allocate memory from the heap
+		 * @param Size Unused
+		 * @return void* Pointer to the allocated memory
+		 */
+		void *operator new(Xsize_t Size)
+		{
+			void *ptr = Xalloc_REQUEST_PAGES(XStoP(sizeof(Block)));
+			return ptr;
+			(void)(Size);
+		}
+
+		/**
+		 * @brief Overload delete operator to free memory from the heap
+		 * @param Address Pointer to the memory to free
+		 */
+		void operator delete(void *Address)
+		{
+			Xalloc_FREE_PAGES(Address, XStoP(sizeof(Block)));
+		}
+	} __attribute__((packed, aligned((16))));
+
+	class SmartSMAPClass
+	{
+	private:
+		V1 *allocator = nullptr;
+
+	public:
+		SmartSMAPClass(V1 *allocator)
+		{
+			this->allocator = allocator;
+			this->allocator->Xstac();
+		}
+		~SmartSMAPClass() { this->allocator->Xclac(); }
+	};
+#define SmartSMAP SmartSMAPClass XALLOC_CONCAT(SmartSMAP##_, __COUNTER__)(this)
+
+	void V1::Xstac()
+	{
+		if (this->SMAPUsed)
+		{
+#if defined(a86)
+			asm volatile("stac" ::
+							 : "cc");
+#endif
+		}
+	}
+
+	void V1::Xclac()
+	{
+		if (this->SMAPUsed)
+		{
+#if defined(a86)
+			asm volatile("clac" ::
+							 : "cc");
+#endif
+		}
+	}
+
+	void V1::Arrange()
+	{
+		Xalloc_err("Arrange() is not implemented yet!");
+	}
+
+	void *V1::malloc(Xsize_t Size)
+	{
+		if (Size == 0)
+		{
+			Xalloc_warn("Attempted to allocate 0 bytes!");
+			return nullptr;
+		}
+
+		SmartSMAP;
+		XallocV1_lock;
+
+		if (this->FirstBlock == nullptr)
+		{
+			this->FirstBlock = new Block(Size);
+			((Block *)this->FirstBlock)->IsFree = false;
+			XallocV1_unlock;
+			return ((Block *)this->FirstBlock)->Address;
+		}
+
+		Block *CurrentBlock = ((Block *)this->FirstBlock);
+		while (CurrentBlock != nullptr)
+		{
+			if (!CurrentBlock->Check())
+			{
+				Xalloc_err("Block %#lx has an invalid sanity key! (%#x != %#x)",
+						   (Xsize_t)CurrentBlock, CurrentBlock->Sanity, Xalloc_BlockSanityKey);
+				while (Xalloc_StopOnFail)
+					;
+			}
+			else if (CurrentBlock->IsFree && CurrentBlock->Size >= Size)
+			{
+				CurrentBlock->IsFree = false;
+				Xmemset(CurrentBlock->Address, 0, Size);
+				XallocV1_unlock;
+				return CurrentBlock->Address;
+			}
+			CurrentBlock = CurrentBlock->Next;
+		}
+
+		CurrentBlock = ((Block *)this->FirstBlock);
+		while (CurrentBlock->Next != nullptr)
+			CurrentBlock = CurrentBlock->Next;
+
+		CurrentBlock->Next = new Block(Size);
+		((Block *)CurrentBlock->Next)->Last = CurrentBlock;
+		((Block *)CurrentBlock->Next)->IsFree = false;
+		XallocV1_unlock;
+		return ((Block *)CurrentBlock->Next)->Address;
+	}
+
+	void V1::free(void *Address)
+	{
+		if (Address == nullptr)
+		{
+			Xalloc_warn("Attempted to free a null pointer!");
+			return;
+		}
+
+		SmartSMAP;
+		XallocV1_lock;
+
+		Block *CurrentBlock = ((Block *)this->FirstBlock);
+		while (CurrentBlock != nullptr)
+		{
+			if (!CurrentBlock->Check())
+			{
+				Xalloc_err("Block %#lx has an invalid sanity key! (%#x != %#x)",
+						   (Xsize_t)CurrentBlock, CurrentBlock->Sanity, Xalloc_BlockSanityKey);
+				while (Xalloc_StopOnFail)
+					;
+			}
+			else if (CurrentBlock->Address == Address)
+			{
+				if (CurrentBlock->IsFree)
+				{
+					Xalloc_warn("Attempted to free an already freed pointer!");
+					XallocV1_unlock;
+					return;
+				}
+
+				CurrentBlock->IsFree = true;
+				XallocV1_unlock;
+				return;
+			}
+			CurrentBlock = CurrentBlock->Next;
+		}
+
+		Xalloc_err("Invalid address %#lx.", Address);
+		XallocV1_unlock;
+	}
+
+	void *V1::calloc(Xsize_t NumberOfBlocks, Xsize_t Size)
+	{
+		if (NumberOfBlocks == 0 || Size == 0)
+		{
+			Xalloc_warn("The %s%s%s is 0!",
+						NumberOfBlocks == 0 ? "NumberOfBlocks" : "",
+						NumberOfBlocks == 0 && Size == 0 ? " and " : "",
+						Size == 0 ? "Size" : "");
+			return nullptr;
+		}
+
+		return this->malloc(NumberOfBlocks * Size);
+	}
+
+	void *V1::realloc(void *Address, Xsize_t Size)
+	{
+		if (Address == nullptr)
+			return this->malloc(Size);
+
+		if (Size == 0)
+		{
+			this->free(Address);
+			return nullptr;
+		}
+
+		// SmartSMAP;
+		// XallocV1_lock;
+		// ...
+		// XallocV1_unlock;
+
+		// TODO: Implement realloc
+		this->free(Address);
+		return this->malloc(Size);
+	}
+
+	V1::V1(void *BaseVirtualAddress, bool UserMode, bool SMAPEnabled)
+	{
+		SmartSMAP;
+		XallocV1_lock;
+		this->SMAPUsed = SMAPEnabled;
+		this->UserMapping = UserMode;
+		this->BaseVirtualAddress = BaseVirtualAddress;
+		XallocV1_unlock;
+	}
+
+	V1::~V1()
+	{
+		SmartSMAP;
+		XallocV1_lock;
+		Xalloc_trace("Destructor not implemented yet.");
+		XallocV1_unlock;
+	}
+}

core/memory/heap_allocators/Xalloc/XallocV2.cpp

@@ -0,0 +1,281 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "Xalloc.hpp"
+
+XallocV2_def;
+
+#define XALLOC_CONCAT(x, y) x##y
+#define XStoP(d) (((d) + PAGE_SIZE - 1) / PAGE_SIZE)
+#define XPtoS(d) ((d)*PAGE_SIZE)
+
+extern "C" void *Xalloc_REQUEST_PAGES(Xsize_t Pages);
+extern "C" void Xalloc_FREE_PAGES(void *Address, Xsize_t Pages);
+extern "C" void Xalloc_MAP_MEMORY(void *VirtualAddress,
+								  void *PhysicalAddress,
+								  Xsize_t Flags);
+extern "C" void Xalloc_UNMAP_MEMORY(void *VirtualAddress);
+
+#define Xalloc_BlockSanityKey 0xA110C
+
+/*
+	[ IN DEVELOPMENT ]
+*/
+
+namespace Xalloc
+{
+	void V2::Block::Check()
+	{
+		if (unlikely(this->Sanity != Xalloc_BlockSanityKey))
+		{
+			Xalloc_err("Block %#lx has an invalid sanity key! (%#x != %#x)",
+					   this, this->Sanity, Xalloc_BlockSanityKey);
+
+			while (Xalloc_StopOnFail)
+				;
+		}
+	}
+
+	V2::Block::Block(Xsize_t Size, V2 *ctx)
+	{
+		this->ctx = ctx;
+		this->Data = ctx->AllocateHeap(Size);
+		this->DataSize = Size;
+	}
+
+	V2::Block::~Block()
+	{
+	}
+
+	void *V2::Block::operator new(Xsize_t)
+	{
+		constexpr Xsize_t bPgs = XStoP(sizeof(Block));
+		void *ptr = Xalloc_REQUEST_PAGES(bPgs);
+		/* TODO: Do something with the rest of
+			the allocated memory */
+		return ptr;
+	}
+
+	void V2::Block::operator delete(void *Address)
+	{
+		constexpr Xsize_t bPgs = XStoP(sizeof(Block));
+		Xalloc_FREE_PAGES(Address, bPgs);
+	}
+
+	/* ========================================= */
+
+	Xuint8_t *V2::AllocateHeap(Xsize_t Size)
+	{
+		Size = this->Align(Size);
+		Xsize_t Pages = XStoP(Size);
+
+		Xuint8_t *FinalAddress = 0x0;
+		if (this->HeapUsed + Size >= this->HeapSize)
+		{
+			void *Address = Xalloc_REQUEST_PAGES(Pages);
+			void *VirtualAddress = (void *)(this->BaseVirtualAddress + this->HeapSize);
+			if (Xalloc_MapPages)
+			{
+				for (Xsize_t i = 0; i < Pages; i++)
+				{
+					Xuintptr_t Page = i * Xalloc_PAGE_SIZE;
+					void *vAddress = (void *)((Xuintptr_t)VirtualAddress + Page);
+					Xalloc_MAP_MEMORY(vAddress, (void *)((Xuintptr_t)Address + Page), 0x3);
+				}
+			}
+
+			this->HeapSize += XPtoS(Pages);
+			FinalAddress = (Xuint8_t *)VirtualAddress;
+		}
+		else
+			FinalAddress = (Xuint8_t *)(this->BaseVirtualAddress + this->HeapUsed);
+
+		this->HeapUsed += Size;
+		return (uint8_t *)FinalAddress;
+	}
+
+	void V2::FreeHeap(Xuint8_t *At, Xsize_t Size)
+	{
+		Xsize_t Pages = XStoP(Size);
+
+		if (Xalloc_MapPages)
+		{
+			for (Xsize_t i = 0; i < Pages; i++)
+			{
+				Xuintptr_t Page = i * Xalloc_PAGE_SIZE;
+				void *VirtualAddress = (void *)((Xuintptr_t)At + Page);
+				Xalloc_UNMAP_MEMORY(VirtualAddress);
+			}
+		}
+
+		Xalloc_FREE_PAGES(At, Pages);
+		this->HeapUsed -= Size;
+	}
+
+	Xsize_t V2::Align(Xsize_t Size)
+	{
+		return (Size + 0xF) & ~0xF;
+	}
+
+	void *V2::FindFreeBlock(Xsize_t Size, Block *&CurrentBlock)
+	{
+		if (this->FirstBlock == nullptr)
+		{
+			this->FirstBlock = new Block(Size, this);
+			this->FirstBlock->IsFree = false;
+			return this->FirstBlock->Data;
+		}
+
+		while (true)
+		{
+			CurrentBlock->Check();
+
+			/* FIXME: This will waste a lot of space
+				need better algorithm */
+			if (CurrentBlock->IsFree &&
+				CurrentBlock->DataSize >= Size)
+			{
+				CurrentBlock->IsFree = false;
+				return CurrentBlock->Data;
+			}
+
+			if (CurrentBlock->Next == nullptr)
+				break;
+
+			CurrentBlock = CurrentBlock->Next;
+		}
+
+		return nullptr;
+	}
+
+	void V2::Arrange()
+	{
+		Xalloc_err("Arrange() is not implemented yet!");
+	}
+
+	void *V2::malloc(Xsize_t Size)
+	{
+		if (Size == 0)
+		{
+			Xalloc_warn("Attempted to allocate 0 bytes!");
+			return nullptr;
+		}
+
+		XallocV2_lock;
+		Block *CurrentBlock = this->FirstBlock;
+		void *ret = this->FindFreeBlock(Size, CurrentBlock);
+		if (ret)
+		{
+			XallocV2_unlock;
+			return ret;
+		}
+
+		CurrentBlock->Next = new Block(Size, this);
+		CurrentBlock->Next->IsFree = false;
+		XallocV2_unlock;
+		return CurrentBlock->Next->Data;
+	}
+
+	void V2::free(void *Address)
+	{
+		if (Address == nullptr)
+		{
+			Xalloc_warn("Attempted to free a null pointer!");
+			return;
+		}
+
+		XallocV2_lock;
+
+		Block *CurrentBlock = ((Block *)this->FirstBlock);
+		while (CurrentBlock != nullptr)
+		{
+			CurrentBlock->Check();
+
+			if (CurrentBlock->Data == Address)
+			{
+				if (CurrentBlock->IsFree)
+					Xalloc_warn("Attempted to free an already freed block! %#lx", Address);
+
+				CurrentBlock->IsFree = true;
+				XallocV2_unlock;
+				return;
+			}
+			CurrentBlock = CurrentBlock->Next;
+		}
+
+		Xalloc_err("Invalid address %#lx.", Address);
+		XallocV2_unlock;
+	}
+
+	void *V2::calloc(Xsize_t NumberOfBlocks, Xsize_t Size)
+	{
+		if (NumberOfBlocks == 0 || Size == 0)
+		{
+			Xalloc_warn("The %s%s%s is 0!",
+						NumberOfBlocks == 0 ? "NumberOfBlocks" : "",
+						NumberOfBlocks == 0 && Size == 0 ? " and " : "",
+						Size == 0 ? "Size" : "");
+			return nullptr;
+		}
+
+		return this->malloc(NumberOfBlocks * Size);
+	}
+
+	void *V2::realloc(void *Address, Xsize_t Size)
+	{
+		if (Address == nullptr && Size != 0)
+			return this->malloc(Size);
+
+		if (Size == 0)
+		{
+			this->free(Address);
+			return nullptr;
+		}
+
+		// XallocV2_lock;
+		// ...
+		// XallocV2_unlock;
+
+		// TODO: Implement realloc
+		static int once = 0;
+		if (!once++)
+			Xalloc_trace("realloc is stub!");
+		this->free(Address);
+		return this->malloc(Size);
+	}
+
+	V2::V2(void *VirtualBase)
+	{
+		if (VirtualBase == 0x0 && Xalloc_MapPages)
+		{
+			Xalloc_err("VirtualBase is 0x0 and Xalloc_MapPages is true!");
+			while (true)
+				;
+		}
+
+		XallocV2_lock;
+		this->BaseVirtualAddress = Xuintptr_t(VirtualBase);
+		XallocV2_unlock;
+	}
+
+	V2::~V2()
+	{
+		XallocV2_lock;
+		Xalloc_trace("Destructor not implemented yet.");
+		XallocV2_unlock;
+	}
+}

core/memory/heap_allocators/liballoc_1_1/liballoc_1_1.c

@@ -0,0 +1,793 @@
+#include "liballoc_1_1.h"
+
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+
+/**  Durand's Amazing Super Duper Memory functions.  */
+
+#define VERSION "1.1"
+#define ALIGNMENT 16ul // 4ul				///< This is the byte alignment that memory must be allocated on. IMPORTANT for GTK and other stuff.
+
+#define ALIGN_TYPE char					   /// unsigned char[16] /// unsigned short
+#define ALIGN_INFO sizeof(ALIGN_TYPE) * 16 ///< Alignment information is stored right before the pointer. This is the number of bytes of information stored there.
+
+#define USE_CASE1
+#define USE_CASE2
+#define USE_CASE3
+#define USE_CASE4
+#define USE_CASE5
+
+/** This macro will conveniently align our pointer upwards */
+#define ALIGN(ptr)                                       \
+	if (ALIGNMENT > 1)                                   \
+	{                                                    \
+		uintptr_t diff;                                  \
+		ptr = (void *)((uintptr_t)ptr + ALIGN_INFO);     \
+		diff = (uintptr_t)ptr & (ALIGNMENT - 1);         \
+		if (diff != 0)                                   \
+		{                                                \
+			diff = ALIGNMENT - diff;                     \
+			ptr = (void *)((uintptr_t)ptr + diff);       \
+		}                                                \
+		*((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)) = \
+			diff + ALIGN_INFO;                           \
+	}
+
+#define UNALIGN(ptr)                                                     \
+	if (ALIGNMENT > 1)                                                   \
+	{                                                                    \
+		uintptr_t diff = *((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)); \
+		if (diff < (ALIGNMENT + ALIGN_INFO))                             \
+		{                                                                \
+			ptr = (void *)((uintptr_t)ptr - diff);                       \
+		}                                                                \
+	}
+
+#define LIBALLOC_MAGIC 0xc001c0de
+#define LIBALLOC_DEAD 0xdeaddead
+
+// #define LIBALLOCDEBUG 1
+#define LIBALLOCINFO 1
+
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+// #include <stdio.h>
+// #include <stdlib.h>
+#include <debug.h>
+
+// #define FLUSH() fflush(stdout)
+#define FLUSH()
+#define atexit(x)
+#define printf(m, ...) trace(m, ##__VA_ARGS__)
+
+#endif
+
+/** A structure found at the top of all system allocated
+ * memory blocks. It details the usage of the memory block.
+ */
+struct liballoc_major
+{
+	struct liballoc_major *prev;  ///< Linked list information.
+	struct liballoc_major *next;  ///< Linked list information.
+	unsigned int pages;			  ///< The number of pages in the block.
+	unsigned int size;			  ///< The number of pages in the block.
+	unsigned int usage;			  ///< The number of bytes used in the block.
+	struct liballoc_minor *first; ///< A pointer to the first allocated memory in the block.
+};
+
+/** This is a structure found at the beginning of all
+ * sections in a major block which were allocated by a
+ * malloc, calloc, realloc call.
+ */
+struct liballoc_minor
+{
+	struct liballoc_minor *prev;  ///< Linked list information.
+	struct liballoc_minor *next;  ///< Linked list information.
+	struct liballoc_major *block; ///< The owning block. A pointer to the major structure.
+	unsigned int magic;			  ///< A magic number to idenfity correctness.
+	unsigned int size;			  ///< The size of the memory allocated. Could be 1 byte or more.
+	unsigned int req_size;		  ///< The size of memory requested.
+};
+
+static struct liballoc_major *l_memRoot = NULL; ///< The root memory block acquired from the system.
+static struct liballoc_major *l_bestBet = NULL; ///< The major with the most free memory.
+
+static unsigned int l_pageSize = 4096;	   ///< The size of an individual page. Set up in liballoc_init.
+static unsigned int l_pageCount = 16;	   ///< The number of pages to request per chunk. Set up in liballoc_init.
+static unsigned long long l_allocated = 0; ///< Running total of allocated memory.
+static unsigned long long l_inuse = 0;	   ///< Running total of used memory.
+
+static long long l_warningCount = 0;	 ///< Number of warnings encountered
+static long long l_errorCount = 0;		 ///< Number of actual errors
+static long long l_possibleOverruns = 0; ///< Number of possible overruns
+
+// ***********   HELPER FUNCTIONS  *******************************
+
+__no_sanitize("undefined") static void *liballoc_memset(void *s, int c, size_t n)
+{
+	unsigned int i;
+	for (i = 0; i < n; i++)
+		((char *)s)[i] = c;
+
+	return s;
+}
+__no_sanitize("undefined") static void *liballoc_memcpy(void *s1, const void *s2, size_t n)
+{
+	char *cdest;
+	char *csrc;
+	unsigned int *ldest = (unsigned int *)s1;
+	unsigned int *lsrc = (unsigned int *)s2;
+
+	while (n >= sizeof(unsigned int))
+	{
+		*ldest++ = *lsrc++;
+		n -= sizeof(unsigned int);
+	}
+
+	cdest = (char *)ldest;
+	csrc = (char *)lsrc;
+
+	while (n > 0)
+	{
+		*cdest++ = *csrc++;
+		n -= 1;
+	}
+
+	return s1;
+}
+
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+__no_sanitize("undefined") static void liballoc_dump()
+{
+#ifdef LIBALLOCDEBUG
+	struct liballoc_major *maj = l_memRoot;
+	struct liballoc_minor *min = NULL;
+#endif
+
+	printf("liballoc: ------ Memory data ---------------\n");
+	printf("liballoc: System memory allocated: %i bytes\n", l_allocated);
+	printf("liballoc: Memory in used (malloc'ed): %i bytes\n", l_inuse);
+	printf("liballoc: Warning count: %i\n", l_warningCount);
+	printf("liballoc: Error count: %i\n", l_errorCount);
+	printf("liballoc: Possible overruns: %i\n", l_possibleOverruns);
+
+#ifdef LIBALLOCDEBUG
+	while (maj != NULL)
+	{
+		printf("liballoc: %lx: total = %i, used = %i\n",
+			   maj,
+			   maj->size,
+			   maj->usage);
+
+		min = maj->first;
+		while (min != NULL)
+		{
+			printf("liballoc:    %lx: %i bytes\n",
+				   min,
+				   min->size);
+			min = min->next;
+		}
+
+		maj = maj->next;
+	}
+#endif
+
+	FLUSH();
+}
+#endif
+
+// ***************************************************************
+
+__no_sanitize("undefined") static struct liballoc_major *allocate_new_page(unsigned int size)
+{
+	unsigned int st;
+	struct liballoc_major *maj;
+
+	// This is how much space is required.
+	st = size + sizeof(struct liballoc_major);
+	st += sizeof(struct liballoc_minor);
+
+	// Perfect amount of space?
+	if ((st % l_pageSize) == 0)
+		st = st / (l_pageSize);
+	else
+		st = st / (l_pageSize) + 1;
+	// No, add the buffer.
+
+	// Make sure it's >= the minimum size.
+	if (st < l_pageCount)
+		st = l_pageCount;
+
+	maj = (struct liballoc_major *)liballoc_alloc(st);
+
+	if (maj == NULL)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: liballoc_alloc( %i ) return NULL\n", st);
+		FLUSH();
+#endif
+		return NULL; // uh oh, we ran out of memory.
+	}
+
+	maj->prev = NULL;
+	maj->next = NULL;
+	maj->pages = st;
+	maj->size = st * l_pageSize;
+	maj->usage = sizeof(struct liballoc_major);
+	maj->first = NULL;
+
+	l_allocated += maj->size;
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: Resource allocated %lx of %i pages (%i bytes) for %i size.\n", maj, st, maj->size, size);
+
+	printf("liballoc: Total memory usage = %i KB\n", (int)((l_allocated / (1024))));
+	FLUSH();
+#endif
+
+	return maj;
+}
+
+__no_sanitize("undefined") void *PREFIX(malloc)(size_t req_size)
+{
+	int startedBet = 0;
+	unsigned long long bestSize = 0;
+	void *p = NULL;
+	uintptr_t diff;
+	struct liballoc_major *maj;
+	struct liballoc_minor *min;
+	struct liballoc_minor *new_min;
+	unsigned long size = req_size;
+
+	// For alignment, we adjust size so there's enough space to align.
+	if (ALIGNMENT > 1)
+	{
+		size += ALIGNMENT + ALIGN_INFO;
+	}
+	// So, ideally, we really want an alignment of 0 or 1 in order
+	// to save space.
+
+	liballoc_lock();
+
+	if (size == 0)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: alloc( 0 ) called from %lx\n",
+			   __builtin_return_address(0));
+		FLUSH();
+#endif
+		liballoc_unlock();
+		return PREFIX(malloc)(1);
+	}
+
+	if (l_memRoot == NULL)
+	{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+#ifdef LIBALLOCDEBUG
+		printf("liballoc: initialization of liballoc " VERSION "\n");
+#endif
+		atexit(liballoc_dump);
+		FLUSH();
+#endif
+
+		// This is the first time we are being used.
+		l_memRoot = allocate_new_page(size);
+		if (l_memRoot == NULL)
+		{
+			liballoc_unlock();
+#ifdef LIBALLOCDEBUG
+			printf("liballoc: initial l_memRoot initialization failed\n", p);
+			FLUSH();
+#endif
+			return NULL;
+		}
+
+#ifdef LIBALLOCDEBUG
+		printf("liballoc: set up first memory major %lx\n", l_memRoot);
+		FLUSH();
+#endif
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: %lx PREFIX(malloc)( %i ): ",
+		   __builtin_return_address(0),
+		   size);
+	FLUSH();
+#endif
+
+	// Now we need to bounce through every major and find enough space....
+
+	maj = l_memRoot;
+	startedBet = 0;
+
+	// Start at the best bet....
+	if (l_bestBet != NULL)
+	{
+		bestSize = l_bestBet->size - l_bestBet->usage;
+
+		if (bestSize > (size + sizeof(struct liballoc_minor)))
+		{
+			maj = l_bestBet;
+			startedBet = 1;
+		}
+	}
+
+	while (maj != NULL)
+	{
+		diff = maj->size - maj->usage;
+		// free memory in the block
+
+		if (bestSize < diff)
+		{
+			// Hmm.. this one has more memory then our bestBet. Remember!
+			l_bestBet = maj;
+			bestSize = diff;
+		}
+
+#ifdef USE_CASE1
+
+		// CASE 1:  There is not enough space in this major block.
+		if (diff < (size + sizeof(struct liballoc_minor)))
+		{
+#ifdef LIBALLOCDEBUG
+			printf("CASE 1: Insufficient space in block %lx\n", maj);
+			FLUSH();
+#endif
+
+			// Another major block next to this one?
+			if (maj->next != NULL)
+			{
+				maj = maj->next; // Hop to that one.
+				continue;
+			}
+
+			if (startedBet == 1) // If we started at the best bet,
+			{					 // let's start all over again.
+				maj = l_memRoot;
+				startedBet = 0;
+				continue;
+			}
+
+			// Create a new major block next to this one and...
+			maj->next = allocate_new_page(size); // next one will be okay.
+			if (maj->next == NULL)
+				break; // no more memory.
+			maj->next->prev = maj;
+			maj = maj->next;
+
+			// .. fall through to CASE 2 ..
+		}
+
+#endif
+
+#ifdef USE_CASE2
+
+		// CASE 2: It's a brand new block.
+		if (maj->first == NULL)
+		{
+			maj->first = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->next = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + sizeof(struct liballoc_minor);
+
+			l_inuse += size;
+
+			p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
+
+			ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+			printf("CASE 2: returning %lx\n", p);
+			FLUSH();
+#endif
+			liballoc_unlock(); // release the lock
+			return p;
+		}
+
+#endif
+
+#ifdef USE_CASE3
+
+		// CASE 3: Block in use and enough space at the start of the block.
+		diff = (uintptr_t)(maj->first);
+		diff -= (uintptr_t)maj;
+		diff -= sizeof(struct liballoc_major);
+
+		if (diff >= (size + sizeof(struct liballoc_minor)))
+		{
+			// Yes, space in front. Squeeze in.
+			maj->first->prev = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
+			maj->first->prev->next = maj->first;
+			maj->first = maj->first->prev;
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + sizeof(struct liballoc_minor);
+
+			l_inuse += size;
+
+			p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
+			ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+			printf("CASE 3: returning %lx\n", p);
+			FLUSH();
+#endif
+			liballoc_unlock(); // release the lock
+			return p;
+		}
+
+#endif
+
+#ifdef USE_CASE4
+
+		// CASE 4: There is enough space in this block. But is it contiguous?
+		min = maj->first;
+
+		// Looping within the block now...
+		while (min != NULL)
+		{
+			// CASE 4.1: End of minors in a block. Space from last and end?
+			if (min->next == NULL)
+			{
+				// the rest of this block is free...  is it big enough?
+				diff = (uintptr_t)(maj) + maj->size;
+				diff -= (uintptr_t)min;
+				diff -= sizeof(struct liballoc_minor);
+				diff -= min->size;
+				// minus already existing usage..
+
+				if (diff >= (size + sizeof(struct liballoc_minor)))
+				{
+					// yay....
+					min->next = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
+					min->next->prev = min;
+					min = min->next;
+					min->next = NULL;
+					min->magic = LIBALLOC_MAGIC;
+					min->block = maj;
+					min->size = size;
+					min->req_size = req_size;
+					maj->usage += size + sizeof(struct liballoc_minor);
+
+					l_inuse += size;
+
+					p = (void *)((uintptr_t)min + sizeof(struct liballoc_minor));
+					ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+					printf("CASE 4.1: returning %lx\n", p);
+					FLUSH();
+#endif
+					liballoc_unlock(); // release the lock
+					return p;
+				}
+			}
+
+			// CASE 4.2: Is there space between two minors?
+			if (min->next != NULL)
+			{
+				// is the difference between here and next big enough?
+				diff = (uintptr_t)(min->next);
+				diff -= (uintptr_t)min;
+				diff -= sizeof(struct liballoc_minor);
+				diff -= min->size;
+				// minus our existing usage.
+
+				if (diff >= (size + sizeof(struct liballoc_minor)))
+				{
+					// yay......
+					new_min = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
+
+					new_min->magic = LIBALLOC_MAGIC;
+					new_min->next = min->next;
+					new_min->prev = min;
+					new_min->size = size;
+					new_min->req_size = req_size;
+					new_min->block = maj;
+					min->next->prev = new_min;
+					min->next = new_min;
+					maj->usage += size + sizeof(struct liballoc_minor);
+
+					l_inuse += size;
+
+					p = (void *)((uintptr_t)new_min + sizeof(struct liballoc_minor));
+					ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+					printf("CASE 4.2: returning %lx\n", p);
+					FLUSH();
+#endif
+
+					liballoc_unlock(); // release the lock
+					return p;
+				}
+			} // min->next != NULL
+
+			min = min->next;
+		} // while min != NULL ...
+
+#endif
+
+#ifdef USE_CASE5
+
+		// CASE 5: Block full! Ensure next block and loop.
+		if (maj->next == NULL)
+		{
+#ifdef LIBALLOCDEBUG
+			printf("CASE 5: block full\n");
+			FLUSH();
+#endif
+
+			if (startedBet == 1)
+			{
+				maj = l_memRoot;
+				startedBet = 0;
+				continue;
+			}
+
+			// we've run out. we need more...
+			maj->next = allocate_new_page(size); // next one guaranteed to be okay
+			if (maj->next == NULL)
+				break; //  uh oh,  no more memory.....
+			maj->next->prev = maj;
+		}
+
+#endif
+
+		maj = maj->next;
+	} // while (maj != NULL)
+
+	liballoc_unlock(); // release the lock
+
+#ifdef LIBALLOCDEBUG
+	printf("All cases exhausted. No memory available.\n");
+	FLUSH();
+#endif
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+	printf("liballoc: WARNING: PREFIX(malloc)( %i ) returning NULL.\n", size);
+	liballoc_dump();
+	FLUSH();
+#endif
+	return NULL;
+}
+
+__no_sanitize("undefined") void PREFIX(free)(void *ptr)
+{
+	struct liballoc_minor *min;
+	struct liballoc_major *maj;
+
+	if (ptr == NULL)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: PREFIX(free)( NULL ) called from %lx\n",
+			   __builtin_return_address(0));
+		FLUSH();
+#endif
+		return;
+	}
+
+	UNALIGN(ptr);
+
+	liballoc_lock(); // lockit
+
+	min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
+
+	if (min->magic != LIBALLOC_MAGIC)
+	{
+		l_errorCount += 1;
+
+		// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
+		if (
+			((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
+			((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
+			((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
+		{
+			l_possibleOverruns += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Possible 1-3 byte overrun for magic %lx != %lx\n",
+				   min->magic,
+				   LIBALLOC_MAGIC);
+			FLUSH();
+#endif
+		}
+
+		if (min->magic == LIBALLOC_DEAD)
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: multiple PREFIX(free)() attempt on %lx from %lx.\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+		else
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Bad PREFIX(free)( %lx ) called from %lx\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+
+		// being lied to...
+		liballoc_unlock(); // release the lock
+		return;
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: %lx PREFIX(free)( %lx ): ",
+		   __builtin_return_address(0),
+		   ptr);
+	FLUSH();
+#endif
+
+	maj = min->block;
+
+	l_inuse -= min->size;
+
+	maj->usage -= (min->size + sizeof(struct liballoc_minor));
+	min->magic = LIBALLOC_DEAD; // No mojo.
+
+	if (min->next != NULL)
+		min->next->prev = min->prev;
+	if (min->prev != NULL)
+		min->prev->next = min->next;
+
+	if (min->prev == NULL)
+		maj->first = min->next;
+	// Might empty the block. This was the first
+	// minor.
+
+	// We need to clean up after the majors now....
+
+	if (maj->first == NULL) // Block completely unused.
+	{
+		if (l_memRoot == maj)
+			l_memRoot = maj->next;
+		if (l_bestBet == maj)
+			l_bestBet = NULL;
+		if (maj->prev != NULL)
+			maj->prev->next = maj->next;
+		if (maj->next != NULL)
+			maj->next->prev = maj->prev;
+		l_allocated -= maj->size;
+
+		liballoc_free(maj, maj->pages);
+	}
+	else
+	{
+		if (l_bestBet != NULL)
+		{
+			int bestSize = l_bestBet->size - l_bestBet->usage;
+			int majSize = maj->size - maj->usage;
+
+			if (majSize > bestSize)
+				l_bestBet = maj;
+		}
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("OK\n");
+	FLUSH();
+#endif
+
+	liballoc_unlock(); // release the lock
+}
+
+__no_sanitize("undefined") void *PREFIX(calloc)(size_t nobj, size_t size)
+{
+	int real_size;
+	void *p;
+
+	real_size = nobj * size;
+
+	p = PREFIX(malloc)(real_size);
+
+	liballoc_memset(p, 0, real_size);
+
+	return p;
+}
+
+__no_sanitize("undefined") void *PREFIX(realloc)(void *p, size_t size)
+{
+	void *ptr;
+	struct liballoc_minor *min;
+	unsigned int real_size;
+
+	// Honour the case of size == 0 => free old and return NULL
+	if (size == 0)
+	{
+		PREFIX(free)
+		(p);
+		return NULL;
+	}
+
+	// In the case of a NULL pointer, return a simple malloc.
+	if (p == NULL)
+		return PREFIX(malloc)(size);
+
+	// Unalign the pointer if required.
+	ptr = p;
+	UNALIGN(ptr);
+
+	liballoc_lock(); // lockit
+
+	min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
+
+	// Ensure it is a valid structure.
+	if (min->magic != LIBALLOC_MAGIC)
+	{
+		l_errorCount += 1;
+
+		// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
+		if (
+			((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
+			((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
+			((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
+		{
+			l_possibleOverruns += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Possible 1-3 byte overrun for magic %lx != %lx\n",
+				   min->magic,
+				   LIBALLOC_MAGIC);
+			FLUSH();
+#endif
+		}
+
+		if (min->magic == LIBALLOC_DEAD)
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: multiple PREFIX(free)() attempt on %lx from %lx.\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+		else
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Bad PREFIX(free)( %lx ) called from %lx\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+
+		// being lied to...
+		liballoc_unlock(); // release the lock
+		return NULL;
+	}
+
+	// Definitely a memory block.
+
+	real_size = min->req_size;
+
+	if (real_size >= size)
+	{
+		min->req_size = size;
+		liballoc_unlock();
+		return p;
+	}
+
+	liballoc_unlock();
+
+	// If we got here then we're reallocating to a block bigger than us.
+	ptr = PREFIX(malloc)(size); // We need to allocate new memory
+	liballoc_memcpy(ptr, p, real_size);
+	PREFIX(free)
+	(p);
+
+	return ptr;
+}

core/memory/heap_allocators/liballoc_1_1/liballoc_1_1.h

@@ -0,0 +1,74 @@
+#ifndef _LIBALLOC_H
+#define _LIBALLOC_H
+
+#include <types.h>
+
+/** \defgroup ALLOCHOOKS liballoc hooks
+ *
+ * These are the OS specific functions which need to
+ * be implemented on any platform that the library
+ * is expected to work on.
+ */
+
+/** @{ */
+
+// If we are told to not define our own size_t, then we skip the define.
+// #define _HAVE_UINTPTR_T
+// typedef	unsigned long	uintptr_t;
+
+// This lets you prefix malloc and friends
+#define PREFIX(func) kliballoc_##func
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /** This function is supposed to lock the memory data structures. It
+     * could be as simple as disabling interrupts or acquiring a spinlock.
+     * It's up to you to decide.
+     *
+     * \return 0 if the lock was acquired successfully. Anything else is
+     * failure.
+     */
+    extern int liballoc_lock();
+
+    /** This function unlocks what was previously locked by the liballoc_lock
+     * function.  If it disabled interrupts, it enables interrupts. If it
+     * had acquiried a spinlock, it releases the spinlock. etc.
+     *
+     * \return 0 if the lock was successfully released.
+     */
+    extern int liballoc_unlock();
+
+    /** This is the hook into the local system which allocates pages. It
+     * accepts an integer parameter which is the number of pages
+     * required.  The page size was set up in the liballoc_init function.
+     *
+     * \return NULL if the pages were not allocated.
+     * \return A pointer to the allocated memory.
+     */
+    extern void *liballoc_alloc(size_t);
+
+    /** This frees previously allocated memory. The void* parameter passed
+     * to the function is the exact same value returned from a previous
+     * liballoc_alloc call.
+     *
+     * The integer value is the number of pages to free.
+     *
+     * \return 0 if the memory was successfully freed.
+     */
+    extern int liballoc_free(void *, size_t);
+
+    extern void *PREFIX(malloc)(size_t);          ///< The standard function.
+    extern void *PREFIX(realloc)(void *, size_t); ///< The standard function.
+    extern void *PREFIX(calloc)(size_t, size_t);  ///< The standard function.
+    extern void PREFIX(free)(void *);             ///< The standard function.
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+
+#endif

core/memory/heap_allocators/liballoc_1_1/liballoc_hooks.cpp

@@ -0,0 +1,26 @@
+#include <types.h>
+#include <lock.hpp>
+#include <memory.hpp>
+
+NewLock(liballocLock);
+
+EXTERNC int liballoc_lock()
+{
+    return liballocLock.Lock(__FUNCTION__);
+}
+
+EXTERNC int liballoc_unlock()
+{
+    return liballocLock.Unlock();
+}
+
+EXTERNC void *liballoc_alloc(size_t Pages)
+{
+    return KernelAllocator.RequestPages(Pages);
+}
+
+EXTERNC int liballoc_free(void *Address, size_t Pages)
+{
+    KernelAllocator.FreePages(Address, Pages);
+    return 0;
+}