kamkow1/mop3
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Organize resources into process groups

Browse Source
This commit is contained in:
Kamil Kowalczyk
2026-01-27 14:18:05 +01:00
parent 67b66f2b39
commit 600886a7ee
20 changed files with 387 additions and 457 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
init/init.c
View File

@@ -6,14 +6,13 @@
#include <stdint.h> #include <stdint.h>
#include <string/string.h> #include <string/string.h>
#define EXAMPLE 3 #define EXAMPLE 1
#if EXAMPLE == 1 #if EXAMPLE == 1
void app_thread1 (void) { #define MUTEX 2000
test ('b');
quit (); void app_thread1 (void);
}
int spawn (void (*fn) (void)) { int spawn (void (*fn) (void)) {
size_t stack_size = 256 * PAGE_SIZE; size_t stack_size = 256 * PAGE_SIZE;
@@ -25,7 +24,29 @@ int spawn (void (*fn) (void)) {
return clone (stack_top, stack_size, fn); 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 #elif EXAMPLE == 2
#define MUTEX 2000 #define MUTEX 2000
@@ -43,28 +64,28 @@ int spawn (void (*fn) (void)) {
} }
void app_main (void) { void app_main (void) {
create_mutex (MUTEX, RV_PRIVATE); create_mutex (MUTEX);
spawn (&app_thread1); spawn (&app_thread1);
for (;;) { for (;;) {
lock_mutex (MUTEX, RV_PRIVATE); lock_mutex (MUTEX);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
test ('a'); test ('a');
unlock_mutex (MUTEX, RV_PRIVATE); unlock_mutex (MUTEX);
} }
} }
void app_thread1 (void) { void app_thread1 (void) {
for (;;) { for (;;) {
lock_mutex (MUTEX, RV_PRIVATE); lock_mutex (MUTEX);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
test ('b'); test ('b');
unlock_mutex (MUTEX, RV_PRIVATE); unlock_mutex (MUTEX);
} }
quit (); quit ();
@@ -86,12 +107,12 @@ int spawn (void (*fn) (void)) {
} }
void app_main (void) { void app_main (void) {
create_mutex (MUTEX, RV_PRIVATE); create_mutex (MUTEX);
spawn (&app_thread1); spawn (&app_thread1);
for (;;) { for (;;) {
lock_mutex (MUTEX, RV_PRIVATE); lock_mutex (MUTEX);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
test ('a'); test ('a');
@@ -102,12 +123,12 @@ void app_main (void) {
void app_thread1 (void) { void app_thread1 (void) {
for (;;) { for (;;) {
lock_mutex (MUTEX, RV_PRIVATE); lock_mutex (MUTEX);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
test ('b'); test ('b');
unlock_mutex (MUTEX, RV_PRIVATE); unlock_mutex (MUTEX);
} }
quit (); quit ();

1
kernel/amd64/mm.h
View File

@@ -9,7 +9,6 @@
struct pd { struct pd {
spin_lock_t lock; spin_lock_t lock;
uintptr_t cr3_paddr; uintptr_t cr3_paddr;
atomic_int refs;
}; };
void amd64_load_kernel_cr3 (void); void amd64_load_kernel_cr3 (void);

131
kernel/amd64/proc.c
View File

@@ -9,6 +9,7 @@
#include <mm/liballoc.h> #include <mm/liballoc.h>
#include <mm/pmm.h> #include <mm/pmm.h>
#include <proc/proc.h> #include <proc/proc.h>
#include <proc/procgroup.h>
#include <proc/resource.h> #include <proc/resource.h>
#include <sync/rw_spin_lock.h> #include <sync/rw_spin_lock.h>
#include <sync/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); atomic_store (&proc->state, PROC_READY);
proc->pid = atomic_fetch_add (&pids, 1); proc->pid = atomic_fetch_add (&pids, 1);
proc->resources = malloc (sizeof (*proc->resources)); proc->procgroup = procgroup_create ();
if (proc->resources == NULL) { if (proc->procgroup == NULL) {
free (proc); free (proc);
return NULL; return NULL;
} }
proc->resources->tree = NULL; procgroup_attach (proc->procgroup, proc);
proc->resources->lock = RW_SPIN_LOCK_INIT;
proc->resources->refs = 1;
proc->resources->sys_rids = 0;
proc->pd = malloc (sizeof (*proc->pd)); rid = procgroup_get_sys_rid (proc->procgroup);
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);
struct proc_resource* kstk_r = 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) { if (kstk_r == NULL) {
pmm_free (proc->pd->cr3_paddr, 1); procgroup_detach (proc->procgroup, proc);
free (proc->pd);
free (proc->resources);
free (proc); free (proc);
return NULL; return NULL;
} }
proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE; 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, rid = procgroup_get_sys_rid (proc->procgroup);
.managed = false};
rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
struct proc_resource* ustk_r = 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) { if (ustk_r == NULL) {
kstk_r->ops.cleanup (proc, kstk_r); kstk_r->ops.cleanup (kstk_r);
free (kstk_r); free (kstk_r);
pmm_free (proc->pd->cr3_paddr, 1); procgroup_detach (proc->procgroup, proc);
free (proc->pd);
free (proc->resources);
free (proc); free (proc);
return NULL; 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, struct proc* proc_clone (struct proc* proto, uintptr_t vstack_top, size_t stack_size,
uintptr_t entry) { uintptr_t entry) {
struct limine_hhdm_response* hhdm = limine_hhdm_request.response; struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
spin_lock_ctx_t ctxprt, ctxrs; spin_lock_ctx_t ctxprt;
int rid; int rid;
struct proc* proc = malloc (sizeof (*proc)); 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); spin_lock (&proto->lock, &ctxprt);
proc->pd = proto->pd; proc->procgroup = proto->procgroup;
proc->mappings = proto->mappings; procgroup_attach (proc->procgroup, proc);
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);
spin_unlock (&proto->lock, &ctxprt); spin_unlock (&proto->lock, &ctxprt);
uintptr_t vstack_bottom = vstack_top - stack_size; 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) { if (pstack_bottom == 0) {
procgroup_detach (proc->procgroup, proc);
free (proc); free (proc);
return NULL; return NULL;
} }
struct proc_resource_mem_init kstk_mem_init = {.pages = KSTACK_SIZE / PAGE_SIZE, rid = procgroup_get_sys_rid (proc->procgroup);
.managed = false};
rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
struct proc_resource* kstk_r = 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) { if (kstk_r == NULL) {
procgroup_detach (proc->procgroup, proc);
free (proc); free (proc);
return NULL; 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) { void proc_cleanup (struct proc* proc) {
struct limine_hhdm_response* hhdm = limine_hhdm_request.response; spin_lock_ctx_t ctxsq, ctxpr;
spin_lock_ctx_t ctxprpd, ctxsq, ctxpr;
spin_lock (&proc->lock, &ctxpr); spin_lock (&proc->lock, &ctxpr);
@@ -209,37 +159,26 @@ void proc_cleanup (struct proc* proc) {
spin_unlock (&proc->lock, &ctxpr); spin_unlock (&proc->lock, &ctxpr);
/* clean resources */ procgroup_detach (proc->procgroup, proc);
proc_cleanup_resources (proc);
/* clean virtual address space */ /* clean virtual address space */
if (atomic_fetch_sub (&proc->pd->refs, 1) == 1) { /* if (atomic_fetch_sub (&proc->pd->refs, 1) == 1) { */
DEBUG ("PID %d Free virtual address space\n", proc->pid); /* DEBUG ("PID %d Free virtual address space\n", proc->pid); */
struct list_node_link *mapping_link, *mapping_link_tmp; /* struct list_node_link *mapping_link, *mapping_link_tmp; */
spin_lock (&proc->pd->lock, &ctxprpd); /* spin_lock (&proc->pd->lock, &ctxprpd); */
list_foreach (proc->mappings, mapping_link, mapping_link_tmp) { /* list_foreach (proc->mappings, mapping_link, mapping_link_tmp) { */
struct proc_mapping* mapping = /* struct proc_mapping* mapping = */
list_entry (mapping_link, struct proc_mapping, proc_mappings_link); /* list_entry (mapping_link, struct proc_mapping, proc_mappings_link); */
list_remove (proc->mappings, mapping_link); /* list_remove (proc->mappings, mapping_link); */
free (mapping); /* free (mapping); */
} /* } */
pmm_free (proc->pd->cr3_paddr, 1); /* pmm_free (proc->pd->cr3_paddr, 1); */
spin_unlock (&proc->pd->lock, &ctxprpd); /* spin_unlock (&proc->pd->lock, &ctxprpd); */
free (proc->pd); /* 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);
/* clean the process */ /* clean the process */
free (proc); free (proc);

2
kernel/amd64/sched1.c
View File

@@ -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 (&proc->lock, &ctxpr);
spin_unlock (cpu_lock, ctxcpu); 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);
} }

8
kernel/proc/locks.txt
View File

@@ -2,5 +2,9 @@ Lock hierarchy for process scheduling:
1. proc_tree_lock 1. proc_tree_lock
2. cpu->lock 2. cpu->lock
3. proc->lock 3. procgroup->lock
4. sq->lock 4. proc->lock
5. sq->lock
1. procgroup_tree_lock
2. procgroup->lock

24
kernel/proc/mem.c
View File

@@ -5,29 +5,7 @@
#include <proc/resource.h> #include <proc/resource.h>
#include <sync/spin_lock.h> #include <sync/spin_lock.h>
bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resource_mem_init* init) { void proc_cleanup_resource_mem (struct proc_resource* resource) {
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;
if (!resource->u.mem.managed) if (!resource->u.mem.managed)
pmm_free (resource->u.mem.paddr, resource->u.mem.pages); pmm_free (resource->u.mem.paddr, resource->u.mem.pages);
} }

9
kernel/proc/mem.h
View File

@@ -15,13 +15,6 @@ struct proc_resource_mem {
bool managed; bool managed;
}; };
struct proc_resource_mem_init { void proc_cleanup_resource_mem (struct proc_resource* resource);
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);
#endif // _KERNEL_PROC_MEM_H #endif // _KERNEL_PROC_MEM_H

8
kernel/proc/mutex.c
View File

@@ -85,13 +85,7 @@ static void proc_mutex_resume (struct proc* proc, struct proc_sq_entry* sq_entry
cpu_request_sched (cpu); cpu_request_sched (cpu);
} }
bool proc_create_resource_mutex (struct proc_mutex* mutex) { void proc_cleanup_resource_mutex (struct proc_resource* resource) {
memset (mutex, 0, sizeof (*mutex));
return true;
}
void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource) {
struct proc_mutex* mutex = &resource->u.mutex; struct proc_mutex* mutex = &resource->u.mutex;
spin_lock_ctx_t ctxmt, ctxsq; spin_lock_ctx_t ctxmt, ctxsq;

3
kernel/proc/mutex.h
View File

@@ -15,8 +15,7 @@ struct proc_mutex {
struct proc* owner; struct proc* owner;
}; };
bool proc_create_resource_mutex (struct proc_mutex* mutex); void proc_cleanup_resource_mutex (struct proc_resource* resource);
void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resource);
void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex); void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex);
bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex); bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex);

40
kernel/proc/proc.c
View File

@@ -11,6 +11,7 @@
#include <mm/pmm.h> #include <mm/pmm.h>
#include <proc/kpproc_fb.h> #include <proc/kpproc_fb.h>
#include <proc/proc.h> #include <proc/proc.h>
#include <proc/procgroup.h>
#include <proc/resource.h> #include <proc/resource.h>
#include <rd/rd.h> #include <rd/rd.h>
#include <sync/rw_spin_lock.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 */ 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; for (uintptr_t vpage = start_vaddr, ppage = start_paddr; vpage < start_vaddr + pages * PAGE_SIZE;
vpage += PAGE_SIZE, ppage += 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; return true;
} }
@@ -81,9 +82,9 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
if (tail_mapping == NULL) if (tail_mapping == NULL)
return false; 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 = struct proc_mapping* mapping =
list_entry (mapping_link, struct proc_mapping, proc_mappings_link); 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; 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); &tail_mapping->proc_mappings_link);
used_tail_mapping = true; 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 */ } else if ((start_vaddr > mapping->vaddr) && (end_vaddr >= m_end)) { /* shrink right */
mapping->size = start_vaddr - mapping->vaddr; mapping->size = start_vaddr - mapping->vaddr;
} else { /* full overlap */ } else { /* full overlap */
list_remove (proc->mappings, &mapping->proc_mappings_link); list_remove (proc->procgroup->mappings, &mapping->proc_mappings_link);
free (mapping); free (mapping);
} }
} }
@@ -123,10 +124,10 @@ bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
free (tail_mapping); free (tail_mapping);
for (uintptr_t vpage = start_vaddr; vpage < end_vaddr; vpage += PAGE_SIZE) { 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; 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); size_t blks = div_align_up (phdr->p_memsz + off, PAGE_SIZE);
struct proc_resource_mem_init mem_init = {.pages = blks}; int rid = procgroup_get_sys_rid (proc->procgroup);
int rid = atomic_fetch_add (&proc->resources->sys_rids, 1); struct proc_resource* r = proc_create_resource_mem (proc->procgroup, rid, blks, 0, false);
struct proc_resource* r =
proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&mem_init);
if (r == NULL) { if (r == NULL) {
DEBUG ("pmm oom error while loading ELF segments! (tried to alloc %zu blks)\n", blks); 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.state = PROC_PSEUDO;
kpproc.pid = 0; 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.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); 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, memcpy ((struct kpproc_fb*)((uintptr_t)hhdm->offset + fb_info_memblk_paddr), &fb_info,
sizeof (fb_info)); sizeof (fb_info));
struct proc_resource_mem_init mem_init = { proc_create_resource_mem (kpproc.procgroup, 0, pages, fb_info_memblk_paddr, true);
.pages = pages, .paddr = fb_info_memblk_paddr, .managed = true};
proc_create_resource (&kpproc, 0, PR_MEM, RV_PUBLIC, &mem_init);
} }
} }

23
kernel/proc/proc.h
View File

@@ -6,6 +6,7 @@
#include <libk/list.h> #include <libk/list.h>
#include <libk/rbtree.h> #include <libk/rbtree.h>
#include <libk/std.h> #include <libk/std.h>
#include <proc/procgroup.h>
#include <proc/resource.h> #include <proc/resource.h>
#include <proc/suspension_q.h> #include <proc/suspension_q.h>
#include <sync/rw_spin_lock.h> #include <sync/rw_spin_lock.h>
@@ -23,25 +24,11 @@
#define PROC_SUSPENDED 2 #define PROC_SUSPENDED 2
#define PROC_PSEUDO 3 #define PROC_PSEUDO 3
/* process flags */
#define PROC_USTK_PREALLOC (1 << 0) #define PROC_USTK_PREALLOC (1 << 0)
struct cpu; 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 proc_sq_entry {
struct list_node_link sq_link; struct list_node_link sq_link;
struct list_node_link proc_link; struct list_node_link proc_link;
@@ -52,18 +39,16 @@ struct proc_sq_entry {
struct proc { struct proc {
int pid; int pid;
struct rb_node_link proc_tree_link; 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 cpu_run_q_link;
struct list_node_link reap_link; struct list_node_link reap_link;
struct list_node_link* sq_entries; struct list_node_link* sq_entries;
struct procgroup* procgroup;
struct list_node_link* mappings; /* pd.lock implicitly protects this field */
struct proc_platformdata pdata; struct proc_platformdata pdata;
uint32_t flags; uint32_t flags;
struct pd* pd;
spin_lock_t lock; spin_lock_t lock;
struct cpu* cpu; struct cpu* cpu;
atomic_int state; atomic_int state;
struct proc_resources* resources;
}; };
void proc_sched (void); void proc_sched (void);

96
kernel/proc/procgroup.c Normal file
View File

@@ -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);
}

38
kernel/proc/procgroup.h Normal file
View File

@@ -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

211
kernel/proc/resource.c
View File

@@ -7,169 +7,98 @@
#include <mm/pmm.h> #include <mm/pmm.h>
#include <proc/mutex.h> #include <proc/mutex.h>
#include <proc/proc.h> #include <proc/proc.h>
#include <proc/procgroup.h>
#include <proc/resource.h> #include <proc/resource.h>
#include <sync/spin_lock.h> #include <sync/spin_lock.h>
#include <sys/debug.h> #include <sys/debug.h>
static struct rb_node_link* resource_tree = NULL; struct proc_resource* proc_find_resource (struct procgroup* procgroup, int rid) {
static rw_spin_lock_t resource_tree_lock = RW_SPIN_LOCK_INIT; spin_lock_ctx_t ctxpg;
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* resource = NULL; struct proc_resource* resource = NULL;
spin_lock_ctx_t ctxrs;
switch (vis) { spin_lock (&procgroup->lock, &ctxpg);
case RV_PRIVATE: { rbtree_find (struct proc_resource, &procgroup->resource_tree, rid, resource, resource_tree_link,
/* User wants to create a private resource, so search locally */ rid);
rw_spin_read_lock (&proc->resources->lock, &ctxrs); spin_unlock (&procgroup->lock, &ctxpg);
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; return resource;
} }
struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type, int vis, struct proc_resource* proc_create_resource_mem (struct procgroup* procgroup, int rid, size_t pages,
void* data) { uintptr_t paddr, bool managed) {
spin_lock_ctx_t ctxrs; spin_lock_ctx_t ctxpg;
struct proc_resource* resource;
/* Check if resource RID already exists */ if (pages == 0)
struct proc_resource* resource_check = proc_find_resource (proc, rid, vis);
/* Resource was found either way, so it already exists */
if (resource_check != NULL)
return NULL; 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) if (resource == NULL)
return NULL; return NULL;
memset (resource, 0, sizeof (*resource)); memset (resource, 0, sizeof (*resource));
resource->lock = SPIN_LOCK_INIT; resource->lock = SPIN_LOCK_INIT;
resource->type = type; resource->ops.cleanup = &proc_cleanup_resource_mem;
resource->refs = 1;
resource->rid = rid; resource->rid = rid;
resource->visibility = vis; resource->type = PR_MEM;
resource->created_by_pid = proc->pid; resource->u.mem.resource = resource;
if (managed) {
switch (resource->type) { resource->u.mem.managed = true;
case PR_MEM: { } else {
struct proc_resource_mem_init* mem_init = data; paddr = pmm_alloc (pages);
proc_create_resource_mem (&resource->u.mem, mem_init); if (paddr == PMM_ALLOC_ERR) {
resource->ops.cleanup = &proc_cleanup_resource_mem; free (resource);
resource->u.mem.resource = resource; return NULL;
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.managed = false;
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->u.mem.paddr = paddr;
resource->u.mem.pages = resource->u.mem.alive_pages = pages;
resource->refs = 1;
switch (resource->visibility) { spin_lock (&procgroup->lock, &ctxpg);
case RV_PRIVATE: { rbtree_insert (struct proc_resource, &procgroup->resource_tree, &resource->resource_tree_link,
rw_spin_write_lock (&proc->resources->lock, &ctxrs); resource_tree_link, rid);
rbtree_insert (struct proc_resource, &proc->resources->tree, spin_unlock (&procgroup->lock, &ctxpg);
&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; 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);
}
}

23
kernel/proc/resource.h
View File

@@ -11,33 +11,28 @@
#define PR_MEM 0 #define PR_MEM 0
#define PR_MUTEX 1 #define PR_MUTEX 1
#define RV_PRIVATE 0
#define RV_PUBLIC 1
struct proc; struct proc;
struct procgroup;
struct proc_resource { struct proc_resource {
int type; int type;
int rid; int rid;
int visibility;
spin_lock_t lock;
atomic_int refs; atomic_int refs;
struct rb_node_link global_resource_tree_link; spin_lock_t lock;
struct rb_node_link local_resource_tree_link; struct rb_node_link resource_tree_link;
union { union {
struct proc_resource_mem mem; struct proc_resource_mem mem;
struct proc_mutex mutex; struct proc_mutex mutex;
} u; } u;
struct { struct {
void (*cleanup) (struct proc* proc, struct proc_resource* resource); void (*cleanup) (struct proc_resource* resource);
} ops; } ops;
int created_by_pid;
}; };
struct proc_resource* proc_create_resource (struct proc* proc, int rid, int type, int vis, struct proc_resource* proc_find_resource (struct procgroup* procgroup, int rid);
void* data); struct proc_resource* proc_create_resource_mem (struct procgroup* procgroup, int rid, size_t pages,
struct proc_resource* proc_find_resource (struct proc* proc, int rid, int vis); uintptr_t paddr, bool managed);
void proc_drop_resource (struct proc* proc, struct proc_resource* resource, bool lock); struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, int rid);
void proc_cleanup_resources (struct proc* proc); void proc_resource_unlink (struct proc_resource* resource);
#endif // _KERNEL_PROC_RESOURCE_H #endif // _KERNEL_PROC_RESOURCE_H

6
kernel/proc/src.mk
View File

@@ -1,9 +1,11 @@
c += proc/proc.c \ c += proc/proc.c \
proc/resource.c \ proc/resource.c \
proc/mutex.c \ proc/mutex.c \
proc/mem.c proc/mem.c \
proc/procgroup.c
o += proc/proc.o \ o += proc/proc.o \
proc/resource.o \ proc/resource.o \
proc/mutex.o \ proc/mutex.o \
proc/mem.o proc/mem.o \
proc/procgroup.o

116
kernel/syscall/syscall.c
View File

@@ -8,6 +8,7 @@
#include <proc/mem.h> #include <proc/mem.h>
#include <proc/mutex.h> #include <proc/mutex.h>
#include <proc/proc.h> #include <proc/proc.h>
#include <proc/procgroup.h>
#include <proc/resource.h> #include <proc/resource.h>
#include <sync/spin_lock.h> #include <sync/spin_lock.h>
#include <sys/debug.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; struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
spin_lock_ctx_t ctxprpd; 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)) { if (!mm_validate_buffer (&proc->procgroup->pd, (uintptr_t)uvaddr, size, 0)) {
spin_unlock (&proc->pd->lock, &ctxprpd); spin_unlock (&proc->procgroup->pd.lock, &ctxprpd);
return NULL; 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; uintptr_t out_kvaddr = (uintptr_t)hhdm->offset + out_paddr;
@@ -52,22 +53,18 @@ DEFINE_SYSCALL (sys_test) {
return ST_OK; 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) { DEFINE_SYSCALL (sys_map) {
spin_lock_ctx_t ctxrs; spin_lock_ctx_t ctxrs;
int mem_rid = (int)a1; int mem_rid = (int)a1;
int vis = (int)a2; uintptr_t vaddr = a2;
uintptr_t vaddr = a3; uint32_t flags = (uint32_t)a3;
uint32_t flags = (uint32_t)a4;
if (vaddr % PAGE_SIZE != 0) if (vaddr % PAGE_SIZE != 0)
return -ST_UNALIGNED; return -ST_UNALIGNED;
if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) struct proc_resource* mem_resource = proc_find_resource (proc->procgroup, mem_rid);
return -ST_BAD_RESOURCE;
struct proc_resource* mem_resource = proc_find_resource (proc, mem_rid, vis);
if (mem_resource == NULL) { if (mem_resource == NULL) {
return -ST_NOT_FOUND; return -ST_NOT_FOUND;
@@ -99,22 +96,18 @@ DEFINE_SYSCALL (sys_unmap) {
return proc_unmap (proc, vaddr, pages) ? ST_OK : -ST_OOM_ERROR; 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) { DEFINE_SYSCALL (sys_create_mem) {
int rid = (int)a1; int rid = (int)a1;
int vis = (int)a2; size_t pages = (size_t)a2;
size_t pages = (size_t)a3;
if (!(vis == RV_PUBLIC || vis == RV_PRIVATE))
return -ST_BAD_RESOURCE;
if (pages == 0) if (pages == 0)
return ST_OK; return ST_OK;
int rid1 = rid < 0 ? atomic_fetch_add (&proc->resources->sys_rids, 1) : rid; /* 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_init mem_init = {.managed = false, .pages = pages}; struct proc_resource* mem_resource =
struct proc_resource* mem_resource = proc_create_resource (proc, rid1, PR_MEM, vis, &mem_init); proc_create_resource_mem (proc->procgroup, rid1, pages, 0, false);
if (mem_resource == NULL) if (mem_resource == NULL)
return -ST_OOM_ERROR; return -ST_OOM_ERROR;
@@ -122,34 +115,33 @@ DEFINE_SYSCALL (sys_create_mem) {
return mem_resource->rid; 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) { DEFINE_SYSCALL (sys_unlink_mem) {
spin_lock_ctx_t ctxrs; /* spin_lock_ctx_t ctxrs; */
int rid = (int)a1; /* int rid = (int)a1; */
int vis = (int)a2; /* size_t pages = (size_t)a2; */
size_t pages = (size_t)a3;
if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) /* if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) */
return -ST_BAD_RESOURCE; /* 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) /* if (mem_resource == NULL) */
return -ST_NOT_FOUND; /* return -ST_NOT_FOUND; */
spin_lock (&mem_resource->lock, &ctxrs); /* spin_lock (&mem_resource->lock, &ctxrs); */
if (mem_resource->type != PR_MEM) { /* if (mem_resource->type != PR_MEM) { */
spin_unlock (&mem_resource->lock, &ctxrs); /* spin_unlock (&mem_resource->lock, &ctxrs); */
return -ST_BAD_RESOURCE; /* return -ST_BAD_RESOURCE; */
} /* } */
mem_resource->u.mem.alive_pages -= pages; /* mem_resource->u.mem.alive_pages -= pages; */
if (mem_resource->u.mem.alive_pages < 0) { /* if (mem_resource->u.mem.alive_pages < 0) { */
spin_unlock (&mem_resource->lock, &ctxrs); /* spin_unlock (&mem_resource->lock, &ctxrs); */
proc_drop_resource (proc, mem_resource, true); /* proc_drop_resource (proc, mem_resource, true); */
} /* } */
return ST_OK; return ST_OK;
} }
@@ -181,19 +173,11 @@ DEFINE_SYSCALL (sys_sched) {
return ST_OK; return ST_OK;
} }
/* int create_mutex (int mutex_rid, int vis) */ /* int create_mutex (int mutex_rid) */
DEFINE_SYSCALL (sys_create_mutex) { DEFINE_SYSCALL (sys_create_mutex) {
int mutex_rid = (int)a1; int mutex_rid = (int)a1;
int vis = (int)a2;
if (mutex_rid < 0) struct proc_resource* mutex_resource = proc_create_resource_mutex (proc->procgroup, mutex_rid);
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);
if (mutex_resource == NULL) if (mutex_resource == NULL)
return -ST_OOM_ERROR; return -ST_OOM_ERROR;
@@ -201,33 +185,25 @@ DEFINE_SYSCALL (sys_create_mutex) {
return mutex_resource->rid; return mutex_resource->rid;
} }
/* int unlink_mutex (int mutex_rid, int vis) */ /* int unlink_mutex (int mutex_rid) */
DEFINE_SYSCALL (sys_unlink_mutex) { DEFINE_SYSCALL (sys_unlink_mutex) {
int mutex_rid = (int)a1; int mutex_rid = (int)a1;
int vis = (int)a2;
if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) struct proc_resource* mutex_resource = proc_find_resource (proc->procgroup, mutex_rid);
return -ST_BAD_RESOURCE;
struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);
if (mutex_resource == NULL) if (mutex_resource == NULL)
return -ST_NOT_FOUND; return -ST_NOT_FOUND;
proc_drop_resource (proc, mutex_resource, true); /* proc_drop_resource (proc, mutex_resource, true); */
return ST_OK; return ST_OK;
} }
/* int lock_mutex (int mutex_rid, int vis) */ /* int lock_mutex (int mutex_rid) */
DEFINE_SYSCALL (sys_lock_mutex) { DEFINE_SYSCALL (sys_lock_mutex) {
int mutex_rid = (int)a1; int mutex_rid = (int)a1;
int vis = (int)a2;
if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) struct proc_resource* mutex_resource = proc_find_resource (proc->procgroup, mutex_rid);
return -ST_BAD_RESOURCE;
struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);
if (mutex_resource == NULL) if (mutex_resource == NULL)
return -ST_NOT_FOUND; return -ST_NOT_FOUND;
@@ -237,15 +213,11 @@ DEFINE_SYSCALL (sys_lock_mutex) {
return ST_OK; return ST_OK;
} }
/* int unlock_mutex (int mutex_rid, int vis) */ /* int unlock_mutex (int mutex_rid) */
DEFINE_SYSCALL (sys_unlock_mutex) { DEFINE_SYSCALL (sys_unlock_mutex) {
int mutex_rid = (int)a1; int mutex_rid = (int)a1;
int vis = (int)a2;
if (!(vis == RV_PUBLIC || vis == RV_PRIVATE)) struct proc_resource* mutex_resource = proc_find_resource (proc->procgroup, mutex_rid);
return -ST_BAD_RESOURCE;
struct proc_resource* mutex_resource = proc_find_resource (proc, mutex_rid, vis);
if (mutex_resource == NULL) if (mutex_resource == NULL)
return -ST_NOT_FOUND; return -ST_NOT_FOUND;

17
libmsl/alloc/liballoc.c
View File

@@ -8,25 +8,26 @@
static uintptr_t liballoc_map_base = PROC_MAP_BASE; static uintptr_t liballoc_map_base = PROC_MAP_BASE;
static int mem_rid_base = 1000000; 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) { void* liballoc_alloc (int pages, int* mem_rid) {
uintptr_t current_base = liballoc_map_base; 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) { if (*mem_rid < 0) {
return NULL; return NULL;
} }
if (map (*mem_rid, RV_PRIVATE, current_base, MAP_FLAGS | MAP_RW) < 0) { if (map (*mem_rid, current_base, MAP_FLAGS | MAP_RW) < 0) {
unlink_mem (*mem_rid, RV_PRIVATE, pages); unlink_mem (*mem_rid, pages);
return NULL; return NULL;
} }
@@ -38,7 +39,7 @@ void* liballoc_alloc (int pages, int* mem_rid) {
int liballoc_free (void* ptr, int pages, int mem_rid) { int liballoc_free (void* ptr, int pages, int mem_rid) {
unmap ((uintptr_t)ptr, pages); unmap ((uintptr_t)ptr, pages);
unlink_mem (mem_rid, RV_PRIVATE, pages); unlink_mem (mem_rid, pages);
return 0; return 0;
} }

20
libmsl/m/system.c
View File

@@ -15,28 +15,24 @@ int test (char c) { return do_syscall (SYS_TEST, c); }
int sched (void) { return do_syscall (SYS_SCHED, 0); } int sched (void) { return do_syscall (SYS_SCHED, 0); }
int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) { int map (int mem_rid, uintptr_t vaddr, uint32_t flags) {
return do_syscall (SYS_MAP, mem_rid, vis, vaddr, 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 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) { int create_mem (int mem_rid, size_t pages) { return do_syscall (SYS_CREATE_MEM, mem_rid, pages); }
return do_syscall (SYS_CREATE_MEM, mem_rid, vis, pages);
}
int unlink_mem (int mem_rid, int vis, size_t pages) { int unlink_mem (int mem_rid, size_t pages) { return do_syscall (SYS_UNLINK_MEM, mem_rid, pages); }
return do_syscall (SYS_UNLINK_MEM, mem_rid, vis, pages);
}
int clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void)) { int clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void)) {
return do_syscall (SYS_CLONE, vstack_top, stack_size, entry); 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); }

17
libmsl/m/system.h
View File

@@ -14,20 +14,17 @@
#define MAP_USER (1 << 2) #define MAP_USER (1 << 2)
#define MAP_FLAGS (MAP_PRESENT | MAP_USER) #define MAP_FLAGS (MAP_PRESENT | MAP_USER)
#define RV_PRIVATE 0
#define RV_PUBLIC 1
int quit (void); int quit (void);
int test (char c); int test (char c);
int sched (void); 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 unmap (uintptr_t vaddr, size_t pages);
int create_mem (int mem_rid, int vis, size_t pages); int create_mem (int mem_rid, size_t pages);
int unlink_mem (int mem_rid, int vis, 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 clone (uintptr_t vstack_top, size_t stack_size, void (*entry) (void));
int create_mutex (int mutex_rid, int vis); int create_mutex (int mutex_rid);
int unlink_mutex (int mutex_rid, int vis); int unlink_mutex (int mutex_rid);
int lock_mutex (int mutex_rid, int vis); int lock_mutex (int mutex_rid);
int unlock_mutex (int mutex_rid, int vis); int unlock_mutex (int mutex_rid);
#endif // _LIBMSL_M_SYSTEM_H #endif // _LIBMSL_M_SYSTEM_H