More locks and checks

src/arch/x86/kmem.cpp

@@ -42,6 +42,7 @@ void         init_kern_heap() {
 }
 
 static void extend_heap(size_t n_pages) {
+    assert(kmem_lock.test() && kmem_lock.owner() == Scheduler::cur_task());
     for (size_t i = 0; i < n_pages; i++) {
         void *p = get4k();
         assert2(p != NULL, "Kernel out of memory!");
@@ -53,6 +54,7 @@ static void extend_heap(size_t n_pages) {
 
 // n is required length!
 struct HeapEntry *split_entry(struct HeapEntry *what, size_t n) {
+    assert(kmem_lock.test() && kmem_lock.owner() == Scheduler::cur_task());
     assert2(what->len > (n + sizeof(struct HeapEntry)), "Trying to split a heap entry that's too small!");
     assert(n <= allocated);
 
@@ -200,6 +202,7 @@ void *kmalloc(size_t n) {
 }
 
 static void try_merge_fwd(struct HeapEntry *entry) {
+    assert(kmem_lock.test() && kmem_lock.owner() == Scheduler::cur_task());
     assert2(entry->magic == KERN_HeapMagicFree, "Bad merge!");
     assert(entry->prev == NULL);
 
@@ -230,6 +233,7 @@ static void try_merge_fwd(struct HeapEntry *entry) {
 }
 
 static struct HeapEntry *try_shrink_heap(struct HeapEntry *entry) {
+    assert(kmem_lock.test() && kmem_lock.owner() == Scheduler::cur_task());
     assert(entry->prev == NULL);
     if ((uint64_t) entry + sizeof(struct HeapEntry) + entry->len == KERN_HeapEnd) {
         // Shrink it if it's at least three pages

src/arch/x86/kmem.hpp

@@ -9,13 +9,13 @@ extern "C" {
 #include <stdint.h>
 
 #define KERN_HeapVirtBegin  (0xffffc00000000000ULL)
-#define KERN_HeapMagicFree  0xDEDE
-#define KERN_HeapMagicTaken 0xADAD
+#define KERN_HeapMagicFree  0xDEDEDEDEDEDEDEDE
+#define KERN_HeapMagicTaken 0xADADADADADADADAD
 
 void init_kern_heap();
 
 struct HeapEntry {
-    uint_fast16_t     magic;
+    uint64_t          magic;
     struct HeapEntry *next;
     struct HeapEntry *prev;
     uint64_t          len;

src/arch/x86/paging.cpp

@@ -3,6 +3,7 @@
 //
 
 #include "paging.hpp"
+#include "LockGuard.hpp"
 #include "asserts.hpp"
 #include "limine.h"
 #include "memman.hpp"
@@ -47,6 +48,7 @@ AddressSpace::~AddressSpace() {
 }
 
 void *AddressSpace::virt2real(void *virt) {
+    LockGuard l(_lock);
     assert2(((uint64_t) virt & 0xFFF) == 0, "Trying to unmap non-aligned memory!");
 
     // Assuming everything related to paging is HHDM
@@ -79,6 +81,7 @@ void *AddressSpace::virt2real(void *virt) {
 }
 
 int AddressSpace::map(void *virt, void *real, uint32_t flags) {
+    LockGuard l(_lock);
     assert2(((uint64_t) virt & 0xFFF) == 0, "Trying to map non-aligned memory!");
     assert2(((uint64_t) real & 0xFFF) == 0, "Trying to map to non-aligned memory!");
 
@@ -134,6 +137,7 @@ int AddressSpace::map(void *virt, void *real, uint32_t flags) {
     return 1;
 }
 int AddressSpace::unmap(void *virt) {
+    LockGuard l(_lock);
     assert2(((uint64_t) virt & 0xFFF) == 0, "Trying to map non-aligned memory!");
 
     // Assuming everything related to paging is HHDM
@@ -168,7 +172,7 @@ int AddressSpace::unmap(void *virt) {
 }
 FDT *AddressSpace::getFdt() {
     if (_fdt.get() == nullptr) {
-        LockGuard l(_fdtLock);
+        LockGuard l(_lock);
         if (_fdt.get() == nullptr) {
             _fdt = UniquePtr(new FDT());
         }

src/arch/x86/paging.hpp

@@ -52,9 +52,10 @@ private:
     uint64_t                             *PML4;
 
     UniquePtr<FDT>                        _fdt;
-    Mutex                                 _fdtLock;
 
     UniquePtr<cgistd::vector<uint64_t *>> _taken_pages;
+
+    Mutex                                 _lock;
 };
 
 extern AddressSpace *KERN_AddressSpace;