Move malloc into kutil

src/kernel/allocator.cpp

@@ -0,0 +1,9 @@
+#include "kutil/memory_manager.h"
+
+kutil::memory_manager g_kernel_memory_manager;
+
+// kutil malloc/free implementation
+namespace kutil {
+	void * malloc(size_t n) { return g_kernel_memory_manager.allocate(n); }
+	void free(void *p) { g_kernel_memory_manager.free(p); }
+}

src/kernel/kalloc.cpp

@@ -1,11 +0,0 @@
-#include "kutil/memory_manager.h"
-
-kutil::memory_manager g_kernel_memory_manager;
-
-void * kalloc(size_t length)				{ return g_kernel_memory_manager.allocate(length); }
-void kfree(void *p)							{ g_kernel_memory_manager.free(p); }
-
-void * operator new (size_t n)				{ return g_kernel_memory_manager.allocate(n); }
-void * operator new[] (size_t n)			{ return g_kernel_memory_manager.allocate(n); }
-void operator delete (void *p) noexcept		{ return g_kernel_memory_manager.free(p); }
-void operator delete[] (void *p) noexcept	{ return g_kernel_memory_manager.free(p); }

src/kernel/kalloc.h

@@ -1,17 +0,0 @@
-#pragma once
-/// \file kalloc.h
-/// Definitions of kalloc() and kfree()
-
-#include <stddef.h>
-
-
-/// Allocate kernel space memory.
-/// \arg length  The amount of memory to allocate, in bytes
-/// \returns     A pointer to the allocated memory, or nullptr if
-///              allocation failed.
-inline void * kalloc(size_t length);
-
-/// Free kernel space memory.
-/// \arg p   The pointer to free
-inline void kfree(void *p);
-

src/modules/kutil/memory.cpp

@@ -1,6 +1,10 @@
 #include "memory.h"
 
 void * operator new (size_t, void *p) noexcept	{ return p; }
+void * operator new (size_t n)					{ return kutil::malloc(n); }
+void * operator new[] (size_t n)				{ return kutil::malloc(n); }
+void operator delete (void *p) noexcept			{ return kutil::free(p); }
+void operator delete[] (void *p) noexcept		{ return kutil::free(p); }
 
 namespace kutil {
 

src/modules/kutil/memory.h

@@ -11,6 +11,18 @@ void * operator new (size_t, void *p) noexcept;
 
 namespace kutil {
 
+/// Allocate memory. Note: this needs to be implemented
+/// by the kernel, or other program using this library.
+/// \arg n   The number of bytes to allocate
+/// \returns The allocated memory
+void * malloc(size_t n);
+
+/// Free memory allocated by malloc(). Note: this needs
+/// to be implemented by the kernel, or other program
+/// using this library.
+/// \arg p   A pointer previously returned by malloc()
+void free(void *p);
+
 /// Fill memory with the given value.
 /// \arg p   The beginning of the memory area to fill
 /// \arg v   The byte value to fill memory with
@@ -25,15 +37,29 @@ void * memset(void *p, uint8_t v, size_t n);
 /// \returns A pointer to the destination memory
 void * memcpy(void *dest, void *src, size_t n);
 
+/// Read a value of type T from a location in memory
+/// \arg p   The location in memory to read
+/// \returns The value at the given location cast to T
 template <typename T>
-inline T read_from(const void *p) { return *reinterpret_cast<const T *>(p); }
-
-template <typename T>
-inline T * offset_pointer(T *p, size_t offset)
+inline T read_from(const void *p)
 {
-	return reinterpret_cast<T *>(reinterpret_cast<addr_t>(p) + offset);
+	return *reinterpret_cast<const T *>(p);
 }
 
+/// Get a pointer that's offset from another pointer
+/// \arg p   The base pointer
+/// \arg n   The offset in bytes
+/// \returns The offset pointer
+template <typename T>
+inline T * offset_pointer(T *p, size_t n)
+{
+	return reinterpret_cast<T *>(reinterpret_cast<addr_t>(p) + n);
+}
+
+/// Return a pointer with the given bits masked out
+/// \arg p    The original pointer
+/// \arg mask A bitmask of bits to clear from p
+/// \returns  The masked pointer
 template <typename T>
 inline T* mask_pointer(T *p, addr_t mask)
 {

src/modules/kutil/vector.h

@@ -142,7 +142,7 @@ public:
 	/// \arg capacity  Number of elements to allocate
 	void set_capacity(size_t capacity)
 	{
-		T *new_array = new T[capacity];
+		T *new_array = reinterpret_cast<T *>(malloc(capacity * sizeof(T)));
 		size_t size = std::min(capacity, m_size);
 
 		kutil::memcpy(new_array, m_elements, size * sizeof(T));