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

Rewrite resource subsystem

Browse Source
This commit is contained in:
Kamil Kowalczyk
2026-01-18 20:50:45 +01:00
parent 4f7077d458
commit ddafc4eb19
20 changed files with 453 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
kernel/syscall/syscall.c
View File

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