[kernel] Remove explicit allocator passing

Many kernel objects had to keep a hold of refrences to allocators in
order to pass them on down the call chain. Remove those explicit
refrences and use `operator new`, `operator delete`, and define new
`kalloc` and `kfree`.

Also remove `slab_allocator` and replace it with a new mixin for slab
allocation, `slab_allocated`, that overrides `operator new` and
`operator free` for its subclass.

Remove some no longer used related headers, `buddy_allocator.h` and
`address_manager.h`

Tags: memory

src/kernel/device_manager.cpp

@@ -60,12 +60,7 @@ void irq4_callback(void *)
 
 
 device_manager::device_manager(const void *root_table, kutil::allocator &alloc) :
-	m_lapic(nullptr),
-	m_ioapics(alloc),
-	m_pci(alloc),
-	m_devices(alloc),
-	m_irqs(alloc),
-	m_blockdevs(alloc)
+	m_lapic(nullptr)
 {
 	kassert(root_table != 0, "ACPI root table pointer is null.");
 

src/kernel/main.cpp

@@ -99,13 +99,13 @@ kernel_main(args::header *header)
 	log::debug(logs::boot, "Runtime service is at: %016lx", header->runtime_services);
 
 	// Load the module tagged as initrd
-	kutil::vector<initrd::disk> initrds(heap);
+	kutil::vector<initrd::disk> initrds;
 	for (unsigned i = 0; i < header->num_modules; ++i) {
 		args::module &mod = header->modules[i];
 		if (mod.type != args::mod_type::initrd)
 			continue;
 
-		initrd::disk &ird = initrds.emplace(mod.location, heap);
+		initrd::disk &ird = initrds.emplace(mod.location);
 		log::info(logs::boot, "initrd loaded with %d files.", ird.files().count());
 		for (auto &f : ird.files())
 			log::info(logs::boot, "  %s%s (%d bytes).", f.executable() ? "*" : "", f.name(), f.size());
@@ -159,7 +159,7 @@ kernel_main(args::header *header)
 	devices->get_lapic()->calibrate_timer();
 
 	syscall_enable();
-	scheduler *sched = new (&scheduler::get()) scheduler(devices->get_lapic(), heap);
+	scheduler *sched = new (&scheduler::get()) scheduler(devices->get_lapic());
 
 	sched->create_kernel_task(-1, logger_task);
 

src/kernel/memory_bootstrap.cpp

@@ -31,6 +31,11 @@ void * operator new [] (size_t size)       { return g_kernel_heap.allocate(size)
 void operator delete (void *p) noexcept    { return g_kernel_heap.free(p); }
 void operator delete [] (void *p) noexcept { return g_kernel_heap.free(p); }
 
+namespace kutil {
+void * kalloc(size_t size) { return g_kernel_heap.allocate(size); }
+void kfree(void *p) { return g_kernel_heap.free(p); }
+}
+
 void walk_page_table(
 	page_table *table,
 	page_table::level level,
@@ -90,8 +95,7 @@ memory_initialize(args::header *kargs)
 
 	new (&g_kernel_space) kutil::vm_space {
 		kernel_offset,
-		(page_offset-kernel_offset),
-		g_kernel_heap};
+		(page_offset-kernel_offset)};
 
 
 	uintptr_t current_start = 0;

src/kernel/objects/kobject.cpp

@@ -12,7 +12,6 @@ static j6_koid_t next_koid;
 kobject::kobject(type t, j6_signal_t signals) :
 	m_koid(koid_generate(t)),
 	m_signals(signals),
-	m_observers(g_kernel_heap),
 	m_handle_count(0)
 {}
 

src/kernel/process.cpp

@@ -1,4 +1,4 @@
-#include "kutil/heap_allocator.h"
+#include "kutil/assert.h"
 #include "cpu.h"
 #include "debug.h"
 #include "log.h"
@@ -6,7 +6,6 @@
 #include "scheduler.h"
 
 extern "C" void task_fork_return_thunk();
-extern kutil::heap_allocator g_kernel_heap; // TODO: this is a bad hack to get access to the heap
 
 void
 process::exit(uint32_t code)
@@ -68,7 +67,7 @@ process::setup_kernel_stack()
 	constexpr unsigned null_frame_entries = 2;
 	constexpr size_t null_frame_size = null_frame_entries * sizeof(uint64_t);
 
-	void *stack_bottom = g_kernel_heap.allocate(initial_stack_size);
+	void *stack_bottom = kutil::kalloc(initial_stack_size);
 	kutil::memset(stack_bottom, 0, initial_stack_size);
 
 	log::debug(logs::memory, "Created kernel stack at %016lx size 0x%lx",

src/kernel/scheduler.cpp

@@ -16,7 +16,7 @@
 
 using memory::initial_stack;
 
-scheduler scheduler::s_instance(nullptr, kutil::allocator::invalid);
+scheduler scheduler::s_instance(nullptr);
 
 const uint64_t rflags_noint = 0x002;
 const uint64_t rflags_int = 0x202;
@@ -28,12 +28,11 @@ extern "C" {
 
 extern uint64_t idle_stack_end;
 
-scheduler::scheduler(lapic *apic, kutil::allocator &alloc) :
+scheduler::scheduler(lapic *apic) :
 	m_apic(apic),
-	m_next_pid(1),
-	m_process_allocator(alloc)
+	m_next_pid(1)
 {
-	auto *idle = m_process_allocator.pop();
+	auto *idle = new process_node;
 	uint8_t last_pri = num_priorities - 1;
 
 	// The kernel idle task, also the thread we're in now
@@ -121,7 +120,7 @@ scheduler::create_process(pid_t pid)
 {
 	kassert(pid <= 0, "Cannot specify a positive pid in create_process");
 
-	auto *proc = m_process_allocator.pop();
+	auto *proc = new process_node;
 	proc->pid = pid ? pid : m_next_pid++;
 	proc->priority = default_priority;
 	return proc;
@@ -233,7 +232,7 @@ void scheduler::prune(uint64_t now)
 				if (parent && parent->wake_on_child(remove)) {
 					m_blocked.remove(parent);
 					m_runlists[parent->priority].push_front(parent);
-					m_process_allocator.push(remove);
+					delete remove;
 				} else {
 					m_exited.push_back(remove);
 				}

src/kernel/scheduler.h

@@ -4,7 +4,6 @@
 
 #include <stdint.h>
 #include "kutil/allocator.h"
-#include "kutil/slab_allocator.h"
 #include "process.h"
 
 class lapic;
@@ -31,8 +30,7 @@ public:
 
 	/// Constructor.
 	/// \arg apic  Pointer to the local APIC object
-	/// \arg alloc Allocator to use for TCBs
-	scheduler(lapic *apic, kutil::allocator &alloc);
+	scheduler(lapic *apic);
 
 	/// Create a new process from a program image in memory.
 	/// \arg name  Name of the program image
@@ -86,9 +84,6 @@ private:
 	uint32_t m_next_pid;
 	uint32_t m_tick_count;
 
-	using process_slab = kutil::slab_allocator<process>;
-	process_slab m_process_allocator;
-
 	process_node *m_current;
 	process_list m_runlists[num_priorities];
 	process_list m_blocked;