From 0a5523f23416b658fb5dd7a6c513e71af21ce122 Mon Sep 17 00:00:00 2001
From: kamkow1 <kamkow256@gmail.com>
Date: Mon, 15 Sep 2025 22:35:15 +0200
Subject: [PATCH] WIP

---
 base/scripts/init.tb            |   3 +-
 kernel/hal/x86_64/vmm.c         |  99 ++++++++++++++++----------------
 kernel/hal/x86_64/vmm.h         |  41 ++++++++-----
 kernel/proc/proc.c              |  79 +++++++++++++++----------
 kernel/proc/proc.h              |   8 ++-
 kernel/syscall/mman.c           |  20 +++++--
 kernel/syscall/processctl.c     |  40 ++++++++++++-
 mk/user/x86_64.mk               |   1 -
 share/sysdefs/processctl.h      |  10 ++++
 ulib/_premain.c                 |   5 +-
 ulib/dlmalloc/dlmalloc_port.inc |  51 ++++------------
 user/arch/x86_64/link.ld        |   2 +-
 user/arch/x86_64/x86_64.mk      |   1 -
 user/init/main.c                |  30 ++++++++--
 user/pctl/Makefile              |  24 ++++++++
 user/pctl/main.c                |  30 ++++++++++
 user/pctl/main.o                | Bin 0 -> 7768 bytes
 user/pctl/pctl                  | Bin 0 -> 35096 bytes
 user/tb/interp.c                |  81 +++++++++++++++++++++-----
 user/tb/interp.h                |   3 +-
 user/tb/main.c                  |  13 ++++-
 user/tb/runtime.c               |  10 ++--
 22 files changed, 374 insertions(+), 177 deletions(-)
 create mode 100644 user/pctl/Makefile
 create mode 100644 user/pctl/main.c
 create mode 100644 user/pctl/main.o
 create mode 100755 user/pctl/pctl

diff --git a/base/scripts/init.tb b/base/scripts/init.tb
index 1528747..0ff3e62 100644
--- a/base/scripts/init.tb
+++ b/base/scripts/init.tb
@@ -1 +1,2 @@
-print "this is an init script!"
+@print "this is an init script!"
+base:/bin/pctl ls
diff --git a/kernel/hal/x86_64/vmm.c b/kernel/hal/x86_64/vmm.c
index 9886977..05656b8 100644
--- a/kernel/hal/x86_64/vmm.c
+++ b/kernel/hal/x86_64/vmm.c
@@ -9,11 +9,11 @@
 #include "kprintf.h"
 #include "spinlock/spinlock.h"
 
-PgTable *KERNEL_CR3 = NULL;
+uint64_t KERNEL_CR3 = 0;
 SpinLock spinlock;
 
-PgTable *hal_vmm_current_cr3(void) {
-  PgTable *cr3;
+uint64_t hal_vmm_current_cr3(void) {
+  uint64_t cr3;
   asm volatile("mov %%cr3, %0" : "=r"(cr3));
   return cr3;
 }
@@ -30,92 +30,93 @@ PgIndex hal_vmm_pageindex(uint64_t vaddr) {
 }
 
 uint64_t *hal_vmm_nexttable(uint64_t *table, uint64_t ent) {
-  uint8_t *addr;
-
-  if (table[ent] & HAL_PG_PRESENT) {
-    addr = (uint8_t *)(table[ent] & ~((uint64_t)0xfff));
+  uint64_t entry = table[ent];
+  uint64_t phys;
+  if (entry & HAL_PG_PRESENT) {
+    phys = entry & ~0xFFFULL;
   } else {
-    addr = pmm_alloc(1);
-    hal_memset(BOOT_INFO.hhdm_off + addr, 0, HAL_PAGE_SIZE);
-    table[ent] = (uint64_t)addr | HAL_PG_USER | HAL_PG_RW | HAL_PG_PRESENT;
+    uint8_t *newphys = pmm_alloc(1);
+    phys = (uint64_t)newphys;
+    hal_memset(VIRT(phys), 0, HAL_PAGE_SIZE);
+    table[ent] = phys | HAL_PG_USER | HAL_PG_RW | HAL_PG_PRESENT;
   }
-
-  return (uint64_t *)(BOOT_INFO.hhdm_off + addr);
+  return (uint64_t *)((uint8_t *)VIRT(phys));
 }
 
-void hal_vmm_map_page(PgTable *pml4, uint64_t virtaddr, uint64_t physaddr, uint32_t flags) {
+void hal_vmm_map_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr, uint32_t flags) {
+  uint64_t *pml4 = (uint64_t *)VIRT(cr3phys);
   PgIndex pi = hal_vmm_pageindex(virtaddr);
 
-  uint64_t *pml3 = hal_vmm_nexttable((uint64_t *)pml4, pi.pml4);
-  uint64_t *pml2 = hal_vmm_nexttable((uint64_t *)pml3, pi.pml3);
-  uint64_t *pml1 = hal_vmm_nexttable((uint64_t *)pml2, pi.pml2);
+  uint64_t *pml3 = hal_vmm_nexttable(pml4, pi.pml4);
+  uint64_t *pml2 = hal_vmm_nexttable(pml3, pi.pml3);
+  uint64_t *pml1 = hal_vmm_nexttable(pml2, pi.pml2);
   uint64_t *pte = &pml1[pi.pml1];
 
-  *pte = (physaddr & ~0xFFF) | (flags & 0x7);
+  *pte = (physaddr & ~0xFFFULL) | ((uint64_t)flags & 0x7ULL);
 }
 
-void hal_vmm_unmap_page(PgTable *pml4, uint64_t virtaddr, uint64_t physaddr) {
+void hal_vmm_unmap_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr) {
+  uint64_t *pml4 = (uint64_t *)VIRT(cr3phys);
   PgIndex pi = hal_vmm_pageindex(virtaddr);
-
-  uint64_t *pml3 = hal_vmm_nexttable((uint64_t *)pml4, pi.pml4);
-  uint64_t *pml2 = hal_vmm_nexttable((uint64_t *)pml3, pi.pml3);
-  uint64_t *pml1 = hal_vmm_nexttable((uint64_t *)pml2, pi.pml2);
+  
+  uint64_t *pml3 = hal_vmm_nexttable(pml4, pi.pml4);
+  uint64_t *pml2 = hal_vmm_nexttable(pml3, pi.pml3);
+  uint64_t *pml1 = hal_vmm_nexttable(pml2, pi.pml2);
   uint64_t *pte = &pml1[pi.pml1];
 
   *pte &= ~HAL_PG_PRESENT;
 }
 
-void hal_vmm_map_range(PgTable *cr3, void *virtstart, void *physstart, size_t size, uint32_t flags) {
-  if (size % HAL_PAGE_SIZE != 0 || (uint64_t)virtstart % HAL_PAGE_SIZE != 0 || (uint64_t)physstart % HAL_PG_PRESENT != 0) {
+void hal_vmm_map_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size, uint32_t flags) {
+  if (size % HAL_PAGE_SIZE != 0 || (uint64_t)virtstart % HAL_PAGE_SIZE != 0 || (uint64_t)physstart % HAL_PAGE_SIZE != 0) {
     return;
   }
 
   spinlock_acquire(&spinlock);
-  uint8_t *vaddr = virtstart, *paddr = physstart;
-
-  for (; vaddr <= ((uint8_t *)virtstart + size); vaddr += HAL_PAGE_SIZE, paddr += HAL_PAGE_SIZE) {
-    hal_vmm_map_page(cr3, (uint64_t)vaddr, (uint64_t)paddr, flags);
+  uint8_t *vaddr = (uint8_t *)virtstart;
+  uint8_t *paddr = (uint8_t *)physstart;
+  uint8_t *end = (uint8_t *)virtstart + size;
+  for (; vaddr < end; vaddr += HAL_PAGE_SIZE, paddr += HAL_PAGE_SIZE) {
+    hal_vmm_map_page(cr3phys, (uint64_t)vaddr, (uint64_t)paddr, flags);
   }
   spinlock_release(&spinlock);
 }
 
-void hal_vmm_unmap_range(PgTable *cr3, void *virtstart, void *physstart, size_t size) {
-  if (size % HAL_PAGE_SIZE != 0 || (uint64_t)virtstart % HAL_PAGE_SIZE != 0 || (uint64_t)physstart % HAL_PG_PRESENT != 0) {
+void hal_vmm_unmap_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size) {
+  if (size % HAL_PAGE_SIZE != 0 || (uint64_t)virtstart % HAL_PAGE_SIZE != 0 || (uint64_t)physstart % HAL_PAGE_SIZE != 0) {
     return;
   }
 
   spinlock_acquire(&spinlock);
-  uint8_t *vaddr = virtstart, *paddr = physstart;
+  uint8_t *vaddr = (uint8_t *)virtstart;
+  uint8_t *paddr = (uint8_t *)physstart;
+  uint8_t *end = vaddr + size;
 
-  for (; vaddr <= ((uint8_t *)virtstart + size); vaddr += HAL_PAGE_SIZE, paddr += HAL_PAGE_SIZE) {
-    hal_vmm_unmap_page(cr3, (uint64_t)vaddr, (uint64_t)paddr);
+  for (; vaddr < end; vaddr += HAL_PAGE_SIZE, paddr += HAL_PAGE_SIZE) {
+    hal_vmm_unmap_page(cr3phys, (uint64_t)vaddr, (uint64_t)paddr);
   }
   spinlock_release(&spinlock);
 }
 
-void hal_vmm_map_kern(PgTable *cr3) {
-  PgTable *kcr3 = BOOT_INFO.hhdm_off + KERNEL_CR3;
+void hal_vmm_map_kern(uint64_t targetcr3) {
+  uint64_t *kcr3 = (uint64_t *)VIRT(KERNEL_CR3);
+  uint64_t *cr3 = (uint64_t *)VIRT(targetcr3);
   for (size_t i = 256; i < 512; i++) {
-    cr3->ents[i] = kcr3->ents[i];
+    cr3[i] = kcr3[i];
   }
 }
 
-void hal_vmm_switch_pd(PgTable *cr3) {
-  hal_loadpd(cr3);
-}
-
-PgTable *hal_vmm_userproc_pml4(Proc *proc) {
-  uint8_t *cr3 = pmm_alloc(1);
-  PgTable *pml4 = (PgTable *)VIRT(cr3);
-  hal_memset(pml4, 0, HAL_PAGE_SIZE);
-  
-  PgTable *kcr3 = VIRT(KERNEL_CR3);
+uint64_t hal_vmm_userproc_pml4_phys(Proc *proc) {
+  uint8_t *cr3phys = pmm_alloc(1);
+  uint64_t phys = (uint64_t)cr3phys;
+  hal_memset(VIRT(phys), 0, HAL_PAGE_SIZE);
 
+  uint64_t *kcr3 = (uint64_t *)VIRT(KERNEL_CR3);
+  uint64_t *pml4 = (uint64_t *)VIRT(phys);
   for (size_t i = 256; i < 512; i++) {
-    pml4->ents[i] = kcr3->ents[i];
+    pml4[i] = kcr3[i];
   }
-
-  return (PgTable *)cr3;
+  return phys;
 }
 
 void hal_vmm_init(void) {
diff --git a/kernel/hal/x86_64/vmm.h b/kernel/hal/x86_64/vmm.h
index 17ba9a0..5f1aa1e 100644
--- a/kernel/hal/x86_64/vmm.h
+++ b/kernel/hal/x86_64/vmm.h
@@ -26,10 +26,14 @@ enum {
 };
 
 typedef struct {
-  uint64_t pml4;
-  uint64_t pml3;
-  uint64_t pml2;
-  uint64_t pml1;
+  uint16_t pml4;
+  uint16_t pml3;
+  uint16_t pml2;
+  uint16_t pml1;
+  /* uint64_t pml4; */
+  /* uint64_t pml3; */
+  /* uint64_t pml2; */
+  /* uint64_t pml1; */
 } PACKED PgIndex;
 
 typedef struct {
@@ -39,25 +43,32 @@ typedef struct {
   bool writethrough: 1;
   bool cachedisabled: 1;
   bool accessed: 1;
-  bool zero0: 1;
-  bool size: 1;
-  bool zero1: 1;
+  bool dirty: 1;
+  bool hugepage: 1;
+  bool global: 1;
   uint8_t avail: 3;
-  uint64_t addr: 52;
+  uint64_t addr: 40;
+  uint16_t osdef: 11;
+  bool nx: 1;
+  /* bool zero0: 1; */
+  /* bool size: 1; */
+  /* bool zero1: 1; */
+  /* uint8_t avail: 3; */
+  /* uint64_t addr: 52; */
 } PACKED Pte;
 
 typedef struct {
   Pte ents[512];
 } PACKED PgTable;
 
-extern PgTable *KERNEL_CR3;
+extern uint64_t KERNEL_CR3;
 
 void hal_vmm_init(void);
-void hal_vmm_unmap_page(PgTable *pml4, uint64_t virtaddr, uint64_t physaddr);
-void hal_vmm_map_page(PgTable *pml4, uint64_t virtaddr, uint64_t physaddr, uint32_t flags);
-PgTable *hal_vmm_current_cr3(void);
-void hal_vmm_map_range(PgTable *cr3, void *virtstart, void *physstart, size_t size, uint32_t flags);
-void hal_vmm_unmap_range(PgTable *cr3, void *virtstart, void *physstart, size_t size);
-PgTable *hal_vmm_userproc_pml4(struct Proc *proc);
+void hal_vmm_unmap_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr);
+void hal_vmm_map_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr, uint32_t flags);
+uint64_t hal_vmm_current_cr3(void);
+void hal_vmm_map_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size, uint32_t flags);
+void hal_vmm_unmap_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size);
+uint64_t hal_vmm_userproc_pml4_phys(struct Proc *proc);
 
 #endif // HAL_VMM_H_
diff --git a/kernel/proc/proc.c b/kernel/proc/proc.c
index 1f49cdc..e6b3fe8 100644
--- a/kernel/proc/proc.c
+++ b/kernel/proc/proc.c
@@ -34,7 +34,6 @@ bool proc_checkelf(uint8_t *elf) {
 }
 
 ElfAuxval proc_load_elf_segs(Proc *proc, uint8_t *data) {
-  PgTable *vas = proc->platformdata.cr3;
   ElfAuxval aux = {0};
 
   Elf64_Ehdr *elfhdr = (Elf64_Ehdr *)data;
@@ -51,16 +50,16 @@ ElfAuxval proc_load_elf_segs(Proc *proc, uint8_t *data) {
       } break;
       case PT_LOAD: {
         uint64_t off = phdr->p_vaddr & (HAL_PAGE_SIZE - 1);
-        uint64_t blocks = (phdr->p_memsz / HAL_PAGE_SIZE) + 1;
+        uint64_t blocks = (off + phdr->p_memsz + HAL_PAGE_SIZE - 1) / HAL_PAGE_SIZE;
 
         uint8_t *physaddr = pmm_alloc(blocks);
-        uint8_t *virtaddr = (uint8_t *)(phdr->p_vaddr - off);
+        uint8_t *virtaddr = (uint8_t *)(phdr->p_vaddr & ~(HAL_PAGE_SIZE - 1));
 
-        hal_memset(VIRT(physaddr), 0, phdr->p_memsz);
+        hal_memset(VIRT(physaddr), 0, blocks * HAL_PAGE_SIZE);
         hal_memcpy(VIRT(physaddr) + off, (data + phdr->p_offset), phdr->p_filesz);
 
         uint32_t pgflags = HAL_PG_USER | HAL_PG_RW | HAL_PG_PRESENT;
-        hal_vmm_map_range(VIRT(vas), virtaddr, physaddr, blocks * HAL_PAGE_SIZE, pgflags);
+        hal_vmm_map_range(proc->platformdata.cr3, virtaddr, physaddr, blocks * HAL_PAGE_SIZE, pgflags);
 
         VasRange *range = dlmalloc(sizeof(*range));
         range->virtstart = virtaddr;
@@ -89,15 +88,15 @@ Proc *proc_spawnkern(void (*ent)(void), char *name) {
 
   proc->kern = true;
 
-  uint8_t *sp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE;
+  uint8_t *pstackp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE;
   uint8_t *kstackp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE;
   proc->platformdata.kstack = kstackp;
-  proc->platformdata.pstack = sp;
+  proc->platformdata.pstack = pstackp;
 
   hal_memset(&proc->platformdata.trapframe, 0, sizeof(proc->platformdata.trapframe));
 
   proc->platformdata.trapframe.ss = 0x10;
-  proc->platformdata.trapframe.rsp = (uint64_t)VIRT(sp);
+  proc->platformdata.trapframe.rsp = (uint64_t)VIRT(pstackp);
   proc->platformdata.trapframe.rflags = 0x202;
   proc->platformdata.trapframe.cs = 0x08;
   proc->platformdata.trapframe.rip = (uint64_t)ent;
@@ -144,31 +143,50 @@ Proc *proc_spawnuser(char *mountpoint, char *path) {
   Proc *proc = dlmalloc(sizeof(*proc));
   hal_memset(proc, 0, sizeof(*proc));
   ksprintf(proc->name, "%s:%s", mountpoint, path);
+  
+  hal_memset(&proc->platformdata.trapframe, 0, sizeof(proc->platformdata.trapframe));
+  proc->platformdata.cr3 = hal_vmm_userproc_pml4_phys(proc);
 
-  uint8_t *sp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE;
-  uint8_t *spbase = sp - PROC_STACKSIZE;
   uint8_t *kstackp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE;
   proc->platformdata.kstack = kstackp;
-  proc->platformdata.pstack = sp;
+  uint8_t *pstackp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS);
+  proc->platformdata.pstack = pstackp;
 
-  hal_memset(&proc->platformdata.trapframe, 0, sizeof(proc->platformdata.trapframe));
-    
-  proc->platformdata.cr3 = hal_vmm_userproc_pml4(proc);
+  uint64_t virttop = PROC_USER_STACK_TOP;
+  uint64_t virtbase = virttop - PROC_STACKSIZE;
 
-  uint32_t flags = HAL_PG_RW | HAL_PG_USER | HAL_PG_PRESENT;
+  uint32_t flags = HAL_PG_RW | HAL_PG_PRESENT | HAL_PG_USER;
+  hal_vmm_map_range(proc->platformdata.cr3, (void *)virtbase, (void *)pstackp, PROC_STACKSIZE, flags);
 
-  hal_vmm_map_range(VIRT(proc->platformdata.cr3), spbase, spbase, PROC_STACKSIZE, flags);
   VasRange *range = dlmalloc(sizeof(*range));
-  range->virtstart = spbase;
-  range->physstart = spbase;
+  range->virtstart = (uint8_t *)virtbase;
+  range->physstart = (uint8_t *)pstackp;
   range->size = PROC_STACKSIZE;
   range->pgflags = flags;
   LL_APPEND(proc->vas, range);
 
+  /* uint8_t *sp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE; */
+  /* uint8_t *spbase = sp - PROC_STACKSIZE; */
+  /* uint8_t *kstackp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE; */
+  /* proc->platformdata.kstack = kstackp; */
+  /* proc->platformdata.pstack = sp; */
+
+    
+
+  /* uint32_t flags = HAL_PG_RW | HAL_PG_USER | HAL_PG_PRESENT; */
+
+  /* hal_vmm_map_range(proc->platformdata.cr3, spbase, spbase, PROC_STACKSIZE, flags); */
+  /* VasRange *range = dlmalloc(sizeof(*range)); */
+  /* range->virtstart = spbase; */
+  /* range->physstart = spbase; */
+  /* range->size = PROC_STACKSIZE; */
+  /* range->pgflags = flags; */
+  /* LL_APPEND(proc->vas, range); */
+
   ElfAuxval aux = proc_load_elf_segs(proc, data);
 
   proc->platformdata.trapframe.ss = 0x20 | 0x3;
-  proc->platformdata.trapframe.rsp = (uint64_t)sp;
+  proc->platformdata.trapframe.rsp = (uint64_t)virttop;
   proc->platformdata.trapframe.rflags = 0x202;
   proc->platformdata.trapframe.cs = 0x18 | 0x3;
   proc->platformdata.trapframe.rip = aux.entry;
@@ -206,6 +224,7 @@ Proc *proc_nextready(void) {
 }
 
 void proc_reaper(void) {
+  spinlock_acquire(&PROCS.spinlock);
   Proc *head = PROCS.procs;
   while (head) {
     if (head->state == PROC_ZOMBIE) {
@@ -221,13 +240,13 @@ void proc_reaper(void) {
         }
       }
 
-      /* for (size_t i = 0; i < PROC_PIPEHANDLES_MAX; i++) { */
-      /*   if (zombie->pipes[i] != NULL && zombie->pipes[i]->ownerpid == zombie->pid) { */
-      /*     dlfree(zombie->pipes[i]); */
-      /*     ipc_pipefree(zombie->pipes[i]); */
-      /*     zombie->pipes[i] = NULL; */
-      /*   } */
-      /* } */
+      for (size_t i = 0; i < PROC_PIPEHANDLES_MAX; i++) {
+        if (zombie->pipes[i] != NULL && zombie->pipes[i]->ownerpid == zombie->pid) {
+          dlfree(zombie->pipes[i]);
+          ipc_pipefree(zombie->pipes[i]);
+          zombie->pipes[i] = NULL;
+        }
+      }
 
       pmm_free((uintptr_t)(zombie->platformdata.kstack - PROC_STACKSIZE), PROC_STACKBLOCKS);
       pmm_free((uintptr_t)(zombie->platformdata.pstack - PROC_STACKSIZE), PROC_STACKBLOCKS);
@@ -238,11 +257,8 @@ void proc_reaper(void) {
         while (vashead) {
           VasRange *tmp = vashead;
           vashead = vashead->next;
-          hal_vmm_unmap_range(VIRT(zombie->platformdata.cr3), tmp->virtstart, tmp->physstart, tmp->size);
-          // first pmm mapping is for the elf itself
-          if (i == 0) {
-            pmm_free((uintptr_t)tmp->physstart, tmp->size / HAL_PAGE_SIZE);
-          }
+          hal_vmm_unmap_range(zombie->platformdata.cr3, tmp->virtstart, tmp->physstart, tmp->size);
+          pmm_free((uintptr_t)tmp->physstart, tmp->size / HAL_PAGE_SIZE);
           dlfree(tmp);
           i++;
         }
@@ -262,6 +278,7 @@ void proc_reaper(void) {
       head = head->next;
     }
   }
+  spinlock_release(&PROCS.spinlock);
 }
 
 void proc_sched(void *cpustate) {
diff --git a/kernel/proc/proc.h b/kernel/proc/proc.h
index 9d3ec70..b88237b 100644
--- a/kernel/proc/proc.h
+++ b/kernel/proc/proc.h
@@ -11,7 +11,7 @@
 
 #define PROC_NAME_MAX 0x100
 
-#define PROC_STACKBLOCKS 32
+#define PROC_STACKBLOCKS 256
 #define PROC_STACKSIZE (PROC_STACKBLOCKS * BITMAP_BLOCK_SIZE)
 
 #define PROC_MAX 0x100 // max amount of processes
@@ -19,13 +19,14 @@
 #define PROC_VFSHANDLES_MAX   0x80
 #define PROC_PIPEHANDLES_MAX  0x20
 
-#define PROC_MMAN_MAP_BASE 0xC000000000
+#define PROC_MMAN_MAP_BASE 0x0000004000000000ULL
+#define PROC_USER_STACK_TOP 0x00007ffffffff000ULL
 
 typedef struct {
   IntrStackFrame trapframe;
   uint8_t *kstack;
   uint8_t *pstack;
-  PgTable *cr3;
+  uint64_t cr3;
 } ProcPlatformData;
 
 enum {
@@ -33,6 +34,7 @@ enum {
   PROC_READY = 1,
   PROC_ZOMBIE = 2,
   PROC_WAITING = 3,
+  PROC_DIED = 4,
 };
 
 typedef struct ProcArg {
diff --git a/kernel/syscall/mman.c b/kernel/syscall/mman.c
index 5b59721..4cc580c 100644
--- a/kernel/syscall/mman.c
+++ b/kernel/syscall/mman.c
@@ -18,7 +18,7 @@ int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
   uint64_t flags = flags1;
   uint8_t **out = (uint8_t **)out1;
 
-  if (size % HAL_PAGE_SIZE != 0) {
+  if (size == 0 || (size % HAL_PAGE_SIZE != 0)) {
     if (out != NULL) {
       *out = NULL;
     }
@@ -37,11 +37,19 @@ int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
   spinlock_release(&PROCS.spinlock);
 
   uint8_t *virt = NULL;
-  if (flags & MMAN_MAP_F_FIXED && addr != NULL) {
+  if ((flags & MMAN_MAP_F_FIXED) && addr != NULL) {
+    if ((uintptr_t)addr % HAL_PAGE_SIZE != 0) {
+      if (out != NULL) {
+        *out = NULL;
+      }
+      pmm_free((uintptr_t)phys, pages);
+      return E_INVALIDARGUMENT;
+    }
+
     virt = addr;
   } else {
     virt = (uint8_t *)proc->mman_map_base;
-    proc->mman_map_base += size;
+    proc->mman_map_base += pages * HAL_PAGE_SIZE;
   }
 
   uint64_t pflags = HAL_PG_USER | HAL_PG_PRESENT;
@@ -49,11 +57,11 @@ int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
     pflags |= HAL_PG_RW;
   }
 
-  hal_vmm_map_range(VIRT(proc->platformdata.cr3), virt, phys, size, pflags);
+  hal_vmm_map_range(proc->platformdata.cr3, virt, phys, pages * HAL_PAGE_SIZE, pflags);
   VasRange *range = dlmalloc(sizeof(*range));
   range->virtstart = virt;
   range->physstart = phys;
-  range->size = size * HAL_PAGE_SIZE;
+  range->size = pages * HAL_PAGE_SIZE;
   range->pgflags = pflags;
   LL_APPEND(proc->vas, range);
 
@@ -91,7 +99,7 @@ int32_t SYSCALL1(sys_mman_unmap, addr1) {
     return E_INVALIDARGUMENT;
   }
 
-  hal_vmm_unmap_range(VIRT(proc->platformdata.cr3), tofree->virtstart, tofree->physstart, tofree->size);
+  hal_vmm_unmap_range(proc->platformdata.cr3, tofree->virtstart, tofree->physstart, tofree->size);
   LL_REMOVE(proc->vas, tofree);
   pmm_free((uintptr_t)tofree->physstart, tofree->size / HAL_PAGE_SIZE);
   dlfree(tofree);
diff --git a/kernel/syscall/processctl.c b/kernel/syscall/processctl.c
index 0785379..310c60b 100644
--- a/kernel/syscall/processctl.c
+++ b/kernel/syscall/processctl.c
@@ -29,7 +29,7 @@ int32_t SYSCALL5(sys_processctl, pid1, cmd1, arg1, arg2, arg3) {
 
   if (proc == NULL) {
     if (cmd == PCTL_POLLSTATE) {
-      ret = 2;
+      ret = PROC_DIED;
       goto done;
     }
     ret = E_INVALIDARGUMENT;
@@ -104,6 +104,44 @@ int32_t SYSCALL5(sys_processctl, pid1, cmd1, arg1, arg2, arg3) {
       }
       ret = E_OK;
     } break;
+    case PCTL_PLS_SZ: {
+      size_t i = 0;
+      spinlock_acquire(&PROCS.spinlock);
+      Proc *p = PROCS.procs;
+      while (p) {
+        i++;
+        p = p->next;
+      }
+      spinlock_release(&PROCS.spinlock);
+      ret = i;
+    } break;
+    case PCTL_PLS_STAT: {
+      uint64_t pidx = arg1;
+      ProcStat *stat = (ProcStat *)arg2;
+      
+      if (stat == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      size_t i = 0;
+      spinlock_acquire(&PROCS.spinlock);
+      Proc *p = PROCS.procs;
+      while (p) {
+        if (i == pidx) {
+          stat->pid = p->pid;
+          hal_strcpy(stat->name, p->name);
+          stat->state = p->state;
+          stat->kern = p->kern;
+          break;
+        }
+
+        i++;
+        p = p->next;
+      }
+      spinlock_release(&PROCS.spinlock);
+      ret = E_OK;
+    } break;
     default: {
       ret = E_INVALIDARGUMENT;
     } break;
diff --git a/mk/user/x86_64.mk b/mk/user/x86_64.mk
index 8379193..9b7bf51 100644
--- a/mk/user/x86_64.mk
+++ b/mk/user/x86_64.mk
@@ -1,5 +1,4 @@
 CFLAGS += -m64 \
-					-fPIE \
 					-mno-80387 \
 					-mno-mmx \
 					-mno-sse \
diff --git a/share/sysdefs/processctl.h b/share/sysdefs/processctl.h
index fd62551..cde07fd 100644
--- a/share/sysdefs/processctl.h
+++ b/share/sysdefs/processctl.h
@@ -11,6 +11,16 @@ enum {
   PCTL_GETPID     = 4,
   PCTL_ARGLEN     = 5,
   PCTL_ARGV       = 6,
+  PCTL_PLS_SZ     = 7,
+  PCTL_PLS_STAT   = 8,
 };
 
+typedef struct {
+  uint64_t pid;
+  char name[0x100];
+  uint8_t state;
+  size_t usemem;
+  bool kern;
+} ProcStat;
+
 #endif // SHARE_HDRS_PROCESSCTL_H_
diff --git a/ulib/_premain.c b/ulib/_premain.c
index cbd5e15..6e41e27 100644
--- a/ulib/_premain.c
+++ b/ulib/_premain.c
@@ -8,11 +8,10 @@
 #include <log.h>
 
 extern void main(void);
+extern uint8_t _bss_start;
+extern uint8_t _bss_end;
 
 void clearbss(void) {
-  extern uint8_t _bss_start;
-  extern uint8_t _bss_end;
-
   uint8_t *ps = &_bss_start;
   uint8_t *pe = &_bss_end;
   size_t sz = pe - ps;
diff --git a/ulib/dlmalloc/dlmalloc_port.inc b/ulib/dlmalloc/dlmalloc_port.inc
index 8ada055..9f222b4 100644
--- a/ulib/dlmalloc/dlmalloc_port.inc
+++ b/ulib/dlmalloc/dlmalloc_port.inc
@@ -46,7 +46,7 @@ int RELEASE_LOCK(SpinLock *sl) {
 }
 
 int INITIAL_LOCK(SpinLock *sl) {
-  spinlock_release(sl);
+  spinlock_init(sl);
   return 0;
 }
     
@@ -79,12 +79,17 @@ void *sbrk(ptrdiff_t inc) {
     return heap_end;
   }
 
-  uint8_t *oldh = heap_end;
-  uint8_t *newh = heap_end + inc;
+  uint8_t *oldbrk = heap_end;
+  uint8_t *newbrk = heap_end + inc;
+
+  if (newbrk < heap_start) {
+    return (void *)-1;
+  }
 
   if (inc > 0) {
-    if (newh > heap_commit) {
-      size_t extra = _roundpage((size_t)(newh - heap_commit));
+    if (newbrk > heap_commit) {
+      size_t need = (size_t)(newbrk - heap_commit);
+      size_t extra = _roundpage(need);
       uint8_t *maddr = NULL;
       int32_t ret = mman_map(NULL, extra, MMAN_MAP_PF_RW, 0, &maddr);
       if (ret != E_OK || maddr == NULL) {
@@ -92,39 +97,7 @@ void *sbrk(ptrdiff_t inc) {
       }
       heap_commit += extra;
     }
-    heap_end = newh;
-  } else {
-    heap_end = newh;
   }
-  return oldh;
-
-  #if 0
-  if (!heap_end) {
-    heap_end = heap_start;
-  }
-
-  if (inc == 0) {
-    return heap_end;
-  }
-
-  uint8_t *oldh = heap_end;
-  uint8_t *newh = heap_end + inc;
-
-  if (inc > 0) {
-    size_t allocsz = _roundpage((size_t)(newh - oldh));
-    uint8_t *maddr = NULL;
-    int32_t ret = mman_map(NULL, allocsz, MMAN_MAP_PF_RW, 0, &maddr);
-    if (ret != E_OK || maddr == NULL) {
-      return (void *)-1;
-    }
-    if (!heap_start) {
-      heap_start = maddr;
-    }
-    oldh = heap_end ? heap_end : maddr;
-    heap_end = oldh + allocsz;
-  } else {
-    heap_end = newh;
-  }
-  return oldh;
-  #endif
+  heap_end = newbrk;
+  return (void *)oldbrk;
 }
diff --git a/user/arch/x86_64/link.ld b/user/arch/x86_64/link.ld
index f3f72b5..5f7ec45 100644
--- a/user/arch/x86_64/link.ld
+++ b/user/arch/x86_64/link.ld
@@ -1,7 +1,7 @@
 ENTRY(_start)
 
 SECTIONS {
-  /* . = 0x0000000000000000; */
+  . = 0x400000;
 
   .text ALIGN(4K):
   {
diff --git a/user/arch/x86_64/x86_64.mk b/user/arch/x86_64/x86_64.mk
index ceee098..79c7562 100644
--- a/user/arch/x86_64/x86_64.mk
+++ b/user/arch/x86_64/x86_64.mk
@@ -2,7 +2,6 @@ include $(ROOT)/mk/user/x86_64.mk
 include $(ROOT)/mk/arch/toolchain-x86_64.mk
 
 LDFLAGS += -m elf_x86_64 \
-					-pie \
 					--no-dynamic-linker \
 					-z text \
 					-z max-page-size=0x1000
diff --git a/user/init/main.c b/user/init/main.c
index 59a366a..606516a 100644
--- a/user/init/main.c
+++ b/user/init/main.c
@@ -7,18 +7,37 @@
 #include <ansiq/all.h>
 #include <string/char.h>
 #include <util/util.h>
+#include <dlmalloc/malloc.h>
+
+#define SUBPROC_PIPE_OUT 0x1f
+
+uint64_t PID;
 
 void main(void) {
+  PID = (uint64_t)processctl(-1, PCTL_GETPID, 0, 0, 0);
+
+  ipcpipe(PID, SUBPROC_PIPE_OUT, IPCPIPE_MAKE, NULL, 0);
+
   char *tbargs[] = { "-m", "runfile", "-f", "base:/scripts/init.tb" };
   int32_t tb = processctl(-1, PCTL_SPAWN, (uint64_t)"base:/bin/tb", (uint64_t)&tbargs, ARRLEN(tbargs));
-  uint64_t selfpid = (uint64_t)processctl(-1, PCTL_GETPID, 0, 0, 0);
-  ipcpipe(tb, IPCPIPE_OUT, IPCPIPE_REPLACE, (uint8_t *)selfpid, IPCPIPE_OUT);
-  processctl(tb, PCTL_RUN, 0, 0, 0);
+  ipcpipe(tb, IPCPIPE_OUT, IPCPIPE_REPLACE, (uint8_t *)PID, SUBPROC_PIPE_OUT);
 
   ipcpipe(IPCPIPE_SELFPID, 10, IPCPIPE_MAKE, NULL, 0);
   ipcpipe(IPCPIPE_SELFPID, 10, IPCPIPE_ADD_BCAST, NULL, 1);
+  
+  processctl(tb, PCTL_RUN, 0, 0, 0);
 
-  while(processctl(tb, PCTL_POLLSTATE, 0, 0, 0) != 2) {
+  #define OUTBUF_MAX 1024
+  char *outbuf = dlmalloc(1024);
+
+  while(processctl(tb, PCTL_POLLSTATE, 0, 0, 0) != 4) {
+    string_memset(outbuf, 0, OUTBUF_MAX);
+    int32_t nrd = ipcpipe(PID, SUBPROC_PIPE_OUT, IPCPIPE_READ, (uint8_t *)outbuf, sizeof(outbuf));
+    if (nrd > 0) {
+      uprintf("%s", outbuf);
+    }
+
+#if 0
     int32_t kbchr;
     int32_t read = ipcpipe(IPCPIPE_SELFPID, 10, IPCPIPE_READ, (uint8_t *)&kbchr, sizeof(kbchr));
     if (read > 0) {
@@ -32,6 +51,9 @@ void main(void) {
         }
       }
     }
+#endif
   }
+
+  for(;;);
 }
 
diff --git a/user/pctl/Makefile b/user/pctl/Makefile
new file mode 100644
index 0000000..0d1b960
--- /dev/null
+++ b/user/pctl/Makefile
@@ -0,0 +1,24 @@
+include $(ROOT)/mk/grabsrc.mk
+include ../Makefile.inc
+
+.PHONY: all clean
+
+TARGET := pctl
+
+LDFLAGS += -L$(ROOT)/ulib -l:libulib.a
+
+SRCFILES := $(call GRABSRC, .)
+CFILES := $(call GET_CFILES, $(SRCFILES))
+OBJ := $(call GET_OBJ, $(SRCFILES))
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(LD) $^ $(LDFLAGS) -o $@
+	echo $$(realpath $(TARGET)) >> $(FILES)
+
+clean:
+	rm -f $(OBJ) $(TARGET)
diff --git a/user/pctl/main.c b/user/pctl/main.c
new file mode 100644
index 0000000..ec0eb95
--- /dev/null
+++ b/user/pctl/main.c
@@ -0,0 +1,30 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <system/system.h>
+#include <sysdefs/processctl.h>
+#include <uprintf.h>
+#include <args/args.h>
+#include <string/string.h>
+#include <util/util.h>
+#include <errors.h>
+
+void main(void) {
+  if (argslen() == 0) {
+    return;
+  }
+
+  char *cmd = args()[0];
+
+  if (string_strcmp(cmd, "ls") == 0) {
+    uint64_t procslen = processctl(-1, PCTL_PLS_SZ, 0, 0, 0);
+    for (size_t i = 0; i < procslen; i++) {
+      ProcStat stat = ZERO(&stat);
+      int32_t r = processctl(-1, PCTL_PLS_STAT, i, (uint64_t)&stat, 0);
+      if (r == E_OK) {
+        uprintf("%-30s %lu %-6s\n", stat.name, stat.pid, stat.kern ? "KERNEL" : "USER");
+      }
+    }
+  } else {
+    uprintf("pctl: unknown command\n");
+  }
+}
diff --git a/user/pctl/main.o b/user/pctl/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..2bdef2c498bd1cc039fe1356406415ada90caa4e
GIT binary patch
literal 7768
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
T2-Hy(pM%Fw{$E4<>G=NvTXOMo

literal 0
HcmV?d00001

diff --git a/user/pctl/pctl b/user/pctl/pctl
new file mode 100755
index 0000000000000000000000000000000000000000..56c0d4a596f732dc33e2d7c2ff667d82dc07914f
GIT binary patch
literal 35096
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

literal 0
HcmV?d00001

diff --git a/user/tb/interp.c b/user/tb/interp.c
index 87cfc0a..2afab06 100644
--- a/user/tb/interp.c
+++ b/user/tb/interp.c
@@ -5,10 +5,17 @@
 #include <string/char.h>
 #include <linklist.h>
 #include <dlmalloc/malloc.h>
+#include <system/system.h>
+#include <sysdefs/processctl.h>
+#include <sysdefs/ipcpipe.h>
 #include <uprintf.h>
 #include "interp.h"
 #include "runtime.h"
 
+#define SUBPROC_PIPE_OUT 0x1f
+
+extern uint64_t PID;
+
 static InterpResult RES;
 
 void tz_init(Tokenizer *tz, const char *str, size_t len) {
@@ -62,7 +69,7 @@ void tz_classify(Tokenizer *tz) {
   while (tk) {
     if (tk->ptr[0] == '"' && tk->ptr[tk->len - 1] == '"') {
       tk->type = TOK_STRING;
-    } else {
+    } else if (tk->ptr[0] == '@') {
       RtCmd *cmd = RTCMDS;
       while (cmd) {
         char tmpbuf[0xff] = {0};
@@ -74,6 +81,8 @@ void tz_classify(Tokenizer *tz) {
         }
         cmd = cmd->next;
       }
+    } else {
+      tk->type = TOK_MISC;
     }
     tk = tk->next;
   }
@@ -132,8 +141,9 @@ bool interp_readline(char *data, const char **bgptr, const char **endptr) {
   return true;
 }
 
-bool interp_runstring(const char *string, size_t len, InterpResult **res) {
+bool interp_runstring(const char *string, InterpResult **res) {
   *res = &RES;
+  string_memset(RES.errmsg, 0, sizeof(RES.errmsg));
   
   rt_init();
   bool ok = true;
@@ -156,19 +166,62 @@ bool interp_runstring(const char *string, size_t len, InterpResult **res) {
     tz_classify(&tz);
 
     Token *cmdtk = tz.tokens;
-    if (cmdtk->type != TOK_CMD) {
-      ok = false;
-      usprintf(RES.errmsg, "Expected cmd name, but got %.*s", (int)cmdtk->len, cmdtk->ptr);
-      tz_free(&tz);
-      goto done;
-    }
+    if (cmdtk->type == TOK_CMD) {
+      ok = cmdtk->cmd->fn(cmdtk->next);
+      if (!ok) {
+        ok = false;
+        usprintf(RES.errmsg, "cmd %.*s failed", (int)cmdtk->len, cmdtk->ptr);
+        tz_free(&tz);
+        goto done;
+      }
+    } else if (cmdtk->type == TOK_MISC) {
+      char *appname = dlmalloc(1024);
+      usprintf(appname, "%.*s", (int)cmdtk->len, cmdtk->ptr);
 
-    ok = cmdtk->cmd->fn(cmdtk->next);
-    if (!ok) {
-      ok = false;
-      usprintf(RES.errmsg, "cmd %.*s failed", (int)cmdtk->len, cmdtk->ptr);
-      tz_free(&tz);
-      goto done;
+      size_t argslen1 = 0;
+      Token *argtk = cmdtk->next;
+      while (argtk) {
+        argslen1++;
+        argtk = argtk->next;
+      }
+      
+      char **args1 = (char **)dlmalloc(sizeof(char *) * argslen1);
+      argtk = cmdtk->next;
+      size_t i = 0;
+      while (argtk) {
+        args1[i] = (char *)dlmalloc(PROC_ARG_MAX);
+        string_memset(args1[i], 0, PROC_ARG_MAX);
+        string_memcpy(args1[i], argtk->ptr, argtk->len);
+        i++;
+        argtk = argtk->next;
+      }
+
+      #define OUTBUF_MAX 1024
+      char *outbuf = dlmalloc(OUTBUF_MAX);
+
+      ipcpipe(PID, SUBPROC_PIPE_OUT, IPCPIPE_MAKE, NULL, 0);
+
+      int32_t app = processctl(-1, PCTL_SPAWN, (uint64_t)(char *)appname, (uint64_t)args1, argslen1);
+      ipcpipe(app, IPCPIPE_OUT, IPCPIPE_REPLACE, (uint8_t *)PID, SUBPROC_PIPE_OUT);
+      ipcpipe(app, IPCPIPE_IN, IPCPIPE_READ, (uint8_t *)PID, IPCPIPE_IN);
+      processctl(app, PCTL_RUN, 0, 0, 0);
+
+      while (processctl(app, PCTL_POLLSTATE, 0, 0, 0) != 4) {
+        string_memset(outbuf, 0, OUTBUF_MAX);
+        int32_t nrd = ipcpipe(PID, SUBPROC_PIPE_OUT, IPCPIPE_READ, (uint8_t *)outbuf, sizeof(outbuf));
+        if (nrd > 0) {
+          uprintf("%s", outbuf);
+        }
+      }
+
+      dlfree(outbuf);
+
+      for (size_t j = 0; j < argslen1; j++) {
+        dlfree(args1[j]);
+      }
+      dlfree(args1);
+
+      dlfree(appname);
     }
 
     tz_free(&tz);
diff --git a/user/tb/interp.h b/user/tb/interp.h
index 28cb826..01c5537 100644
--- a/user/tb/interp.h
+++ b/user/tb/interp.h
@@ -19,6 +19,7 @@ typedef struct Token {
   enum {
     TOK_STRING,
     TOK_CMD,
+    TOK_MISC,
   } type;
 
   struct RtCmd *cmd;
@@ -32,6 +33,6 @@ typedef struct {
   Token *tokens;
 } Tokenizer;
 
-bool interp_runstring(const char *string, size_t len, InterpResult **res);
+bool interp_runstring(const char *string, InterpResult **res);
 
 #endif // TB_INTERP_H_
diff --git a/user/tb/main.c b/user/tb/main.c
index eb76bc4..169eaba 100644
--- a/user/tb/main.c
+++ b/user/tb/main.c
@@ -15,6 +15,8 @@
 #include <util/util.h>
 #include "interp.h"
 
+uint64_t PID;
+
 struct {
   char *modestr;
   enum { MODE_INTERACTIVE = 1, MODE_RUNFILE = 2 } mode;
@@ -68,7 +70,8 @@ void do_file(char *filepath) {
     LOG(LOG_ERR, "%s is not a file (%d)\n", filepath, statbuf.type);
     return;
   }
-  uint8_t *buf = dlmalloc(statbuf.size);
+  uint8_t *buf = dlmalloc(statbuf.size+1);
+  string_memset(buf, 0, statbuf.size+1);
 
   if ((ret = ioctl(ioh, IOCTL_READ, (uint64_t)buf, statbuf.size, 0)) < 0) {
     LOG(LOG_ERR, "Could not read %s (%d): %s\n", filepath, ioh, ERRSTRING(ioh));
@@ -76,7 +79,7 @@ void do_file(char *filepath) {
   }
 
   InterpResult *res;
-  bool ok = interp_runstring((const char *)buf, statbuf.size, &res);
+  bool ok = interp_runstring((const char *)buf, &res);
   if (!ok) {
     uprintf("Interpreter error:\n");
     uprintf("%s\n", res->errmsg);
@@ -105,10 +108,16 @@ void do_mode_interactive(void) {
     }
     linebuf[cursor - 1] = '\0';
     uprintf("\n");
+    InterpResult *res;
+    if (!interp_runstring(linebuf, &res)) {
+      LOG(LOG_ERR, "%s\n", res->errmsg);
+    }
   }
 }
 
 void main(void) {
+  PID = processctl(-1, PCTL_GETPID, 0, 0, 0);
+
   set_config();
 
   if (CONFIG.mode == MODE_INTERACTIVE) {
diff --git a/user/tb/runtime.c b/user/tb/runtime.c
index 4957b71..769e0e1 100644
--- a/user/tb/runtime.c
+++ b/user/tb/runtime.c
@@ -8,11 +8,11 @@
 
 RtCmd *RTCMDS = NULL;
 
-#define RTCMD(name) \
+#define RTCMD(name, _fn) \
   do { \
     RtCmd *_cmd = dlmalloc(sizeof(*_cmd)); \
-    _cmd->cmdname = #name; \
-    _cmd->fn = rt_##name; \
+    _cmd->cmdname = (name); \
+    _cmd->fn = (_fn); \
     LL_APPEND(RTCMDS, _cmd); \
   } while(0)
 
@@ -25,10 +25,10 @@ bool rt_print(Token *tks) {
     }
     tk = tk->next;
   }
-
+  uprintf("\n");
   return true;
 }
 
 void rt_init(void) {
-  RTCMD(print);
+  RTCMD("@print", &rt_print);
 }