diff --git a/init/init.c b/init/init.c
index 003980c..2281468 100644
--- a/init/init.c
+++ b/init/init.c
@@ -6,14 +6,13 @@
 #include <stdint.h>
 #include <string/string.h>
 
-#define EXAMPLE 3
+#define EXAMPLE 1
 
 #if EXAMPLE == 1
 
-void app_thread1 (void) {
-  test ('b');
-  quit ();
-}
+#define MUTEX 2000
+
+void app_thread1 (void);
 
 int spawn (void (*fn) (void)) {
   size_t stack_size = 256 * PAGE_SIZE;
@@ -25,7 +24,29 @@ int spawn (void (*fn) (void)) {
   return clone (stack_top, stack_size, fn);
 }
 
-void app_main (void) { spawn (&app_thread1); }
+void app_main (void) {
+  create_mutex (MUTEX);
+
+  spawn (&app_thread1);
+
+  lock_mutex (MUTEX);
+
+  for (int i = 0; i < 3; i++)
+    test ('a');
+
+  unlock_mutex (MUTEX);
+}
+
+void app_thread1 (void) {
+  lock_mutex (MUTEX);
+
+  for (int i = 0; i < 3; i++)
+    test ('b');
+
+  unlock_mutex (MUTEX);
+
+  quit ();
+}
 #elif EXAMPLE == 2
 
 #define MUTEX 2000
@@ -43,28 +64,28 @@ int spawn (void (*fn) (void)) {
 }
 
 void app_main (void) {
-  create_mutex (MUTEX, RV_PRIVATE);
+  create_mutex (MUTEX);
 
   spawn (&app_thread1);
 
   for (;;) {
-    lock_mutex (MUTEX, RV_PRIVATE);
+    lock_mutex (MUTEX);
 
     for (int i = 0; i < 3; i++)
       test ('a');
 
-    unlock_mutex (MUTEX, RV_PRIVATE);
+    unlock_mutex (MUTEX);
   }
 }
 
 void app_thread1 (void) {
   for (;;) {
-    lock_mutex (MUTEX, RV_PRIVATE);
+    lock_mutex (MUTEX);
 
     for (int i = 0; i < 3; i++)
       test ('b');
 
-    unlock_mutex (MUTEX, RV_PRIVATE);
+    unlock_mutex (MUTEX);
   }
 
   quit ();
@@ -86,12 +107,12 @@ int spawn (void (*fn) (void)) {
 }
 
 void app_main (void) {
-  create_mutex (MUTEX, RV_PRIVATE);
+  create_mutex (MUTEX);
 
   spawn (&app_thread1);
 
   for (;;) {
-    lock_mutex (MUTEX, RV_PRIVATE);
+    lock_mutex (MUTEX);
 
     for (int i = 0; i < 3; i++)
       test ('a');
@@ -102,12 +123,12 @@ void app_main (void) {
 
 void app_thread1 (void) {
   for (;;) {
-    lock_mutex (MUTEX, RV_PRIVATE);
+    lock_mutex (MUTEX);
 
     for (int i = 0; i < 3; i++)
       test ('b');
 
-    unlock_mutex (MUTEX, RV_PRIVATE);
+    unlock_mutex (MUTEX);
   }
 
   quit ();
diff --git a/kernel/amd64/mm.h b/kernel/amd64/mm.h
index f48bc18..5aa6ceb 100644
--- a/kernel/amd64/mm.h
+++ b/kernel/amd64/mm.h
@@ -9,7 +9,6 @@
 struct pd {
   spin_lock_t lock;
   uintptr_t cr3_paddr;
-  atomic_int refs;
 };
 
 void amd64_load_kernel_cr3 (void);
diff --git a/kernel/amd64/proc.c b/kernel/amd64/proc.c
index 68fa6d6..e841942 100644
--- a/kernel/amd64/proc.c
+++ b/kernel/amd64/proc.c
@@ -9,6 +9,7 @@
 #include <mm/liballoc.h>
 #include <mm/pmm.h>
 #include <proc/proc.h>
+#include <proc/procgroup.h>
 #include <proc/resource.h>
 #include <sync/rw_spin_lock.h>
 #include <sync/spin_lock.h>
@@ -31,59 +32,31 @@ 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) {
+  proc->procgroup = procgroup_create ();
+  if (proc->procgroup == 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;
+  procgroup_attach (proc->procgroup, proc);
 
-  proc->pd = malloc (sizeof (*proc->pd));
-  if (proc->pd == NULL) {
-    free (proc->resources);
-    free (proc);
-    return NULL;
-  }
-
-  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;
-  }
-
-  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE,
-                                                 .managed = false};
-  rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
+  rid = procgroup_get_sys_rid (proc->procgroup);
   struct proc_resource* kstk_r =
-      proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
+      proc_create_resource_mem (proc->procgroup, rid, KSTACK_SIZE / PAGE_SIZE, 0, false);
   if (kstk_r == NULL) {
-    pmm_free (proc->pd->cr3_paddr, 1);
-    free (proc->pd);
-    free (proc->resources);
+    procgroup_detach (proc->procgroup, proc);
     free (proc);
     return NULL;
   }
 
   proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_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);
+  rid = procgroup_get_sys_rid (proc->procgroup);
   struct proc_resource* ustk_r =
-      proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&ustk_mem_init);
+      proc_create_resource_mem (proc->procgroup, rid, USTACK_SIZE / PAGE_SIZE, 0, false);
   if (ustk_r == NULL) {
-    kstk_r->ops.cleanup (proc, kstk_r);
+    kstk_r->ops.cleanup (kstk_r);
     free (kstk_r);
-    pmm_free (proc->pd->cr3_paddr, 1);
-    free (proc->pd);
-    free (proc->resources);
+    procgroup_detach (proc->procgroup, proc);
     free (proc);
     return NULL;
   }
@@ -109,7 +82,7 @@ struct proc* proc_from_elf (uint8_t* elf_contents) {
 struct proc* proc_clone (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, ctxrs;
+  spin_lock_ctx_t ctxprt;
   int rid;
 
   struct proc* proc = malloc (sizeof (*proc));
@@ -124,47 +97,25 @@ struct proc* proc_clone (struct proc* proto, uintptr_t vstack_top, size_t stack_
 
   spin_lock (&proto->lock, &ctxprt);
 
-  proc->pd = proto->pd;
-  proc->mappings = proto->mappings;
-  atomic_fetch_add (&proto->pd->refs, 1);
-
-  proc->resources = proto->resources;
-
-  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);
+  proc->procgroup = proto->procgroup;
+  procgroup_attach (proc->procgroup, proc);
 
   spin_unlock (&proto->lock, &ctxprt);
 
   uintptr_t vstack_bottom = vstack_top - stack_size;
 
-  uintptr_t pstack_bottom = mm_v2p (proc->pd, vstack_bottom, MM_PD_LOCK);
+  uintptr_t pstack_bottom = mm_v2p (&proc->procgroup->pd, vstack_bottom, MM_PD_LOCK);
   if (pstack_bottom == 0) {
+    procgroup_detach (proc->procgroup, proc);
     free (proc);
     return NULL;
   }
 
-  struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE,
-                                                 .managed = false};
-  rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
+  rid = procgroup_get_sys_rid (proc->procgroup);
   struct proc_resource* kstk_r =
-      proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
+      proc_create_resource_mem (proc->procgroup, rid, KSTACK_SIZE / PAGE_SIZE, 0, false);
   if (kstk_r == NULL) {
+    procgroup_detach (proc->procgroup, proc);
     free (proc);
     return NULL;
   }
@@ -183,8 +134,7 @@ struct proc* proc_clone (struct proc* proto, uintptr_t vstack_top, size_t stack_
 }
 
 void proc_cleanup (struct proc* proc) {
-  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
-  spin_lock_ctx_t ctxprpd, ctxsq, ctxpr;
+  spin_lock_ctx_t ctxsq, ctxpr;
 
   spin_lock (&proc->lock, &ctxpr);
 
@@ -209,37 +159,26 @@ void proc_cleanup (struct proc* proc) {
 
   spin_unlock (&proc->lock, &ctxpr);
 
-  /* clean resources */
-  proc_cleanup_resources (proc);
+  procgroup_detach (proc->procgroup, proc);
 
   /* clean virtual address space */
-  if (atomic_fetch_sub (&proc->pd->refs, 1) == 1) {
-    DEBUG ("PID %d Free virtual address space\n", proc->pid);
-    struct list_node_link *mapping_link, *mapping_link_tmp;
-    spin_lock (&proc->pd->lock, &ctxprpd);
+  /* if (atomic_fetch_sub (&proc->pd->refs, 1) == 1) { */
+  /*   DEBUG ("PID %d Free virtual address space\n", proc->pid); */
+  /*   struct list_node_link *mapping_link, *mapping_link_tmp; */
+  /*   spin_lock (&proc->pd->lock, &ctxprpd); */
 
-    list_foreach (proc->mappings, mapping_link, mapping_link_tmp) {
-      struct proc_mapping* mapping =
-          list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
+  /*   list_foreach (proc->mappings, mapping_link, mapping_link_tmp) { */
+  /*     struct proc_mapping* mapping = */
+  /*         list_entry (mapping_link, struct proc_mapping, proc_mappings_link); */
 
-      list_remove (proc->mappings, mapping_link);
-      free (mapping);
-    }
+  /*     list_remove (proc->mappings, mapping_link); */
+  /*     free (mapping); */
+  /*   } */
 
-    pmm_free (proc->pd->cr3_paddr, 1);
-    spin_unlock (&proc->pd->lock, &ctxprpd);
-    free (proc->pd);
-  }
-
-  /* clean kstack */
-  pmm_free (proc->pdata.kernel_stack - (uintptr_t)hhdm->offset - KSTACK_SIZE,
-            KSTACK_SIZE / PAGE_SIZE);
-
-  /* clean ustack */
-  if ((proc->flags & PROC_USTK_PREALLOC))
-    pmm_free (proc->pdata.user_stack, USTACK_SIZE / PAGE_SIZE);
-
-  DEBUG ("PID %d Free stacks\n", proc->pid);
+  /*   pmm_free (proc->pd->cr3_paddr, 1); */
+  /*   spin_unlock (&proc->pd->lock, &ctxprpd); */
+  /*   free (proc->pd); */
+  /* } */
 
   /* clean the process */
   free (proc);
diff --git a/kernel/amd64/sched1.c b/kernel/amd64/sched1.c
index 1b36226..7f38f65 100644
--- a/kernel/amd64/sched1.c
+++ b/kernel/amd64/sched1.c
@@ -18,5 +18,5 @@ void do_sched (struct proc* proc, spin_lock_t* cpu_lock, spin_lock_ctx_t* ctxcpu
   spin_unlock (&proc->lock, &ctxpr);
   spin_unlock (cpu_lock, ctxcpu);
 
-  amd64_do_sched ((void*)&proc->pdata.regs, (void*)proc->pd->cr3_paddr);
+  amd64_do_sched ((void*)&proc->pdata.regs, (void*)proc->procgroup->pd.cr3_paddr);
 }
diff --git a/kernel/proc/locks.txt b/kernel/proc/locks.txt
index f180302..e67fb14 100644
--- a/kernel/proc/locks.txt
+++ b/kernel/proc/locks.txt
@@ -2,5 +2,9 @@ Lock hierarchy for process scheduling:
 
 1. proc_tree_lock
 2. cpu->lock
-3. proc->lock
-4. sq->lock
+3. procgroup->lock
+4. proc->lock
+5. sq->lock
+
+1. procgroup_tree_lock
+2. procgroup->lock
diff --git a/kernel/proc/mem.c b/kernel/proc/mem.c
index 541a39e..aeffd00 100644
--- a/kernel/proc/mem.c
+++ b/kernel/proc/mem.c
@@ -5,29 +5,7 @@
 #include <proc/resource.h>
 #include <sync/spin_lock.h>
 
-bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resource_mem_init* init) {
-  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;
-}
-
-void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource) {
-  (void)proc;
-
+void proc_cleanup_resource_mem (struct proc_resource* resource) {
   if (!resource->u.mem.managed)
     pmm_free (resource->u.mem.paddr, resource->u.mem.pages);
 }
diff --git a/kernel/proc/mem.h b/kernel/proc/mem.h
index 2974428..a3d5564 100644
--- a/kernel/proc/mem.h
+++ b/kernel/proc/mem.h
@@ -15,13 +15,6 @@ struct proc_resource_mem {
   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_cleanup_resource_mem (struct proc_resource* resource);
 
 #endif // _KERNEL_PROC_MEM_H
diff --git a/kernel/proc/mutex.c b/kernel/proc/mutex.c
index 47ffe5a..d715ddd 100644
--- a/kernel/proc/mutex.c
+++ b/kernel/proc/mutex.c
@@ -85,13 +85,7 @@ static void proc_mutex_resume (struct proc* proc, struct proc_sq_entry* sq_entry
   cpu_request_sched (cpu);
 }
 
-bool proc_create_resource_mutex (struct proc_mutex* mutex) {
-  memset (mutex, 0, sizeof (*mutex));
-
-  return true;
-}
-
-void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource) {
+void proc_cleanup_resource_mutex (struct proc_resource* resource) {
   struct proc_mutex* mutex = &resource->u.mutex;
   spin_lock_ctx_t ctxmt, ctxsq;
 
diff --git a/kernel/proc/mutex.h b/kernel/proc/mutex.h
index 7a244c6..710c71f 100644
--- a/kernel/proc/mutex.h
+++ b/kernel/proc/mutex.h
@@ -15,8 +15,7 @@ struct proc_mutex {
   struct proc* owner;
 };
 
-bool proc_create_resource_mutex (struct proc_mutex* mutex);
-void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource);
+void proc_cleanup_resource_mutex (struct proc_resource* resource);
 void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex);
 bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex);
 
diff --git a/kernel/proc/proc.c b/kernel/proc/proc.c
index dde8876..f7f90c0 100644
--- a/kernel/proc/proc.c
+++ b/kernel/proc/proc.c
@@ -11,6 +11,7 @@
 #include <mm/pmm.h>
 #include <proc/kpproc_fb.h>
 #include <proc/proc.h>
+#include <proc/procgroup.h>
 #include <proc/resource.h>
 #include <rd/rd.h>
 #include <sync/rw_spin_lock.h>
@@ -56,16 +57,16 @@ bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr,
 
   flags &= ~(MM_PD_LOCK | MM_PD_RELOAD); /* clear LOCK flag if present, because we lock manualy */
 
-  spin_lock (&proc->pd->lock, &ctxprpd);
+  spin_lock (&proc->procgroup->pd.lock, &ctxprpd);
 
-  list_append (proc->mappings, &mapping->proc_mappings_link);
+  list_append (proc->procgroup->mappings, &mapping->proc_mappings_link);
 
   for (uintptr_t vpage = start_vaddr, ppage = start_paddr; vpage < start_vaddr + pages * PAGE_SIZE;
        vpage += PAGE_SIZE, ppage += PAGE_SIZE) {
-    mm_map_page (proc->pd, ppage, vpage, flags);
+    mm_map_page (&proc->procgroup->pd, ppage, vpage, flags);
   }
 
-  spin_unlock (&proc->pd->lock, &ctxprpd);
+  spin_unlock (&proc->procgroup->pd.lock, &ctxprpd);
 
   return true;
 }
@@ -81,9 +82,9 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
   if (tail_mapping == NULL)
     return false;
 
-  spin_lock (&proc->pd->lock, &ctxprpd);
+  spin_lock (&proc->procgroup->pd.lock, &ctxprpd);
 
-  list_foreach (proc->mappings, mapping_link, mapping_link_tmp) {
+  list_foreach (proc->procgroup->mappings, mapping_link, mapping_link_tmp) {
     struct proc_mapping* mapping =
         list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
 
@@ -99,7 +100,7 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
 
         mapping->size = start_vaddr - mapping->vaddr;
 
-        list_insert_after (proc->mappings, &mapping->proc_mappings_link,
+        list_insert_after (proc->procgroup->mappings, &mapping->proc_mappings_link,
                            &tail_mapping->proc_mappings_link);
 
         used_tail_mapping = true;
@@ -113,7 +114,7 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
       } else if ((start_vaddr > mapping->vaddr) && (end_vaddr >= m_end)) { /* shrink right */
         mapping->size = start_vaddr - mapping->vaddr;
       } else { /* full overlap */
-        list_remove (proc->mappings, &mapping->proc_mappings_link);
+        list_remove (proc->procgroup->mappings, &mapping->proc_mappings_link);
         free (mapping);
       }
     }
@@ -123,10 +124,10 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
     free (tail_mapping);
 
   for (uintptr_t vpage = start_vaddr; vpage < end_vaddr; vpage += PAGE_SIZE) {
-    mm_unmap_page (proc->pd, vpage, 0);
+    mm_unmap_page (&proc->procgroup->pd, vpage, 0);
   }
 
-  spin_unlock (&proc->pd->lock, &ctxprpd);
+  spin_unlock (&proc->procgroup->pd.lock, &ctxprpd);
 
   return true;
 }
@@ -155,10 +156,8 @@ 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, PR_MEM, RV_PRIVATE, (void*)&mem_init);
+      int rid = procgroup_get_sys_rid (proc->procgroup);
+      struct proc_resource* r = proc_create_resource_mem (proc->procgroup, rid, blks, 0, false);
       if (r == NULL) {
         DEBUG ("pmm oom error while loading ELF segments! (tried to alloc %zu blks)\n", blks);
       }
@@ -357,14 +356,9 @@ static void proc_kpproc_init (void) {
   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;
+  kpproc.procgroup = procgroup_create ();
+  procgroup_attach (kpproc.procgroup, &kpproc);
 
   rbtree_insert (struct proc, &proc_tree, &kpproc.proc_tree_link, proc_tree_link, pid);
 
@@ -394,9 +388,7 @@ static void proc_kpproc_init (void) {
     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);
+    proc_create_resource_mem (kpproc.procgroup, 0, pages, fb_info_memblk_paddr, true);
   }
 }
 
diff --git a/kernel/proc/proc.h b/kernel/proc/proc.h
index 8b05327..ba422f2 100644
--- a/kernel/proc/proc.h
+++ b/kernel/proc/proc.h
@@ -6,6 +6,7 @@
 #include <libk/list.h>
 #include <libk/rbtree.h>
 #include <libk/std.h>
+#include <proc/procgroup.h>
 #include <proc/resource.h>
 #include <proc/suspension_q.h>
 #include <sync/rw_spin_lock.h>
@@ -23,25 +24,11 @@
 #define PROC_SUSPENDED 2
 #define PROC_PSEUDO    3
 
+/* process flags */
 #define PROC_USTK_PREALLOC (1 << 0)
 
 struct cpu;
 
-struct proc_mapping {
-  struct list_node_link proc_mappings_link;
-
-  uintptr_t paddr;
-  uintptr_t vaddr;
-  size_t size;
-};
-
-struct proc_resources {
-  atomic_int refs;
-  atomic_int sys_rids;
-  struct rb_node_link* tree;
-  rw_spin_lock_t lock;
-};
-
 struct proc_sq_entry {
   struct list_node_link sq_link;
   struct list_node_link proc_link;
@@ -52,18 +39,16 @@ struct proc_sq_entry {
 struct proc {
   int pid;
   struct rb_node_link proc_tree_link;
+  struct rb_node_link procgroup_memb_tree_link;
   struct list_node_link cpu_run_q_link;
   struct list_node_link reap_link;
   struct list_node_link* sq_entries;
-
-  struct list_node_link* mappings; /* pd.lock implicitly protects this field */
+  struct procgroup* procgroup;
   struct proc_platformdata pdata;
   uint32_t flags;
-  struct pd* pd;
   spin_lock_t lock;
   struct cpu* cpu;
   atomic_int state;
-  struct proc_resources* resources;
 };
 
 void proc_sched (void);
diff --git a/kernel/proc/procgroup.c b/kernel/proc/procgroup.c
new file mode 100644
index 0000000..2385a78
--- /dev/null
+++ b/kernel/proc/procgroup.c
@@ -0,0 +1,96 @@
+#include <libk/rbtree.h>
+#include <libk/std.h>
+#include <mm/liballoc.h>
+#include <proc/proc.h>
+#include <proc/procgroup.h>
+#include <sync/rw_spin_lock.h>
+#include <sync/spin_lock.h>
+#include <sys/debug.h>
+#include <sys/mm.h>
+
+static struct rb_node_link* procgroup_tree = NULL;
+static rw_spin_lock_t procgroup_tree_lock = RW_SPIN_LOCK_INIT;
+static atomic_int pgids = 0;
+
+struct procgroup* procgroup_create (void) {
+  spin_lock_ctx_t ctxpgtr;
+
+  struct procgroup* procgroup = malloc (sizeof (*procgroup));
+  if (procgroup == NULL) {
+    return NULL;
+  }
+
+  procgroup->refs = 0;
+  procgroup->memb_proc_tree = NULL;
+  procgroup->lock = SPIN_LOCK_INIT;
+  procgroup->pgid = atomic_fetch_add (&pgids, 1);
+  procgroup->pd.lock = SPIN_LOCK_INIT;
+  procgroup->pd.cr3_paddr = mm_alloc_user_pd_phys ();
+
+  rw_spin_write_lock (&procgroup_tree_lock, &ctxpgtr);
+  rbtree_insert (struct procgroup, &procgroup_tree, &procgroup->procgroup_tree_link,
+                 procgroup_tree_link, pgid);
+  rw_spin_write_unlock (&procgroup_tree_lock, &ctxpgtr);
+
+  return procgroup;
+}
+
+void procgroup_attach (struct procgroup* procgroup, struct proc* proc) {
+  spin_lock_ctx_t ctxpg, ctxpr;
+
+  spin_lock (&procgroup->lock, &ctxpg);
+  spin_lock (&proc->lock, &ctxpr);
+
+  rbtree_insert (struct proc, &procgroup->memb_proc_tree, &proc->procgroup_memb_tree_link,
+                 procgroup_memb_tree_link, pid);
+  atomic_fetch_add (&procgroup->refs, 1);
+  DEBUG ("procgrpup attach PID %d to PGID %d\n", proc->pid, procgroup->pgid);
+
+  spin_unlock (&proc->lock, &ctxpr);
+  spin_unlock (&procgroup->lock, &ctxpg);
+}
+
+void procgroup_detach (struct procgroup* procgroup, struct proc* proc) {
+  spin_lock_ctx_t ctxpg, ctxpr, ctxpgtr;
+
+  spin_lock (&procgroup->lock, &ctxpg);
+  spin_lock (&proc->lock, &ctxpr);
+
+  rbtree_delete (&procgroup->memb_proc_tree, &proc->procgroup_memb_tree_link);
+  int refs = atomic_fetch_sub (&procgroup->refs, 1);
+  DEBUG ("procgrpup detach PID %d to PGID %d\n", proc->pid, procgroup->pgid);
+
+  spin_unlock (&proc->lock, &ctxpr);
+  spin_unlock (&procgroup->lock, &ctxpg);
+
+  if (refs == 1) {
+    rw_spin_write_lock (&procgroup_tree_lock, &ctxpgtr);
+    spin_lock (&procgroup->lock, &ctxpg);
+
+    rbtree_delete (&procgroup_tree, &procgroup->procgroup_tree_link);
+
+    spin_unlock (&procgroup->lock, &ctxpg);
+    rw_spin_write_unlock (&procgroup_tree_lock, &ctxpgtr);
+
+    /* unlink resources */
+    struct rb_node_link* rnode;
+    rbtree_first (&procgroup->resource_tree, rnode);
+    while (rnode) {
+      struct rb_node_link* next;
+      rbtree_next (rnode, next);
+
+      struct proc_resource* resource =
+          rbtree_entry (rnode, struct proc_resource, resource_tree_link);
+
+      rnode = next;
+
+      proc_resource_unlink (resource);
+    }
+
+    free (procgroup);
+  }
+}
+
+int procgroup_get_sys_rid (struct procgroup* procgroup) {
+  return atomic_fetch_add (&procgroup->sys_rids, 1);
+}
diff --git a/kernel/proc/procgroup.h b/kernel/proc/procgroup.h
new file mode 100644
index 0000000..ed6fcda
--- /dev/null
+++ b/kernel/proc/procgroup.h
@@ -0,0 +1,38 @@
+#ifndef _KERNEL_PROC_PROCGROUP_H
+#define _KERNEL_PROC_PROCGROUP_H
+
+#include <libk/list.h>
+#include <libk/rbtree.h>
+#include <libk/std.h>
+#include <proc/resource.h>
+#include <sync/spin_lock.h>
+#include <sys/mm.h>
+
+struct proc;
+
+struct proc_mapping {
+  struct list_node_link proc_mappings_link;
+
+  uintptr_t paddr;
+  uintptr_t vaddr;
+  size_t size;
+};
+
+struct procgroup {
+  int pgid;
+  struct rb_node_link procgroup_tree_link;
+  struct rb_node_link* memb_proc_tree;
+  spin_lock_t lock;
+  atomic_int refs;
+  struct rb_node_link* resource_tree;
+  atomic_int sys_rids;
+  struct pd pd;
+  struct list_node_link* mappings; /* protected by pd.lock */
+};
+
+struct procgroup* procgroup_create (void);
+void procgroup_attach (struct procgroup* procgroup, struct proc* proc);
+void procgroup_detach (struct procgroup* procgroup, struct proc* proc);
+int procgroup_get_sys_rid (struct procgroup* procgroup);
+
+#endif // _KERNEL_PROC_PROCGROUP_H
diff --git a/kernel/proc/resource.c b/kernel/proc/resource.c
index 8116a25..9ec8762 100644
--- a/kernel/proc/resource.c
+++ b/kernel/proc/resource.c
@@ -7,169 +7,98 @@
 #include <mm/pmm.h>
 #include <proc/mutex.h>
 #include <proc/proc.h>
+#include <proc/procgroup.h>
 #include <proc/resource.h>
 #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) {
-  spin_lock_ctx_t ctxrs;
-
-  rw_spin_write_lock (&proc->resources->lock, &ctxrs);
-
-  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);
-
-    rnode = next;
-
-    proc_drop_resource (proc, resource, false);
-  }
-
-  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, bool lock) {
-  spin_lock_ctx_t ctxrs;
-
-  if (atomic_fetch_sub (&resource->refs, 1) == 1) {
-    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));
-
-    switch (resource->visibility) {
-    case RV_PRIVATE: {
-      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* proc_find_resource (struct procgroup* procgroup, int rid) {
+  spin_lock_ctx_t ctxpg;
   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;
-  }
+  spin_lock (&procgroup->lock, &ctxpg);
+  rbtree_find (struct proc_resource, &procgroup->resource_tree, rid, resource, resource_tree_link,
+               rid);
+  spin_unlock (&procgroup->lock, &ctxpg);
 
   return resource;
 }
 
-struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type, int vis,
-                                            void* data) {
-  spin_lock_ctx_t ctxrs;
+struct proc_resource* proc_create_resource_mem (struct procgroup* procgroup, int rid, size_t pages,
+                                                uintptr_t paddr, bool managed) {
+  spin_lock_ctx_t ctxpg;
+  struct proc_resource* resource;
 
-  /* Check if resource RID already exists */
-  struct proc_resource* resource_check = proc_find_resource (proc, rid, vis);
-
-  /* Resource was found either way, so it already exists */
-  if (resource_check != NULL)
+  if (pages == 0)
     return NULL;
 
-  /* create the resource */
+  resource = proc_find_resource (procgroup, rid);
+  if (resource != NULL)
+    return resource;
 
-  struct proc_resource* resource = malloc (sizeof (*resource));
+  resource = malloc (sizeof (*resource));
   if (resource == NULL)
     return NULL;
 
   memset (resource, 0, sizeof (*resource));
-
   resource->lock = SPIN_LOCK_INIT;
-  resource->type = type;
-  resource->refs = 1;
+  resource->ops.cleanup = &proc_cleanup_resource_mem;
   resource->rid = rid;
-  resource->visibility = vis;
-  resource->created_by_pid = proc->pid;
-
-  switch (resource->type) {
-  case PR_MEM: {
-    struct proc_resource_mem_init* mem_init = data;
-    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 created_by=%d, type=%d rid=%d paddr=%p, pages=%zu\n", resource,
-           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 created_by=%d type=%d rid=%d\n", resource,
-           resource->created_by_pid, resource->type, resource->rid);
-  } break;
-  default: {
-    free (resource);
-    return NULL;
-  } break;
+  resource->type = PR_MEM;
+  resource->u.mem.resource = resource;
+  if (managed) {
+    resource->u.mem.managed = true;
+  } else {
+    paddr = pmm_alloc (pages);
+    if (paddr == PMM_ALLOC_ERR) {
+      free (resource);
+      return NULL;
+    }
+    resource->u.mem.managed = false;
   }
+  resource->u.mem.paddr = paddr;
+  resource->u.mem.pages = resource->u.mem.alive_pages = pages;
+  resource->refs = 1;
 
-  switch (resource->visibility) {
-  case RV_PRIVATE: {
-    rw_spin_write_lock (&proc->resources->lock, &ctxrs);
-    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;
-  }
+  spin_lock (&procgroup->lock, &ctxpg);
+  rbtree_insert (struct proc_resource, &procgroup->resource_tree, &resource->resource_tree_link,
+                 resource_tree_link, rid);
+  spin_unlock (&procgroup->lock, &ctxpg);
 
   return resource;
 }
+
+struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, int rid) {
+  spin_lock_ctx_t ctxpg;
+  struct proc_resource* resource;
+
+  resource = proc_find_resource (procgroup, rid);
+  if (resource != NULL)
+    return resource;
+
+  resource = malloc (sizeof (*resource));
+  if (resource == NULL)
+    return NULL;
+
+  memset (resource, 0, sizeof (*resource));
+  resource->lock = SPIN_LOCK_INIT;
+  resource->ops.cleanup = &proc_cleanup_resource_mutex;
+  resource->u.mem.resource = resource;
+  resource->rid = rid;
+  resource->type = PR_MUTEX;
+  resource->refs = 1;
+
+  spin_lock (&procgroup->lock, &ctxpg);
+  rbtree_insert (struct proc_resource, &procgroup->resource_tree, &resource->resource_tree_link,
+                 resource_tree_link, rid);
+  spin_unlock (&procgroup->lock, &ctxpg);
+
+  return resource;
+}
+
+void proc_resource_unlink (struct proc_resource* resource) {
+  if (atomic_fetch_sub (&resource->refs, 1) == 1) {
+    resource->ops.cleanup (resource);
+    free (resource);
+  }
+}
diff --git a/kernel/proc/resource.h b/kernel/proc/resource.h
index db8bf16..282cc80 100644
--- a/kernel/proc/resource.h
+++ b/kernel/proc/resource.h
@@ -11,33 +11,28 @@
 #define PR_MEM   0
 #define PR_MUTEX 1
 
-#define RV_PRIVATE 0
-#define RV_PUBLIC  1
-
 struct proc;
+struct procgroup;
 
 struct proc_resource {
   int type;
   int rid;
-  int visibility;
-  spin_lock_t lock;
   atomic_int refs;
-  struct rb_node_link global_resource_tree_link;
-  struct rb_node_link local_resource_tree_link;
+  spin_lock_t lock;
+  struct rb_node_link resource_tree_link;
   union {
     struct proc_resource_mem mem;
     struct proc_mutex mutex;
   } u;
   struct {
-    void (*cleanup) (struct proc* proc, struct proc_resource* resource);
+    void (*cleanup) (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);
-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);
+struct proc_resource* proc_find_resource (struct procgroup* procgroup, int rid);
+struct proc_resource* proc_create_resource_mem (struct procgroup* procgroup, int rid, size_t pages,
+                                                uintptr_t paddr, bool managed);
+struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, int rid);
+void proc_resource_unlink (struct proc_resource* resource);
 
 #endif // _KERNEL_PROC_RESOURCE_H
diff --git a/kernel/proc/src.mk b/kernel/proc/src.mk
index 6e5fd28..ac87b6d 100644
--- a/kernel/proc/src.mk
+++ b/kernel/proc/src.mk
@@ -1,9 +1,11 @@
 c += proc/proc.c \
 		 proc/resource.c \
 		 proc/mutex.c \
-		 proc/mem.c
+		 proc/mem.c \
+		 proc/procgroup.c
 
 o += proc/proc.o \
 		 proc/resource.o \
 		 proc/mutex.o \
-		 proc/mem.o
+		 proc/mem.o \
+		 proc/procgroup.o
diff --git a/kernel/syscall/syscall.c b/kernel/syscall/syscall.c
index d608bde..5b1e6d7 100644
--- a/kernel/syscall/syscall.c
+++ b/kernel/syscall/syscall.c
@@ -8,6 +8,7 @@
 #include <proc/mem.h>
 #include <proc/mutex.h>
 #include <proc/proc.h>
+#include <proc/procgroup.h>
 #include <proc/resource.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
@@ -23,16 +24,16 @@ static void* sys_get_user_buffer (struct proc* proc, uintptr_t uvaddr, size_t si
   struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
   spin_lock_ctx_t ctxprpd;
 
-  spin_lock (&proc->pd->lock, &ctxprpd);
+  spin_lock (&proc->procgroup->pd.lock, &ctxprpd);
 
-  if (!mm_validate_buffer (proc->pd, (uintptr_t)uvaddr, size, 0)) {
-    spin_unlock (&proc->pd->lock, &ctxprpd);
+  if (!mm_validate_buffer (&proc->procgroup->pd, (uintptr_t)uvaddr, size, 0)) {
+    spin_unlock (&proc->procgroup->pd.lock, &ctxprpd);
     return NULL;
   }
 
-  uintptr_t out_paddr = mm_v2p (proc->pd, uvaddr, 0);
+  uintptr_t out_paddr = mm_v2p (&proc->procgroup->pd, uvaddr, 0);
 
-  spin_unlock (&proc->pd->lock, &ctxprpd);
+  spin_unlock (&proc->procgroup->pd.lock, &ctxprpd);
 
   uintptr_t out_kvaddr = (uintptr_t)hhdm->offset + out_paddr;
 
@@ -52,22 +53,18 @@ DEFINE_SYSCALL (sys_test) {
   return ST_OK;
 }
 
-/* int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) */
+/* int map (int mem_rid, uintptr_t vaddr, uint32_t flags) */
 DEFINE_SYSCALL (sys_map) {
   spin_lock_ctx_t ctxrs;
 
   int mem_rid = (int)a1;
-  int vis = (int)a2;
-  uintptr_t vaddr = a3;
-  uint32_t flags = (uint32_t)a4;
+  uintptr_t vaddr = a2;
+  uint32_t flags = (uint32_t)a3;
 
   if (vaddr % PAGE_SIZE != 0)
     return -ST_UNALIGNED;
 
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* mem_resource = proc_find_resource (proc, mem_rid, vis);
+  struct proc_resource* mem_resource = proc_find_resource (proc->procgroup, mem_rid);
 
   if (mem_resource == NULL) {
     return -ST_NOT_FOUND;
@@ -99,22 +96,18 @@ DEFINE_SYSCALL (sys_unmap) {
   return proc_unmap (proc, vaddr, pages) ? ST_OK : -ST_OOM_ERROR;
 }
 
-/* int create_mem (int rid, int vis, size_t pages) */
+/* int create_mem (int rid, size_t pages) */
 DEFINE_SYSCALL (sys_create_mem) {
   int rid = (int)a1;
-  int vis = (int)a2;
-  size_t pages = (size_t)a3;
-
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
+  size_t pages = (size_t)a2;
 
   if (pages == 0)
     return ST_OK;
 
-  int rid1 = rid < 0 ? atomic_fetch_add (&proc->resources->sys_rids, 1) : rid;
-
-  struct proc_resource_mem_init mem_init = {.managed = false, .pages = pages};
-  struct proc_resource* mem_resource = proc_create_resource (proc, rid1, PR_MEM, vis, &mem_init);
+  /* int rid1 = rid < 0 ? atomic_fetch_add (&proc->resources->sys_rids, 1) : rid; */
+  int rid1 = rid < 0 ? procgroup_get_sys_rid (proc->procgroup) : rid;
+  struct proc_resource* mem_resource =
+      proc_create_resource_mem (proc->procgroup, rid1, pages, 0, false);
 
   if (mem_resource == NULL)
     return -ST_OOM_ERROR;
@@ -122,34 +115,33 @@ DEFINE_SYSCALL (sys_create_mem) {
   return mem_resource->rid;
 }
 
-/* int unlink_mem (int rid, int vis, size_t pages) */
+/* int unlink_mem (int rid, size_t pages) */
 DEFINE_SYSCALL (sys_unlink_mem) {
-  spin_lock_ctx_t ctxrs;
+  /* spin_lock_ctx_t ctxrs; */
 
-  int rid = (int)a1;
-  int vis = (int)a2;
-  size_t pages = (size_t)a3;
+  /* int rid = (int)a1; */
+  /* size_t pages = (size_t)a2; */
 
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
+  /* if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) */
+  /*   return -ST_BAD_RESOURCE; */
 
-  struct proc_resource* mem_resource = proc_find_resource (proc, rid, vis);
+  /* struct proc_resource* mem_resource = proc_find_resource (proc, rid, vis); */
 
-  if (mem_resource == NULL)
-    return -ST_NOT_FOUND;
+  /* if (mem_resource == NULL) */
+  /*   return -ST_NOT_FOUND; */
 
-  spin_lock (&mem_resource->lock, &ctxrs);
+  /* spin_lock (&mem_resource->lock, &ctxrs); */
 
-  if (mem_resource->type != PR_MEM) {
-    spin_unlock (&mem_resource->lock, &ctxrs);
-    return -ST_BAD_RESOURCE;
-  }
+  /* if (mem_resource->type != PR_MEM) { */
+  /*   spin_unlock (&mem_resource->lock, &ctxrs); */
+  /*   return -ST_BAD_RESOURCE; */
+  /* } */
 
-  mem_resource->u.mem.alive_pages -= pages;
-  if (mem_resource->u.mem.alive_pages < 0) {
-    spin_unlock (&mem_resource->lock, &ctxrs);
-    proc_drop_resource (proc, mem_resource, true);
-  }
+  /* mem_resource->u.mem.alive_pages -= pages; */
+  /* if (mem_resource->u.mem.alive_pages < 0) { */
+  /*   spin_unlock (&mem_resource->lock, &ctxrs); */
+  /*   proc_drop_resource (proc, mem_resource, true); */
+  /* } */
 
   return ST_OK;
 }
@@ -181,19 +173,11 @@ DEFINE_SYSCALL (sys_sched) {
   return ST_OK;
 }
 
-/* int create_mutex (int mutex_rid, int vis) */
+/* int create_mutex (int mutex_rid) */
 DEFINE_SYSCALL (sys_create_mutex) {
   int mutex_rid = (int)a1;
-  int vis = (int)a2;
 
-  if (mutex_rid < 0)
-    return -ST_BAD_RESOURCE;
-
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* mutex_resource =
-      proc_create_resource (proc, mutex_rid, PR_MUTEX, vis, NULL);
+  struct proc_resource* mutex_resource = proc_create_resource_mutex (proc->procgroup, mutex_rid);
 
   if (mutex_resource == NULL)
     return -ST_OOM_ERROR;
@@ -201,33 +185,25 @@ DEFINE_SYSCALL (sys_create_mutex) {
   return mutex_resource->rid;
 }
 
-/* int unlink_mutex (int mutex_rid, int vis) */
+/* int unlink_mutex (int mutex_rid) */
 DEFINE_SYSCALL (sys_unlink_mutex) {
   int mutex_rid = (int)a1;
-  int vis = (int)a2;
 
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);
+  struct proc_resource* mutex_resource = proc_find_resource (proc->procgroup, mutex_rid);
 
   if (mutex_resource == NULL)
     return -ST_NOT_FOUND;
 
-  proc_drop_resource (proc, mutex_resource, true);
+  /* proc_drop_resource (proc, mutex_resource, true); */
 
   return ST_OK;
 }
 
-/* int lock_mutex (int mutex_rid, int vis) */
+/* int lock_mutex (int mutex_rid) */
 DEFINE_SYSCALL (sys_lock_mutex) {
   int mutex_rid = (int)a1;
-  int vis = (int)a2;
 
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);
+  struct proc_resource* mutex_resource = proc_find_resource (proc->procgroup, mutex_rid);
 
   if (mutex_resource == NULL)
     return -ST_NOT_FOUND;
@@ -237,15 +213,11 @@ DEFINE_SYSCALL (sys_lock_mutex) {
   return ST_OK;
 }
 
-/* int unlock_mutex (int mutex_rid, int vis) */
+/* int unlock_mutex (int mutex_rid) */
 DEFINE_SYSCALL (sys_unlock_mutex) {
   int mutex_rid = (int)a1;
-  int vis = (int)a2;
 
-  if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
-    return -ST_BAD_RESOURCE;
-
-  struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);
+  struct proc_resource* mutex_resource = proc_find_resource (proc->procgroup, mutex_rid);
 
   if (mutex_resource == NULL)
     return -ST_NOT_FOUND;
diff --git a/libmsl/alloc/liballoc.c b/libmsl/alloc/liballoc.c
index 34d0306..941a5a5 100644
--- a/libmsl/alloc/liballoc.c
+++ b/libmsl/alloc/liballoc.c
@@ -8,25 +8,26 @@
 
 static uintptr_t liballoc_map_base = PROC_MAP_BASE;
 static int mem_rid_base = 1000000;
+static int liballoc_mutex;
 
-void liballoc_init (void) { create_mutex (LIBALLOC_MUTEX, RV_PRIVATE); }
+void liballoc_init (void) { liballoc_mutex = create_mutex (LIBALLOC_MUTEX); }
 
-void liballoc_deinit (void) { unlink_mutex (LIBALLOC_MUTEX, RV_PRIVATE); }
+void liballoc_deinit (void) { unlink_mutex (liballoc_mutex); }
 
-int liballoc_lock (void) { return lock_mutex (LIBALLOC_MUTEX, RV_PRIVATE); }
+int liballoc_lock (void) { return lock_mutex (liballoc_mutex); }
 
-int liballoc_unlock (void) { return unlock_mutex (LIBALLOC_MUTEX, RV_PRIVATE); }
+int liballoc_unlock (void) { return unlock_mutex (liballoc_mutex); }
 
 void* liballoc_alloc (int pages, int* mem_rid) {
   uintptr_t current_base = liballoc_map_base;
 
-  *mem_rid = create_mem (mem_rid_base++, RV_PRIVATE, pages);
+  *mem_rid = create_mem (mem_rid_base++, pages);
   if (*mem_rid < 0) {
     return NULL;
   }
 
-  if (map (*mem_rid, RV_PRIVATE, current_base, MAP_FLAGS | MAP_RW) < 0) {
-    unlink_mem (*mem_rid, RV_PRIVATE, pages);
+  if (map (*mem_rid, current_base, MAP_FLAGS | MAP_RW) < 0) {
+    unlink_mem (*mem_rid, pages);
     return NULL;
   }
 
@@ -38,7 +39,7 @@ void* liballoc_alloc (int pages, int* mem_rid) {
 
 int liballoc_free (void* ptr, int pages, int mem_rid) {
   unmap ((uintptr_t)ptr, pages);
-  unlink_mem (mem_rid, RV_PRIVATE, pages);
+  unlink_mem (mem_rid, pages);
   return 0;
 }
 
diff --git a/libmsl/m/system.c b/libmsl/m/system.c
index f50ba90..29e14d2 100644
--- a/libmsl/m/system.c
+++ b/libmsl/m/system.c
@@ -15,28 +15,24 @@ int test (char c) { return do_syscall (SYS_TEST, c); }
 
 int sched (void) { return do_syscall (SYS_SCHED, 0); }
 
-int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) {
-  return do_syscall (SYS_MAP, mem_rid, vis, vaddr, flags);
+int map (int mem_rid, uintptr_t vaddr, uint32_t flags) {
+  return do_syscall (SYS_MAP, mem_rid, vaddr, flags);
 }
 
 int unmap (uintptr_t vaddr, size_t pages) { return do_syscall (SYS_UNMAP, vaddr, pages); }
 
-int create_mem (int mem_rid, int vis, size_t pages) {
-  return do_syscall (SYS_CREATE_MEM, mem_rid, vis, pages);
-}
+int create_mem (int mem_rid, size_t pages) { return do_syscall (SYS_CREATE_MEM, mem_rid, pages); }
 
-int unlink_mem (int mem_rid, int vis, size_t pages) {
-  return do_syscall (SYS_UNLINK_MEM, mem_rid, vis, pages);
-}
+int unlink_mem (int mem_rid, size_t pages) { return do_syscall (SYS_UNLINK_MEM, mem_rid, pages); }
 
 int clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void)) {
   return do_syscall (SYS_CLONE, vstack_top, stack_size, entry);
 }
 
-int create_mutex (int mutex_rid, int vis) { return do_syscall (SYS_CREATE_MUTEX, mutex_rid, vis); }
+int create_mutex (int mutex_rid) { return do_syscall (SYS_CREATE_MUTEX, mutex_rid); }
 
-int unlink_mutex (int mutex_rid, int vis) { return do_syscall (SYS_UNLINK_MUTEX, mutex_rid, vis); }
+int unlink_mutex (int mutex_rid) { return do_syscall (SYS_UNLINK_MUTEX, mutex_rid); }
 
-int lock_mutex (int mutex_rid, int vis) { return do_syscall (SYS_LOCK_MUTEX, mutex_rid, vis); }
+int lock_mutex (int mutex_rid) { return do_syscall (SYS_LOCK_MUTEX, mutex_rid); }
 
-int unlock_mutex (int mutex_rid, int vis) { return do_syscall (SYS_UNLOCK_MUTEX, mutex_rid, vis); }
+int unlock_mutex (int mutex_rid) { return do_syscall (SYS_UNLOCK_MUTEX, mutex_rid); }
diff --git a/libmsl/m/system.h b/libmsl/m/system.h
index 1604dba..58fb5be 100644
--- a/libmsl/m/system.h
+++ b/libmsl/m/system.h
@@ -14,20 +14,17 @@
 #define MAP_USER    (1 << 2)
 #define MAP_FLAGS   (MAP_PRESENT | MAP_USER)
 
-#define RV_PRIVATE 0
-#define RV_PUBLIC  1
-
 int quit (void);
 int test (char c);
 int sched (void);
-int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags);
+int map (int mem_rid, uintptr_t vaddr, uint32_t flags);
 int unmap (uintptr_t vaddr, size_t pages);
-int create_mem (int mem_rid, int vis, size_t pages);
-int unlink_mem (int mem_rid, int vis, size_t pages);
+int create_mem (int mem_rid, size_t pages);
+int unlink_mem (int mem_rid, size_t pages);
 int clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void));
-int create_mutex (int mutex_rid, int vis);
-int unlink_mutex (int mutex_rid, int vis);
-int lock_mutex (int mutex_rid, int vis);
-int unlock_mutex (int mutex_rid, int vis);
+int create_mutex (int mutex_rid);
+int unlink_mutex (int mutex_rid);
+int lock_mutex (int mutex_rid);
+int unlock_mutex (int mutex_rid);
 
 #endif // _LIBMSL_M_SYSTEM_H