more stuff

core/mem/init.c

@@ -23,7 +23,7 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
 
     const size_t pgsz = arch_mem_page_size();
 
-    log("mem", "Memory map:\n");
+    log("mem: Memory map:\n");
     for (size_t i = 0; i < map_len; i++) {
         if (map[i].length == 0)
             continue;
@@ -44,7 +44,7 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
             break;
         }
 
-        log("mem", "[%p - %p] %s\n", (void*)map[i].address, (void*)(map[i].address + map[i].length - 1), label);
+        log("mem: [%p - %p] %s\n", (void*)map[i].address, (void*)(map[i].address + map[i].length - 1), label);
     }
 
     // Set up the bootstrap allocator.
@@ -54,8 +54,7 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
             largest = &map[i];
     }
     mem_phys_bootstrap(largest);
-    log("mem",
-        "Using region [%p - %p] for bootstrap allocator\n",
+    log("mem: Using region [%p - %p] for bootstrap allocator\n",
         (void*)largest->address,
         (void*)(largest->address + largest->length - 1));
 
@@ -67,7 +66,7 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
     assert(pmap_new_kernel(&kernel_vma.pmap, 0) == 0, "Unable to allocate the kernel page table\n");
 
     // text
-    log("mem", "Mapping text segment at %p\n", __ld_text_start);
+    log("mem: Mapping text segment at %p\n", __ld_text_start);
     for (uint8_t* p = __ld_text_start; p <= __ld_text_end; p += pgsz) {
         errno_t status = pmap_map(
             &kernel_vma.pmap,
@@ -80,7 +79,7 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
     }
 
     // rodata
-    log("mem", "Mapping rodata segment at %p\n", __ld_rodata_start);
+    log("mem: Mapping rodata segment at %p\n", __ld_rodata_start);
     for (uint8_t* p = __ld_rodata_start; p < __ld_rodata_end; p += pgsz) {
         errno_t status = pmap_map(
             &kernel_vma.pmap,
@@ -93,7 +92,7 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
     }
 
     // data
-    log("mem", "Mapping data segment at %p\n", __ld_data_start);
+    log("mem: Mapping data segment at %p\n", __ld_data_start);
     for (uint8_t* p = __ld_data_start; p < __ld_data_end; p += pgsz) {
         errno_t status = pmap_map(
             &kernel_vma.pmap,
@@ -161,5 +160,5 @@ void mem_init(struct phys_mem* map, size_t map_len, uintptr_t kernel_virt, phys_
 
     slab_init();
 
-    log("mem", "Memory initialization complete\n");
+    log("mem: Memory initialization complete\n");
 }

core/mem/pmap.c

@@ -15,7 +15,7 @@ errno_t pmap_new_kernel(struct pmap* pt, enum alloc_flags flags) {
 
     struct pmap result = {
         .root = addr,
-        .lock = (spinlock_t){0},
+        .lock = (struct spinlock){0},
         .is_user = false,
     };
 
@@ -35,7 +35,7 @@ errno_t pmap_new_user(struct pmap* pt, enum alloc_flags flags) {
 
     struct pmap result = {
         .root = user_l1,
-        .lock = (spinlock_t){0},
+        .lock = (struct spinlock){0},
         .is_user = true,
     };
 

core/mem/pmm.c

@@ -56,7 +56,7 @@ void mem_phys_bootstrap(struct phys_mem* mem) {
 }
 
 static struct page* pmm_head = nullptr;
-static spinlock_t pmm_lock = {0};
+static struct spinlock pmm_lock = {0};
 static size_t pmm_total_free = 0;
 
 static errno_t freelist_alloc(size_t num_pages, enum alloc_flags flags, phys_t* out) {
@@ -84,11 +84,10 @@ static errno_t freelist_alloc(size_t num_pages, enum alloc_flags flags, phys_t*
 
         // If the current block has exactly enough pages left, consume it entirely.
         if (__unlikely(it->freelist.count == num_pages)) {
-            if (prev_it) {
+            if (prev_it)
                 prev_it->freelist.next = it->freelist.next;
-            } else {
+            else
                 pmm_head = it->freelist.next;
-            }
 
             it->freelist.next = nullptr;
             it->freelist.count = 0;
@@ -150,5 +149,5 @@ void mem_phys_init(struct phys_mem* map, size_t length) {
     }
 
     const size_t free_bytes = (pmm_total_free * arch_mem_page_size());
-    log("pmm", "Total available memory: %zu MiB\n", free_bytes / 1024 / 1024);
+    log("pmm: Total available memory: %zu MiB\n", free_bytes / 1024 / 1024);
 }

core/mem/slab.c

@@ -10,8 +10,8 @@ typedef struct {
 } slab_info;
 
 struct slab {
-    spinlock_t lock; // Access lock.
-    size_t ent_size; // Size of one entry.
+    struct spinlock lock; // Access lock.
+    size_t ent_size;      // Size of one entry.
     void** head;
 };
 
@@ -24,7 +24,7 @@ typedef struct {
 static struct slab slabs[8] = {0};
 
 static errno_t slab_new(struct slab* slab, size_t size) {
-    slab->lock = (spinlock_t){0};
+    slab->lock = (struct spinlock){0};
 
     // Allocate a new page for the head.
     phys_t addr;

core/mem/virt.c

@@ -1,7 +1,7 @@
 #include <zinnia/alloc.h>
+#include <zinnia/atomic.h>
 #include <zinnia/utils.h>
 #include <zinnia/virt.h>
-#include <stdatomic.h>
 #include <stddef.h>
 
 struct page* vm_pfndb = nullptr;
@@ -12,8 +12,7 @@ static size_t mapping_offset = 0;
 
 uintptr_t vm_alloc(size_t length) {
     uintptr_t base = arch_mem_mapping_addr();
-    size_t offset =
-        atomic_fetch_add_explicit(&mapping_offset, ALIGN_UP(length, arch_mem_page_size()), memory_order_acquire);
+    size_t offset = atomic_fetch_add(&mapping_offset, ALIGN_UP(length, arch_mem_page_size()), ATOMIC_ACQUIRE);
 
     return base + offset;
 }