add allocator spinlock

Author: braindigitalis

src/ap.c

@@ -13,8 +13,8 @@ void kmain_ap(struct limine_smp_info *info)
 	 * @todo Insert cpu-local scheduler loop here.
 	 * Each AP will run its own list of executing BASIC processes. Accessing
 	 * the list of other APs and the BSP will be strictly controlled via a
-	 * marshalled lookup system using a spinlock, e.g. if AP 1 wants to check if
-	 * PID X on AP 2 is still running.
+	 * marshalled lookup system using a spinlock, e.g. if AP 1 wants to start a new
+	 * process on AP 2, it signals via this system.
 	 *
 	 * This will be done as follows:
 	 *
@@ -24,5 +24,8 @@ void kmain_ap(struct limine_smp_info *info)
 	 * 4) Initially AP's will wait for a start command in their queue,
 	 *    they won't run their scheduler until they receive this command. This allows them all to
 	 *    gracefully wait until the first BASIC process is ready to be loaded (/programs/init).
+	 * 5) A shared process list will be used for enumerating processes and checking process
+	 *    state, so we dont have to peek at another scheduler instance's command queue to
+	 *    see if a process ours is waiting on still lives.
 	 */
 }

src/kmalloc.c

@@ -13,6 +13,8 @@ static uint64_t allocated = 0;
 
 static uint32_t low_mem_cur = LOW_HEAP_START;
 
+static spinlock_t allocator_lock = 0;
+
 volatile struct limine_memmap_request memory_map_request = {
 	.id = LIMINE_MEMMAP_REQUEST,
 	.revision = 0,
@@ -29,6 +31,8 @@ void init_heap() {
 	uint64_t best_len = 0;
 	uint64_t best_addr = 0;
 
+	init_spinlock(&allocator_lock);
+
 	for (uint64_t i = 0; i < memory_map_request.response->entry_count; ++i) {
 		struct limine_memmap_entry* entry = memory_map_request.response->entries[i];
 		if (entry->type == LIMINE_MEMMAP_USABLE && entry->length > best_len) {
@@ -54,29 +58,35 @@ void print_heapinfo() {
 }
 
 void* kmalloc(uint64_t size) {
+	lock_spinlock(&allocator_lock);
 	void* p = ta_alloc(size);
 	allocated += ta_usable_size((void*)p);
+	unlock_spinlock(&allocator_lock);
 	return p;
 }
 
 void kfree(const void* ptr) {
 	if (!ptr) {
 		return;
 	}
+	lock_spinlock(&allocator_lock);
 	uintptr_t a = (uintptr_t)ptr;
 	if (a >= LOW_HEAP_START && a < LOW_HEAP_MAX) {
 		preboot_fail("kfree: tried to free low heap memory - use kfree_low instead!");
 	}
 	allocated -= ta_usable_size((void*)ptr);
 	ta_free((void*)ptr);
+	unlock_spinlock(&allocator_lock);
 }
 
 uint32_t kmalloc_low(uint32_t size) {
+	lock_spinlock(&allocator_lock);
 	uint32_t ret = low_mem_cur;
 	if (ret + size >= LOW_HEAP_MAX) {
 		preboot_fail("kmalloc_low exhausted");
 	}
 	low_mem_cur += size;
+	unlock_spinlock(&allocator_lock);
 	return ret;
 }