Resolve strange IRQ issues which cause the scheduler to behave weirdly (IRQ mapping)

include/m/resource_buffer.h

@@ -0,0 +1,19 @@
+#ifndef _M_RESOURCE_BUFFER_H
+#define _M_RESOURCE_BUFFER_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+struct resource_buffer_mem {
+  uintptr_t paddr;
+  size_t pages;
+};
+
+struct resource_buffer {
+  int type;
+  union {
+    struct resource_buffer_mem mem;
+  } u;
+};
+
+#endif // _M_RESOURCE_BUFFER_H

include/m/syscall_defs.h

@@ -5,14 +5,12 @@
 #define SYS_PROC_TEST                   2
 #define SYS_PROC_MAP                    3
 #define SYS_PROC_UNMAP                  4
-#define SYS_PROC_CREATE_RESOURCE_MEM    5
+#define SYS_PROC_CREATE_RESOURCE        5
 #define SYS_PROC_DROP_RESOURCE          6
-#define SYS_PROC_CREATE_RESOURCE_MUTEX  7
 #define SYS_PROC_MUTEX_LOCK             8
 #define SYS_PROC_MUTEX_UNLOCK           9
 #define SYS_PROC_SPAWN_THREAD           10
 #define SYS_PROC_SCHED                  11
 #define SYS_PROC_TRANSLATE_V2P          12
-#define SYS_PROC_MEM_UNREF              13
 
 #endif // _M_SYSCALL_DEFS_H

init/init.c

@@ -6,16 +6,25 @@
 #include <stdint.h>
 #include <string/string.h>
 
-char c = 'a';
+#define EXAMPLE 1
+
+#if EXAMPLE == 1
 int mutex_rid;
 
 void mythread (void) {
-  for (;;) {
+  for (int j = 0; j < 10; j++) {
-    proc_mutex_lock (mutex_rid);
+    proc_mutex_lock (mutex_rid, RV_PRIVATE);
+
     for (size_t i = 0; i < 3; i++)
       proc_test ('b');
-    proc_mutex_unlock (mutex_rid);
+
+    proc_mutex_unlock (mutex_rid, RV_PRIVATE);
+
+    for (volatile int i = 0; i < 200 * 1000 * 1000; i++)
+      ;
   }
+
+  proc_quit ();
 }
 
 int make_thread (void (*fn) (void)) {
@@ -29,14 +38,23 @@ int make_thread (void (*fn) (void)) {
 }
 
 void app_main (void) {
-  mutex_rid = proc_create_resource_mutex (200, RV_PRIVATE);
+  mutex_rid = proc_create_resource (200, PR_MUTEX, RV_PRIVATE, NULL);
 
   make_thread (&mythread);
 
-  for (;;) {
+  for (int j = 0; j < 10; j++) {
-    proc_mutex_lock (mutex_rid);
+    proc_mutex_lock (mutex_rid, RV_PRIVATE);
+
     for (size_t i = 0; i < 3; i++)
       proc_test ('a');
-    proc_mutex_unlock (mutex_rid);
+
+    proc_mutex_unlock (mutex_rid, RV_PRIVATE);
+
+    for (volatile int i = 0; i < 400 * 1000 * 1000; i++)
+      ;
   }
+
+  for (;;)
+    ;
 }
+#endif

kernel/amd64/apic.c

@@ -77,7 +77,7 @@ static void amd64_ioapic_write (struct ioapic* ioapic, uint32_t reg, uint32_t va
 }
 
 /* Find an IOAPIC corresposting to provided IRQ */
-static struct ioapic* amd64_ioapic_find (uint8_t irq) {
+static struct ioapic* amd64_ioapic_find (uint32_t irq) {
   struct ioapic* ioapic = NULL;
 
   for (size_t i = 0; i < ioapic_entries; i++) {
@@ -103,7 +103,7 @@ static struct ioapic* amd64_ioapic_find (uint8_t irq) {
  * flags - IOAPIC redirection flags.
  * lapic_id - Local APIC that will receive the interrupt.
  */
-void amd64_ioapic_route_irq (uint8_t vec, uint8_t irq, uint64_t flags, uint64_t lapic_id) {
+void amd64_ioapic_route_irq (uint32_t vec, uint32_t irq, uint64_t flags, uint64_t lapic_id) {
   struct ioapic* ioapic = NULL;
   struct acpi_madt_interrupt_source_override* override;
   bool found_override = false;
@@ -119,13 +119,13 @@ void amd64_ioapic_route_irq (uint8_t vec, uint8_t irq, uint64_t flags, uint64_t
   uint64_t calc_flags = (lapic_id << 56) | (flags) | (vec & 0xFF);
 
   if (found_override) {
-    uint8_t polarity = ((override->flags & 0x03) == 0x03) ? 1 : 0;
+    uint32_t polarity = ((override->flags & 0x03) == 0x03) ? 1 : 0;
-    uint8_t mode = (((override->flags >> 2) & 0x03) == 0x03) ? 1 : 0;
+    uint32_t mode = (((override->flags >> 2) & 0x03) == 0x03) ? 1 : 0;
     calc_flags |= (uint64_t)mode << 15;
     calc_flags |= (uint64_t)polarity << 13;
   }
 
-  uint8_t gsi = found_override ? override->gsi : irq;
+  uint32_t gsi = found_override ? override->gsi : irq;
 
   ioapic = amd64_ioapic_find (gsi);
 
@@ -263,7 +263,7 @@ void amd64_lapic_init (uint32_t us) {
  * lapic_id - Target Local APIC
  * vec - Interrupt vector/IDT stub, which will be invoked by the IPI.
  */
-void amd64_lapic_ipi (uint8_t lapic_id, uint8_t vec) {
+void amd64_lapic_ipi (uint32_t lapic_id, uint32_t vec) {
   /* wait for previous IPI to finish */
   while (amd64_lapic_read (LAPIC_ICR) & (1 << 12)) {
     __asm__ volatile ("pause");

kernel/amd64/apic.h

@@ -3,12 +3,12 @@
 
 #include <libk/std.h>
 
-void amd64_ioapic_route_irq (uint8_t vec, uint8_t irq, uint64_t flags, uint64_t lapic_id);
+void amd64_ioapic_route_irq (uint32_t vec, uint32_t irq, uint64_t flags, uint64_t lapic_id);
 void amd64_ioapic_init (void);
 
 uint32_t amd64_lapic_id (void);
 void amd64_lapic_eoi (void);
-void amd64_lapic_ipi (uint8_t lapic_id, uint8_t vec);
+void amd64_lapic_ipi (uint32_t lapic_id, uint32_t vec);
 void amd64_lapic_init (uint32_t us);
 
 #endif // _KERNEL_AMD64_APIC_H

kernel/amd64/intr.c

@@ -216,12 +216,12 @@ void irq_save (spin_lock_ctx_t* ctx) { *ctx = amd64_irq_save_flags (); }
 void irq_restore (spin_lock_ctx_t* ctx) { amd64_irq_restore_flags (*ctx); }
 
 /* Map custom IRQ mappings to legacy IRQs */
-uint8_t amd64_resolve_irq (uint8_t irq) {
+uint32_t amd64_resolve_irq (uint32_t irq) {
-  static const uint8_t mappings[] = {
+  static const uint32_t mappings[] = {
       [SCHED_PREEMPT_TIMER] = 0,
-      [TLB_SHOOTDOWN] = 1,
+      [TLB_SHOOTDOWN] = 6,
-      [CPU_REQUEST_SCHED] = 2,
+      [CPU_REQUEST_SCHED] = 3,
-      [CPU_SPURIOUS] = 3,
+      [CPU_SPURIOUS] = 5,
   };
 
   return mappings[irq];

kernel/amd64/intr.h

@@ -32,7 +32,7 @@ struct saved_regs {
 } PACKED;
 
 void amd64_load_idt (void);
-uint8_t amd64_resolve_irq (uint8_t irq);
+uint32_t amd64_resolve_irq (uint32_t irq);
 void amd64_intr_init (void);
 
 #endif // _KERNEL_AMD64_INTR_H

kernel/amd64/mm.c

@@ -43,6 +43,8 @@ void amd64_load_kernel_cr3 (void) {
   }
 }
 
+struct pd* mm_get_kernel_pd (void) { return &kernel_pd; }
+
 /* Extract PML info from virtual address */
 static struct pg_index amd64_mm_page_index (uint64_t vaddr) {
   struct pg_index ret;

kernel/amd64/proc.c

@@ -1,4 +1,5 @@
 #include <amd64/gdt.h>
+#include <amd64/proc.h>
 #include <aux/elf.h>
 #include <libk/list.h>
 #include <libk/rbtree.h>
@@ -9,13 +10,16 @@
 #include <mm/pmm.h>
 #include <proc/proc.h>
 #include <proc/resource.h>
+#include <sync/rw_spin_lock.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 
+/* 0 is kpproc */
 static atomic_int pids = 1;
 
 struct proc* proc_from_elf (uint8_t* elf_contents) {
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  int rid;
 
   struct proc* proc = malloc (sizeof (*proc));
   if (proc == NULL)
@@ -27,51 +31,59 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
   atomic_store (&proc->state, PROC_READY);
   proc->pid = atomic_fetch_add (&pids, 1);
 
+  proc->resources = malloc (sizeof (*proc->resources));
+  if (proc->resources == NULL) {
+    free (proc);
+    return NULL;
+  }
+  proc->resources->tree = NULL;
+  proc->resources->lock = RW_SPIN_LOCK_INIT;
+  proc->resources->refs = 1;
+  proc->resources->sys_rids = 0;
+
   proc->pd = malloc (sizeof (*proc->pd));
   if (proc->pd == NULL) {
+    free (proc->resources);
     free (proc);
     return NULL;
   }
 
-  proc->sys_rids = malloc (sizeof (*proc->sys_rids));
-  if (proc->sys_rids == NULL) {
-    free (proc);
-    return NULL;
-  }
-  proc->sys_rids->counter = 0;
-  proc->sys_rids->refs = 1;
-
   proc->pd->lock = SPIN_LOCK_INIT;
   proc->pd->refs = 1;
   proc->pd->cr3_paddr = mm_alloc_user_pd_phys ();
   if (proc->pd->cr3_paddr == 0) {
     free (proc->pd);
+    free (proc->resources);
     free (proc);
     return NULL;
   }
 
-  int kstk_rid = atomic_fetch_add (&proc->sys_rids->counter, 1);
+  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE,
-  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE};
+                                                 .managed = false};
+  rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
   struct proc_resource* kstk_r =
-      proc_create_resource (proc, kstk_rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
+      proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
   if (kstk_r == NULL) {
     pmm_free (proc->pd->cr3_paddr, 1);
     free (proc->pd);
+    free (proc->resources);
     free (proc);
     return NULL;
   }
 
   proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
 
-  int ustk_rid = atomic_fetch_add (&proc->sys_rids->counter, 1);
+  struct proc_resource_mem_init ustk_mem_init = {.pages = USTACK_SIZE / PAGE_SIZE,
-  struct proc_resource_mem_init ustk_mem_init = {.pages = USTACK_SIZE / PAGE_SIZE};
+                                                 .managed = false};
+  rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
   struct proc_resource* ustk_r =
-      proc_create_resource (proc, ustk_rid, PR_MEM, RV_PRIVATE, (void*)&ustk_mem_init);
+      proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&ustk_mem_init);
   if (ustk_r == NULL) {
     kstk_r->ops.cleanup (proc, kstk_r);
     free (kstk_r);
     pmm_free (proc->pd->cr3_paddr, 1);
     free (proc->pd);
+    free (proc->resources);
     free (proc);
     return NULL;
   }
@@ -97,7 +109,8 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
 struct proc* proc_spawn_thread (struct proc* proto, uintptr_t vstack_top, size_t stack_size,
                                 uintptr_t entry) {
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
-  spin_lock_ctx_t ctxprt;
+  spin_lock_ctx_t ctxprt, ctxrs;
+  int rid;
 
   struct proc* proc = malloc (sizeof (*proc));
   if (proc == NULL)
@@ -115,9 +128,26 @@ struct proc* proc_spawn_thread (struct proc* proto, uintptr_t vstack_top, size_t
   proc->mappings = proto->mappings;
   atomic_fetch_add (&proto->pd->refs, 1);
 
-  proc->resource_tree = proto->resource_tree;
+  proc->resources = proto->resources;
-  proc->sys_rids = proto->sys_rids;
+
-  atomic_fetch_add (&proc->sys_rids->refs, 1);
+  rw_spin_write_lock (&proc->resources->lock, &ctxrs);
+
+  atomic_fetch_add (&proc->resources->refs, 1);
+
+  struct rb_node_link* rnode;
+  rbtree_first (&proc->resources->tree, rnode);
+  while (rnode) {
+    struct rb_node_link* next;
+    rbtree_next (rnode, next);
+
+    struct proc_resource* resource =
+        rbtree_entry (rnode, struct proc_resource, local_resource_tree_link);
+    atomic_fetch_add (&resource->refs, 1);
+
+    rnode = next;
+  }
+
+  rw_spin_write_unlock (&proc->resources->lock, &ctxrs);
 
   spin_unlock (&proto->lock, &ctxprt);
 
@@ -129,10 +159,11 @@ struct proc* proc_spawn_thread (struct proc* proto, uintptr_t vstack_top, size_t
     return NULL;
   }
 
-  int kstk_rid = atomic_fetch_add (&proc->sys_rids->counter, 1);
+  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE,
-  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE};
+                                                 .managed = false};
+  rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
   struct proc_resource* kstk_r =
-      proc_create_resource (proc, kstk_rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
+      proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
   if (kstk_r == NULL) {
     free (proc);
     return NULL;

kernel/irq/irq.c

@@ -3,6 +3,7 @@
 #include <libk/std.h>
 #include <mm/liballoc.h>
 #include <sync/rw_spin_lock.h>
+#include <sys/debug.h>
 
 #if defined(__x86_64__)
 #include <amd64/apic.h>

kernel/libk/assert.h

@@ -8,6 +8,7 @@
     if (!(x)) {                                                                                    \
       DEBUG ("%s ssertion failed\n", #x);                                                          \
       spin ();                                                                                     \
+      __builtin_unreachable ();                                                                    \
     }                                                                                              \
   } while (0)
 

kernel/limine/requests.c

@@ -20,3 +20,4 @@ DECL_REQ (memmap, MEMMAP);
 DECL_REQ (rsdp, RSDP);
 DECL_REQ (mp, MP);
 DECL_REQ (module, MODULE);
+DECL_REQ (framebuffer, FRAMEBUFFER);

kernel/limine/requests.h

@@ -10,5 +10,6 @@ EXTERN_REQ (memmap);
 EXTERN_REQ (rsdp);
 EXTERN_REQ (mp);
 EXTERN_REQ (module);
+EXTERN_REQ (framebuffer);
 
 #endif // _KERNEL_LIMINE_REQUESTS_H

kernel/proc/kpproc_fb.h

@@ -0,0 +1,20 @@
+#ifndef _KERNEL_PROC_KPPROC_FB_H
+#define _KERNEL_PROC_KPPROC_FB_H
+
+#include <aux/compiler.h>
+#include <libk/std.h>
+
+/* data to expose as a kpproc resource */
+struct kpproc_fb {
+  uintptr_t paddr;
+  uint64_t w, h, pitch;
+  uint16_t bpp;
+  uint8_t red_mask_size;
+  uint8_t red_mask_shift;
+  uint8_t green_mask_size;
+  uint8_t green_mask_shift;
+  uint8_t blue_mask_size;
+  uint8_t blue_mask_shift;
+};
+
+#endif // _KERNEL_PROC_KPPROC_FB_H

kernel/proc/mem.c

@@ -9,11 +9,17 @@ bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resour
   if (init->pages == 0)
     return false;
 
+  if (init->managed) {
+    mem->paddr = init->paddr;
+    mem->managed = true;
+  } else {
     uintptr_t paddr = pmm_alloc (init->pages);
     if (paddr == PMM_ALLOC_ERR)
       return false;
-
     mem->paddr = paddr;
+    mem->managed = false;
+  }
+
   mem->pages = mem->alive_pages = init->pages;
 
   return true;
@@ -21,17 +27,7 @@ bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resour
 
 void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource) {
   (void)proc;
+
+  if (!resource->u.mem.managed)
     pmm_free (resource->u.mem.paddr, resource->u.mem.pages);
 }
-
-void proc_mem_unref (struct proc* proc, struct proc_resource_mem* mem, size_t pages) {
-  spin_lock_ctx_t ctxrs;
-
-  spin_lock (&mem->resource->lock, &ctxrs);
-  mem->alive_pages -= pages;
-  ptrdiff_t current_pages = mem->alive_pages;
-  spin_unlock (&mem->resource->lock, &ctxrs);
-
-  if (current_pages <= 0)
-    proc_drop_resource (proc, mem->resource);
-}

kernel/proc/mem.h

@@ -12,14 +12,16 @@ struct proc_resource_mem {
   uintptr_t paddr;
   size_t pages;
   ptrdiff_t alive_pages;
+  bool managed;
 };
 
 struct proc_resource_mem_init {
+  uintptr_t paddr;
   size_t pages;
+  bool managed;
 };
 
 bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resource_mem_init* init);
 void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource);
-void proc_mem_unref (struct proc* proc, struct proc_resource_mem* mem, size_t pages);
 
 #endif // _KERNEL_PROC_MEM_H

kernel/proc/mutex.c

@@ -51,26 +51,27 @@ bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
 
   spin_lock (&mutex->suspension_q.lock, &ctxsq);
 
-  struct proc* resumed_proc;
+  struct proc* resumed_proc = NULL;
   struct rb_node_link* node;
   rbtree_first (&mutex->suspension_q.proc_tree, node);
 
   if (node) {
     resumed_proc = rbtree_entry (node, struct proc, suspension_link);
     mutex->owner = resumed_proc;
+    mutex->locked = true;
 
     spin_unlock (&mutex->suspension_q.lock, &ctxsq);
     spin_unlock (&mutex->resource->lock, &ctxmt);
+
     proc_resume (resumed_proc);
 
     return true;
   }
 
-  spin_unlock (&mutex->suspension_q.lock, &ctxsq);
-
   mutex->locked = false;
   mutex->owner = NULL;
 
+  spin_unlock (&mutex->suspension_q.lock, &ctxsq);
   spin_unlock (&mutex->resource->lock, &ctxmt);
 
   return true;

kernel/proc/proc.c

@@ -9,6 +9,7 @@
 #include <limine/requests.h>
 #include <mm/liballoc.h>
 #include <mm/pmm.h>
+#include <proc/kpproc_fb.h>
 #include <proc/proc.h>
 #include <proc/resource.h>
 #include <rd/rd.h>
@@ -25,7 +26,7 @@
 #include <amd64/intr_defs.h>
 #endif
 
-#define SCHED_REAP_FREQ 200
+#define SCHED_REAP_FREQ 10
 
 /*
  * Lock hierachy:
@@ -40,6 +41,9 @@ static rw_spin_lock_t proc_tree_lock = RW_SPIN_LOCK_INIT;
 
 static atomic_int sched_cycles = 0;
 
+/* kernel pseudo process */
+static struct proc kpproc;
+
 static bool proc_check_elf (uint8_t* elf) {
   if (!((elf[0] == 0x7F) && (elf[1] == 'E') && (elf[2] == 'L') && (elf[3] == 'F')))
     return false;
@@ -144,7 +148,6 @@ struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf) {
   aux.phent = ehdr->e_phentsize;
 
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
-  int rid_counter = 10;
 
   for (uint64_t segment = 0; segment < ehdr->e_phnum; segment++) {
     Elf64_Phdr* phdr =
@@ -161,8 +164,9 @@ struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf) {
       size_t blks = div_align_up (phdr->p_memsz + off, PAGE_SIZE);
 
       struct proc_resource_mem_init mem_init = {.pages = blks};
+      int rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
       struct proc_resource* r =
-          proc_create_resource (proc, rid_counter++, PR_MEM, RV_PRIVATE, (void*)&mem_init);
+          proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&mem_init);
       if (r == NULL) {
         DEBUG ("pmm oom error while loading ELF segments! (tried to alloc %zu blks)\n", blks);
       }
@@ -197,6 +201,17 @@ static struct proc* proc_spawn_rd (char* name) {
   return proc_from_elf (rd_file->content);
 }
 
+struct proc* proc_find_pid (int pid) {
+  spin_lock_ctx_t ctxprtr;
+  struct proc* proc = NULL;
+
+  rw_spin_read_lock (&proc_tree_lock, &ctxprtr);
+  rbtree_find (struct proc, &proc_tree, pid, proc, proc_tree_link, pid);
+  rw_spin_read_unlock (&proc_tree_lock, &ctxprtr);
+
+  return proc;
+}
+
 void proc_register (struct proc* proc, struct cpu* cpu) {
   spin_lock_ctx_t ctxcpu, ctxprtr;
 
@@ -340,9 +355,6 @@ void proc_kill (struct proc* proc, void* regs) {
 
   DEBUG ("killed PID %d\n", proc->pid);
 
-  if (cpu == thiscpu)
-    proc_sched (regs);
-  else
   cpu_request_sched (cpu);
 }
 
@@ -393,23 +405,71 @@ void proc_resume (struct proc* proc) {
 
 static void proc_irq_sched (void* arg, void* regs) {
   (void)arg;
-
-#if defined(__x86_64__)
-  struct saved_regs* s_regs = regs;
-  /* Only schedule, when we came from usermode */
-  if ((s_regs->cs & 0x03))
   proc_sched (regs);
-#endif
+}
+
+static void proc_kpproc_init (void) {
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+
+  memset (&kpproc, 0, sizeof (kpproc));
+
+  kpproc.lock = SPIN_LOCK_INIT;
+  kpproc.state = PROC_PSEUDO;
+  kpproc.pid = 0;
+
+  kpproc.resources = malloc (sizeof (*kpproc.resources));
+  kpproc.resources->tree = NULL;
+  kpproc.resources->lock = RW_SPIN_LOCK_INIT;
+  kpproc.resources->refs = 1;
+  kpproc.resources->sys_rids = 0;
+
+  kpproc.pd = mm_get_kernel_pd ();
+  kpproc.cpu = thiscpu;
+
+  rbtree_insert (struct proc, &proc_tree, &kpproc.proc_tree_link, proc_tree_link, pid);
+
+  /* prepare kernel resources */
+  {
+    /* frame buffer */
+
+    struct limine_framebuffer_response* fb = limine_framebuffer_request.response;
+    struct kpproc_fb fb_info = {
+        .paddr = (uintptr_t)fb->framebuffers[0]->address - (uintptr_t)hhdm->offset,
+        .w = fb->framebuffers[0]->width,
+        .h = fb->framebuffers[0]->height,
+        .pitch = fb->framebuffers[0]->pitch,
+        .bpp = fb->framebuffers[0]->bpp,
+        .red_mask_size = fb->framebuffers[0]->red_mask_size,
+        .red_mask_shift = fb->framebuffers[0]->red_mask_shift,
+        .green_mask_size = fb->framebuffers[0]->green_mask_size,
+        .green_mask_shift = fb->framebuffers[0]->green_mask_shift,
+        .blue_mask_size = fb->framebuffers[0]->blue_mask_size,
+        .blue_mask_shift = fb->framebuffers[0]->blue_mask_shift,
+    };
+
+    DEBUG ("Framebuffer address %p\n", fb_info.paddr);
+
+    size_t pages = align_up (sizeof (fb_info), PAGE_SIZE) / PAGE_SIZE;
+    uintptr_t fb_info_memblk_paddr = pmm_alloc (pages);
+    memcpy ((struct kpproc_fb*)((uintptr_t)hhdm->offset + fb_info_memblk_paddr), &fb_info,
+            sizeof (fb_info));
+
+    struct proc_resource_mem_init mem_init = {
+        .pages = pages, .paddr = fb_info_memblk_paddr, .managed = true};
+    proc_create_resource (&kpproc, 0, PR_MEM, RV_PUBLIC, &mem_init);
+  }
 }
 
 void proc_init (void) {
+#if defined(__x86_64__)
+  irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER, IRQ_INTERRUPT_SAFE);
+  irq_attach (&proc_irq_sched, NULL, CPU_REQUEST_SCHED, IRQ_INTERRUPT_SAFE);
+#endif
+
+  proc_kpproc_init ();
+
   struct proc* init = proc_spawn_rd ("init.exe");
   proc_register (init, thiscpu);
 
-#if defined(__x86_64__)
-  irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER, IRQ_INTERRUPT_UNSAFE);
-  irq_attach (&proc_irq_sched, NULL, CPU_REQUEST_SCHED, IRQ_INTERRUPT_UNSAFE);
-#endif
-
   do_sched (init);
 }

kernel/proc/proc.h

@@ -8,6 +8,7 @@
 #include <libk/std.h>
 #include <proc/resource.h>
 #include <proc/suspension_q.h>
+#include <sync/rw_spin_lock.h>
 #include <sync/spin_lock.h>
 #include <sys/mm.h>
 
@@ -16,14 +17,11 @@
 #include <amd64/proc.h> /* USTACK_SIZE */
 #endif
 
-/* Process is ready to run */
+/* process states */
 #define PROC_READY     0
-/* Process marked garbage collection */
 #define PROC_DEAD      1
-/* Process is suspended */
 #define PROC_SUSPENDED 2
-
+#define PROC_PSEUDO    3
-#define PROC_RESOURCES_MAX 1024
 
 #define PROC_USTK_PREALLOC (1 << 0)
 
@@ -37,9 +35,11 @@ struct proc_mapping {
   size_t size;
 };
 
-struct proc_sys_rids {
+struct proc_resources {
   atomic_int refs;
-  atomic_int counter;
+  atomic_int sys_rids;
+  struct rb_node_link* tree;
+  rw_spin_lock_t lock;
 };
 
 struct proc {
@@ -56,9 +56,8 @@ struct proc {
   spin_lock_t lock;
   struct cpu* cpu;
   atomic_int state;
-  struct rb_node_link* resource_tree;
-  struct proc_sys_rids* sys_rids;
   struct proc_suspension_q* suspension_q;
+  struct proc_resources* resources;
 };
 
 void proc_suspend (struct proc* proc, struct proc_suspension_q* sq);
@@ -70,6 +69,7 @@ bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr,
 bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages);
 struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf);
 void proc_register (struct proc* proc, struct cpu* cpu);
+struct proc* proc_find_pid (int pid);
 void proc_init (void);
 
 #endif // _KERNEL_PROC_PROC_H

kernel/proc/resource.c

@@ -1,4 +1,5 @@
 #include <libk/assert.h>
+#include <libk/list.h>
 #include <libk/rbtree.h>
 #include <libk/std.h>
 #include <libk/string.h>
@@ -10,48 +11,112 @@
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 
+static struct rb_node_link* resource_tree = NULL;
+static rw_spin_lock_t resource_tree_lock = RW_SPIN_LOCK_INIT;
+
 void proc_cleanup_resources (struct proc* proc) {
-  struct proc_resource* resource = NULL;
+  spin_lock_ctx_t ctxrs;
+
+  rw_spin_write_lock (&proc->resources->lock, &ctxrs);
 
   struct rb_node_link* rnode;
-  rbtree_first (&proc->resource_tree, rnode);
+  rbtree_first (&proc->resources->tree, rnode);
-
   while (rnode) {
     struct rb_node_link* next;
     rbtree_next (rnode, next);
-    resource = rbtree_entry (rnode, struct proc_resource, proc_resource_tree_link);
+
-    proc_drop_resource (proc, resource);
+    struct proc_resource* resource =
+        rbtree_entry (rnode, struct proc_resource, local_resource_tree_link);
+
     rnode = next;
+
+    proc_drop_resource (proc, resource, false);
   }
 
-  assert (proc->resource_tree == NULL);
+  rw_spin_write_unlock (&proc->resources->lock, &ctxrs);
+
+  if (atomic_fetch_sub (&proc->resources->refs, 1) == 1) {
+    free (proc->resources);
+  }
 }
 
-void proc_drop_resource (struct proc* proc, struct proc_resource* resource) {
+void proc_drop_resource (struct proc* proc, struct proc_resource* resource, bool lock) {
-  spin_lock_ctx_t ctxpr;
+  spin_lock_ctx_t ctxrs;
 
-  DEBUG ("resource=%p, type=%d, rid=%d\n", resource, resource->type, resource->rid);
+  DEBUG ("resource=%p created_by=%d vis=%d type=%d rid=%d refs=%d\n", resource,
+         resource->created_by_pid, resource->visibility, resource->type, resource->rid,
+         atomic_load (&resource->refs));
 
   if (atomic_fetch_sub (&resource->refs, 1) == 1) {
-    spin_lock (&proc->lock, &ctxpr);
+    switch (resource->visibility) {
-    rbtree_delete (&proc->resource_tree, &resource->proc_resource_tree_link);
+    case RV_PRIVATE: {
-    spin_unlock (&proc->lock, &ctxpr);
+      if (lock)
+        rw_spin_write_lock (&proc->resources->lock, &ctxrs);
+
+      rbtree_delete (&proc->resources->tree, &resource->local_resource_tree_link);
+
+      if (lock)
+        rw_spin_write_unlock (&proc->resources->lock, &ctxrs);
+    } break;
+    case RV_PUBLIC: {
+      if (lock)
+        rw_spin_write_lock (&resource_tree_lock, &ctxrs);
+
+      rbtree_delete (&resource_tree, &resource->global_resource_tree_link);
+
+      if (lock)
+        rw_spin_write_unlock (&resource_tree_lock, &ctxrs);
+    } break;
+    default: {
+      assert (0);
+    } break;
+    }
 
     resource->ops.cleanup (proc, resource);
     free (resource);
   }
 }
 
+struct proc_resource* proc_find_resource (struct proc* proc, int rid, int vis) {
+  struct proc_resource* resource = NULL;
+  spin_lock_ctx_t ctxrs;
+
+  switch (vis) {
+  case RV_PRIVATE: {
+    /* User wants to create a private resource, so search locally */
+    rw_spin_read_lock (&proc->resources->lock, &ctxrs);
+    rbtree_find (struct proc_resource, &proc->resources->tree, rid, resource,
+                 local_resource_tree_link, rid);
+    rw_spin_read_unlock (&proc->resources->lock, &ctxrs);
+  } break;
+  case RV_PUBLIC: {
+    /* User wants to create a public resource, so search globally */
+    rw_spin_read_lock (&resource_tree_lock, &ctxrs);
+    rbtree_find (struct proc_resource, &resource_tree, rid, resource, global_resource_tree_link,
+                 rid);
+    rw_spin_read_unlock (&resource_tree_lock, &ctxrs);
+  } break;
+  default: {
+    assert (0);
+  } break;
+  }
+
+  return resource;
+}
+
 struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type, int vis,
                                             void* data) {
-  spin_lock_ctx_t ctxpr;
+  spin_lock_ctx_t ctxrs;
+
   /* Check if resource RID already exists */
-  struct proc_resource* resource_check;
+  struct proc_resource* resource_check = proc_find_resource (proc, rid, vis);
-  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource_check,
+
-               proc_resource_tree_link, rid);
+  /* Resource was found either way, so it already exists */
   if (resource_check != NULL)
     return NULL;
 
+  /* create the resource */
+
   struct proc_resource* resource = malloc (sizeof (*resource));
   if (resource == NULL)
     return NULL;
@@ -63,6 +128,7 @@ struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type
   resource->refs = 1;
   resource->rid = rid;
   resource->visibility = vis;
+  resource->created_by_pid = proc->pid;
 
   switch (resource->type) {
   case PR_MEM: {
@@ -70,14 +136,16 @@ struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type
     proc_create_resource_mem (&resource->u.mem, mem_init);
     resource->ops.cleanup = &proc_cleanup_resource_mem;
     resource->u.mem.resource = resource;
-    DEBUG ("PR_MEM resource=%p type=%d rid=%d paddr=%p, pages=%zu\n", resource, resource->type,
+    DEBUG ("PR_MEM resource=%p created_by=%d, type=%d rid=%d paddr=%p, pages=%zu\n", resource,
-           resource->rid, resource->u.mem.paddr, resource->u.mem.pages);
+           resource->created_by_pid, resource->type, resource->rid, resource->u.mem.paddr,
+           resource->u.mem.pages);
   } break;
   case PR_MUTEX: {
     proc_create_resource_mutex (&resource->u.mutex);
     resource->ops.cleanup = &proc_cleanup_resource_mutex;
     resource->u.mutex.resource = resource;
-    DEBUG ("PR_MUTEX resource=%p, type=%d rid=%d\n", resource, resource->type, resource->rid);
+    DEBUG ("PR_MUTEX resource=%p created_by=%d type=%d rid=%d\n", resource,
+           resource->created_by_pid, resource->type, resource->rid);
   } break;
   default: {
     free (resource);
@@ -85,10 +153,23 @@ struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type
   } break;
   }
 
-  spin_lock (&proc->lock, &ctxpr);
+  switch (resource->visibility) {
-  rbtree_insert (struct proc_resource, &proc->resource_tree, &resource->proc_resource_tree_link,
+  case RV_PRIVATE: {
-                 proc_resource_tree_link, rid);
+    rw_spin_write_lock (&proc->resources->lock, &ctxrs);
-  spin_unlock (&proc->lock, &ctxpr);
+    rbtree_insert (struct proc_resource, &proc->resources->tree,
+                   &resource->local_resource_tree_link, local_resource_tree_link, rid);
+    rw_spin_write_unlock (&proc->resources->lock, &ctxrs);
+  } break;
+  case RV_PUBLIC: {
+    rw_spin_write_lock (&resource_tree_lock, &ctxrs);
+    rbtree_insert (struct proc_resource, &resource_tree, &resource->global_resource_tree_link,
+                   global_resource_tree_link, rid);
+    rw_spin_write_unlock (&resource_tree_lock, &ctxrs);
+  } break;
+  default: {
+    assert (0);
+  } break;
+  }
 
   return resource;
 }

kernel/proc/resource.h

@@ -1,6 +1,7 @@
 #ifndef _KERNEL_PROC_RESOURCE_H
 #define _KERNEL_PROC_RESOURCE_H
 
+#include <libk/list.h>
 #include <libk/rbtree.h>
 #include <libk/std.h>
 #include <proc/mem.h>
@@ -14,7 +15,6 @@
 #define RV_PUBLIC  1
 
 struct proc;
-struct proc_resource;
 
 struct proc_resource {
   int type;
@@ -22,7 +22,8 @@ struct proc_resource {
   int visibility;
   spin_lock_t lock;
   atomic_int refs;
-  struct rb_node_link proc_resource_tree_link;
+  struct rb_node_link global_resource_tree_link;
+  struct rb_node_link local_resource_tree_link;
   union {
     struct proc_resource_mem mem;
     struct proc_mutex mutex;
@@ -30,11 +31,13 @@ struct proc_resource {
   struct {
     void (*cleanup) (struct proc* proc, struct proc_resource* resource);
   } ops;
+  int created_by_pid;
 };
 
 struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type, int vis,
                                             void* data);
-void proc_drop_resource (struct proc* proc, struct proc_resource* resource);
+struct proc_resource* proc_find_resource (struct proc* proc, int rid, int vis);
+void proc_drop_resource (struct proc* proc, struct proc_resource* resource, bool lock);
 void proc_cleanup_resources (struct proc* proc);
 
 #endif // _KERNEL_PROC_RESOURCE_H

kernel/sys/mm.h

@@ -25,6 +25,7 @@ bool mm_validate (struct pd* pd, uintptr_t vaddr, uint32_t flags);
 bool mm_validate_buffer (struct pd* pd, uintptr_t vaddr, size_t size, uint32_t flags);
 uintptr_t mm_p2v (struct pd* pd, uintptr_t paddr, uint32_t flags);
 uintptr_t mm_v2p (struct pd* pd, uintptr_t vaddr, uint32_t flags);
+struct pd* mm_get_kernel_pd (void);
 void mm_init (void);
 
 #endif // _KERNEL_SYS_MM_H

kernel/syscall/syscall.c

@@ -1,6 +1,8 @@
 #include <aux/compiler.h>
+#include <libk/assert.h>
 #include <libk/std.h>
 #include <limine/requests.h>
+#include <m/resource_buffer.h>
 #include <m/status.h>
 #include <m/syscall_defs.h>
 #include <mm/pmm.h>
@@ -15,9 +17,29 @@
 #include <syscall/syscall.h>
 
 #define DEFINE_SYSCALL(name)                                                                       \
-  int name (struct proc* proc, void* UNUSED regs, uintptr_t UNUSED a1, uintptr_t UNUSED a2,        \
+  int name (struct proc* UNUSED proc, void* UNUSED regs, uintptr_t UNUSED a1, uintptr_t UNUSED a2, \
             uintptr_t UNUSED a3, uintptr_t UNUSED a4, uintptr_t UNUSED a5, uintptr_t UNUSED a6)
 
+static void* sys_get_user_buffer (struct proc* proc, uintptr_t uvaddr, size_t size) {
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  spin_lock_ctx_t ctxprpd;
+
+  spin_lock (&proc->pd->lock, &ctxprpd);
+
+  if (!mm_validate_buffer (proc->pd, (uintptr_t)uvaddr, size, 0)) {
+    spin_unlock (&proc->pd->lock, &ctxprpd);
+    return NULL;
+  }
+
+  uintptr_t out_paddr = mm_v2p (proc->pd, uvaddr, 0);
+
+  spin_unlock (&proc->pd->lock, &ctxprpd);
+
+  uintptr_t out_kvaddr = (uintptr_t)hhdm->offset + out_paddr;
+
+  return (void*)out_kvaddr;
+}
+
 /* int proc_quit (void) */
 DEFINE_SYSCALL (sys_proc_quit) {
   proc_kill (proc, regs);
@@ -60,68 +82,83 @@ DEFINE_SYSCALL (sys_proc_unmap) {
   return ok ? ST_OK : -ST_OOM_ERROR;
 }
 
-/* int proc_create_resource_mem (int rid, size_t pages, int vis, uintptr_t* out_paddr) */
+/* int proc_create_resource (int rid, int type, int vis, void* buffer) */
-DEFINE_SYSCALL (sys_proc_create_resource_mem) {
+DEFINE_SYSCALL (sys_proc_create_resource) {
-  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
-  spin_lock_ctx_t ctxprpd;
-
   int rid = (int)a1;
-  size_t pages = (size_t)a2;
+  int type = (int)a2;
   int vis = (int)a3;
-  uintptr_t* out_paddr_buf = (uintptr_t*)a4;
+  uintptr_t buffer_ptr = a4;
 
   if (rid < 0)
     return -ST_BAD_RESOURCE;
 
-  spin_lock (&proc->pd->lock, &ctxprpd);
+  if (!(type == PR_MEM || type == PR_MUTEX))
+    return -ST_BAD_RESOURCE;
 
-  uintptr_t out_paddr_buf_paddr = mm_v2p (proc->pd, (uintptr_t)out_paddr_buf, 0);
+  if (!(vis == RV_PRIVATE || vis == RV_PUBLIC))
+    return -ST_BAD_RESOURCE;
 
-  if (!mm_validate_buffer (proc->pd, (uintptr_t)out_paddr_buf, sizeof (uintptr_t), 0)) {
+  struct resource_buffer* rbuf = NULL;
-    spin_unlock (&proc->pd->lock, &ctxprpd);
+  if (buffer_ptr != 0) {
+    rbuf = sys_get_user_buffer (proc, buffer_ptr, sizeof (struct resource_buffer));
+    if (rbuf == NULL)
       return -ST_BAD_ADDRESS_SPACE;
   }
 
-  spin_unlock (&proc->pd->lock, &ctxprpd);
+  /* confusing data is invalid */
+  if ((rbuf != NULL) && (type != rbuf->type))
+    return -ST_BAD_RESOURCE;
 
-  uintptr_t* out_paddr_buf_vaddr = (uintptr_t*)((uintptr_t)hhdm->offset + out_paddr_buf_paddr);
+  switch (type) {
+  case PR_MEM: {
+    /* need rbuf to construct */
+    if (rbuf == NULL)
+      return -ST_BAD_RESOURCE;
 
-  struct proc_resource_mem_init mem_init = {.pages = pages};
+    struct proc_resource_mem_init mem_init = {
-  struct proc_resource* r = proc_create_resource (proc, rid, PR_MEM, vis, &mem_init);
+        .managed = false,
+        .pages = rbuf->u.mem.pages,
+    };
 
-  if (r != NULL) {
+    struct proc_resource* resource = proc_create_resource (proc, rid, type, vis, &mem_init);
-    *out_paddr_buf_vaddr = r->u.mem.paddr;
+
-    return r->rid;
+    if (resource == NULL) {
-  } else {
       return -ST_OOM_ERROR;
     }
+
+    rbuf->u.mem.pages = resource->u.mem.pages;
+    rbuf->u.mem.paddr = resource->u.mem.paddr;
+
+    return resource->rid;
+  } break;
+  case PR_MUTEX: {
+    /* no rbuf is fine */
+
+    struct proc_resource* resource = proc_create_resource (proc, rid, type, vis, NULL);
+
+    if (resource == NULL) {
+      return -ST_OOM_ERROR;
+    }
+
+    return resource->rid;
+  } break;
+  }
+
+  assert (0);
 }
 
-/* int proc_create_resource_mutex (int rid, int vis) */
+/* int proc_mutex_lock (int mutex_rid, int vis) */
-DEFINE_SYSCALL (sys_proc_create_resource_mutex) {
+DEFINE_SYSCALL (sys_proc_mutex_lock) {
   int rid = (int)a1;
   int vis = (int)a2;
 
   if (rid < 0)
     return -ST_BAD_RESOURCE;
 
-  struct proc_resource* r = proc_create_resource (proc, rid, PR_MUTEX, vis, NULL);
+  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-  if (r != NULL)
+    return -ST_BAD_RESOURCE;
-    return r->rid;
-  else
-    return -ST_OOM_ERROR;
-}
 
-/* int proc_mutex_lock (int mutex_rid) */
+  struct proc_resource* resource = proc_find_resource (proc, rid, vis);
-DEFINE_SYSCALL (sys_proc_mutex_lock) {
-  spin_lock_ctx_t ctxpr;
-  int rid = (int)a1;
-
-  struct proc_resource* resource;
-  spin_lock (&proc->lock, &ctxpr);
-  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
-               rid);
-  spin_unlock (&proc->lock, &ctxpr);
 
   if (resource == NULL)
     return -ST_NOT_FOUND;
@@ -131,16 +168,18 @@ DEFINE_SYSCALL (sys_proc_mutex_lock) {
   return ST_OK;
 }
 
-/* int proc_mutex_unlock (int mutex_rid) */
+/* int proc_mutex_unlock (int mutex_rid, int vis) */
 DEFINE_SYSCALL (sys_proc_mutex_unlock) {
-  spin_lock_ctx_t ctxpr;
   int rid = (int)a1;
+  int vis = (int)a2;
 
-  struct proc_resource* resource;
+  if (rid < 0)
-  spin_lock (&proc->lock, &ctxpr);
+    return -ST_BAD_RESOURCE;
-  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
+
-               rid);
+  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-  spin_unlock (&proc->lock, &ctxpr);
+    return -ST_BAD_RESOURCE;
+
+  struct proc_resource* resource = proc_find_resource (proc, rid, vis);
 
   if (resource == NULL)
     return -ST_NOT_FOUND;
@@ -149,26 +188,26 @@ DEFINE_SYSCALL (sys_proc_mutex_unlock) {
   if (result < 0)
     return result;
 
-  proc_sched (regs);
-
   return ST_OK;
 }
 
-/* int proc_drop_resource (int rid) */
+/* int proc_drop_resource (int rid, int vis) */
 DEFINE_SYSCALL (sys_proc_drop_resource) {
-  spin_lock_ctx_t ctxpr;
   int rid = (int)a1;
+  int vis = (int)a2;
 
-  struct proc_resource* resource;
+  if (rid < 0)
-  spin_lock (&proc->lock, &ctxpr);
+    return -ST_BAD_RESOURCE;
-  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
+
-               rid);
+  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-  spin_unlock (&proc->lock, &ctxpr);
+    return -ST_BAD_RESOURCE;
+
+  struct proc_resource* resource = proc_find_resource (proc, rid, vis);
 
   if (resource == NULL)
     return -ST_NOT_FOUND;
 
-  proc_drop_resource (proc, resource);
+  proc_drop_resource (proc, resource, true);
 
   return ST_OK;
 }
@@ -202,26 +241,18 @@ DEFINE_SYSCALL (sys_proc_sched) {
   return ST_OK;
 }
 
+/* int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr) */
 DEFINE_SYSCALL (sys_proc_translate_v2p) {
-  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
-  spin_lock_ctx_t ctxprpd;
   int result = ST_OK;
 
   uintptr_t vaddr = a1;
-  uintptr_t* out_paddr_buf = (uintptr_t*)a2;
+  uintptr_t out_paddr_buf = a2;
 
-  spin_lock (&proc->pd->lock, &ctxprpd);
+  uintptr_t* out_paddr_buf_vaddr = sys_get_user_buffer (proc, out_paddr_buf, sizeof (uintptr_t));
-
+  if (out_paddr_buf_vaddr == NULL)
-  uintptr_t out_paddr_buf_paddr = mm_v2p (proc->pd, (uintptr_t)out_paddr_buf, 0);
-
-  if (!mm_validate_buffer (proc->pd, (uintptr_t)out_paddr_buf, sizeof (uintptr_t), 0)) {
-    spin_unlock (&proc->pd->lock, &ctxprpd);
     return -ST_BAD_ADDRESS_SPACE;
-  }
 
-  uintptr_t* out_paddr_buf_vaddr = (uintptr_t*)((uintptr_t)hhdm->offset + out_paddr_buf_paddr);
+  uintptr_t translated_addr = mm_v2p (proc->pd, vaddr, MM_PD_LOCK);
-
-  uintptr_t translated_addr = mm_v2p (proc->pd, vaddr, 0);
   if (translated_addr == 0) {
     result = -ST_BAD_ADDRESS_SPACE;
     goto done;
@@ -230,44 +261,21 @@ DEFINE_SYSCALL (sys_proc_translate_v2p) {
   *out_paddr_buf_vaddr = translated_addr;
 
 done:
-  spin_unlock (&proc->pd->lock, &ctxprpd);
   return result;
 }
 
-/* int proc_resource_mem_unref (int mem_rid, size_t pages) */
-DEFINE_SYSCALL (sys_proc_mem_unref) {
-  spin_lock_ctx_t ctxpr;
-  int rid = (int)a1;
-  size_t pages = (size_t)a2;
-
-  struct proc_resource* resource;
-  spin_lock (&proc->lock, &ctxpr);
-  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
-               rid);
-  spin_unlock (&proc->lock, &ctxpr);
-
-  if (resource == NULL)
-    return -ST_NOT_FOUND;
-
-  proc_mem_unref (proc, &resource->u.mem, pages);
-
-  return ST_OK;
-}
-
 static syscall_handler_func_t handler_table[] = {
     [SYS_PROC_QUIT] = &sys_proc_quit,
     [SYS_PROC_TEST] = &sys_proc_test,
     [SYS_PROC_MAP] = &sys_proc_map,
     [SYS_PROC_UNMAP] = &sys_proc_unmap,
-    [SYS_PROC_CREATE_RESOURCE_MEM] = &sys_proc_create_resource_mem,
+    [SYS_PROC_CREATE_RESOURCE] = &sys_proc_create_resource,
     [SYS_PROC_DROP_RESOURCE] = &sys_proc_drop_resource,
-    [SYS_PROC_CREATE_RESOURCE_MUTEX] = &sys_proc_create_resource_mutex,
     [SYS_PROC_MUTEX_LOCK] = &sys_proc_mutex_lock,
     [SYS_PROC_MUTEX_UNLOCK] = &sys_proc_mutex_unlock,
     [SYS_PROC_SPAWN_THREAD] = &sys_proc_spawn_thread,
     [SYS_PROC_SCHED] = &sys_proc_sched,
     [SYS_PROC_TRANSLATE_V2P] = &sys_proc_translate_v2p,
-    [SYS_PROC_MEM_UNREF] = &sys_proc_mem_unref,
 };
 
 syscall_handler_func_t syscall_find_handler (int syscall_num) {

libmsl/alloc/liballoc.c

@@ -3,32 +3,36 @@
 
 #include <alloc/liballoc.h>
 #include <m/proc.h>
+#include <m/resource_buffer.h>
 
 static int liballoc_mutex;
 static uintptr_t liballoc_map_base = PROC_MAP_BASE;
 static int mem_rid_base = 1000000;
 
-void liballoc_init (void) { liballoc_mutex = proc_create_resource_mutex (100, RV_PRIVATE); }
+void liballoc_init (void) {
+  liballoc_mutex = proc_create_resource (100, PR_MUTEX, RV_PRIVATE, NULL);
+}
 
 int liballoc_lock (void) {
-  proc_mutex_lock (liballoc_mutex);
+  proc_mutex_lock (liballoc_mutex, RV_PRIVATE);
   return 0;
 }
 
 int liballoc_unlock (void) {
-  proc_mutex_unlock (liballoc_mutex);
+  proc_mutex_unlock (liballoc_mutex, RV_PRIVATE);
   return 0;
 }
 
 void* liballoc_alloc (int pages) {
   uintptr_t current_base = liballoc_map_base;
-  uintptr_t out_paddr;
 
-  int mem_rid = proc_create_resource_mem (mem_rid_base++, pages, RV_PRIVATE, &out_paddr);
+  struct resource_buffer mem_init = {.type = PR_MEM, .u = {.mem = {.pages = (size_t)pages}}};
+
+  int mem_rid = proc_create_resource (mem_rid_base++, PR_MEM, RV_PRIVATE, &mem_init);
   if (mem_rid < 0)
     return NULL;
 
-  proc_map (out_paddr, current_base, pages, PM_PRESENT | PM_RW | PM_USER);
+  proc_map (mem_init.u.mem.paddr, current_base, (size_t)pages, PM_PRESENT | PM_RW | PM_USER);
 
   uintptr_t old_base = current_base;
   current_base += pages * PAGE_SIZE;
@@ -36,20 +40,7 @@ void* liballoc_alloc (int pages) {
   return (void*)old_base;
 }
 
-int liballoc_free (void* ptr, int pages) {
+int liballoc_free (void* ptr, int pages) { return 0; }
-  int res;
-  uintptr_t out_paddr;
-
-  res = proc_translate_v2p ((uintptr_t)ptr, &out_paddr);
-  if (res < 0)
-    return res;
-
-  res = proc_unmap ((uintptr_t)ptr, pages);
-  if (res < 0)
-    return res;
-
-  return proc_mem_unref (out_paddr, pages);
-}
 
 /**  Durand's Ridiculously Amazing Super Duper Memory functions.  */
 

libmsl/m/proc.c

@@ -1,3 +1,4 @@
+#include <m/resource_buffer.h>
 #include <m/syscall.h>
 #include <m/syscall_defs.h>
 #include <stddef.h>
@@ -15,25 +16,21 @@ int proc_unmap (uintptr_t vaddr, size_t pages) {
   return syscall (SYS_PROC_UNMAP, vaddr, (uintptr_t)pages, 0, 0, 0, 0);
 }
 
-int proc_create_resource_mem (int rid, size_t pages, int vis, uintptr_t* out_paddr) {
+int proc_create_resource (int rid, int type, int vis, void* buffer) {
-  return syscall (SYS_PROC_CREATE_RESOURCE_MEM, (uintptr_t)rid, (uintptr_t)pages, (uintptr_t)vis,
+  return syscall (SYS_PROC_CREATE_RESOURCE, (uintptr_t)rid, (uintptr_t)type, (uintptr_t)vis,
-                  (uintptr_t)out_paddr, 0, 0);
+                  (uintptr_t)buffer, 0, 0);
 }
 
-int proc_drop_resource (int rid) {
+int proc_drop_resource (int rid, int vis) {
-  return syscall (SYS_PROC_DROP_RESOURCE, (uintptr_t)rid, 0, 0, 0, 0, 0);
+  return syscall (SYS_PROC_DROP_RESOURCE, (uintptr_t)rid, (uintptr_t)vis, 0, 0, 0, 0);
 }
 
-int proc_create_resource_mutex (int rid, int vis) {
+int proc_mutex_lock (int mutex_rid, int vis) {
-  return syscall (SYS_PROC_CREATE_RESOURCE_MUTEX, (uintptr_t)rid, (uintptr_t)vis, 0, 0, 0, 0);
+  return syscall (SYS_PROC_MUTEX_LOCK, (uintptr_t)mutex_rid, (uintptr_t)vis, 0, 0, 0, 0);
 }
 
-int proc_mutex_lock (int mutex_rid) {
+int proc_mutex_unlock (int mutex_rid, int vis) {
-  return syscall (SYS_PROC_MUTEX_LOCK, (uintptr_t)mutex_rid, 0, 0, 0, 0, 0);
+  return syscall (SYS_PROC_MUTEX_UNLOCK, (uintptr_t)mutex_rid, (uintptr_t)vis, 0, 0, 0, 0);
-}
-
-int proc_mutex_unlock (int mutex_rid) {
-  return syscall (SYS_PROC_MUTEX_UNLOCK, (uintptr_t)mutex_rid, 0, 0, 0, 0, 0);
 }
 
 int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry) {
@@ -45,8 +42,4 @@ int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr) {
   return syscall (SYS_PROC_TRANSLATE_V2P, vaddr, (uintptr_t)out_paddr, 0, 0, 0, 0);
 }
 
-int proc_mem_unref (uintptr_t paddr, size_t pages) {
-  return syscall (SYS_PROC_MEM_UNREF, paddr, (uintptr_t)pages, 0, 0, 0, 0);
-}
-
 int proc_sched (void) { return syscall (SYS_PROC_SCHED, 0, 0, 0, 0, 0, 0); }

libmsl/m/proc.h

@@ -13,6 +13,9 @@
 #define RV_PRIVATE 0
 #define RV_PUBLIC  1
 
+#define PR_MEM   0
+#define PR_MUTEX 1
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -20,14 +23,12 @@ int proc_quit (void);
 int proc_test (char c);
 int proc_map (uintptr_t paddr, uintptr_t vaddr, size_t pages, uint32_t flags);
 int proc_unmap (uintptr_t vaddr, size_t pages);
-int proc_create_resource_mem (int rid, size_t pages, int vis, uintptr_t* out_paddr);
+int proc_create_resource (int rid, int type, int vis, void* buffer);
-int proc_drop_resource (int rid);
+int proc_drop_resource (int rid, int vis);
-int proc_create_resource_mutex (int rid, int vis);
+int proc_mutex_lock (int mutex_rid, int vis);
-int proc_mutex_lock (int mutex_rid);
+int proc_mutex_unlock (int mutex_rid, int vis);
-int proc_mutex_unlock (int mutex_rid);
 int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry);
 int proc_sched (void);
 int proc_translate_v2p (uintptr_t vaddr, uintptr_t* out_paddr);
-int proc_mem_unref (uintptr_t paddr, size_t pages);
 
 #endif // _LIBMSL_M_PROC_H