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

Compare commits

base: kamkow1:67b66f2b394749b34e816e4392eca7f79509cdb8
Branches Tags
kamkow1:master
..
compare: kamkow1:b388b30b245631c59180387c0053e7c1a78bf6b4
Branches Tags
kamkow1:master

2 Commits
67b66f2b39 ... b388b30b24

Author SHA1 Message Date
kamkow1
b388b30b24 Redesign userspace memory management
All checks were successful
Build documentation / build-and-deploy (push) Successful in 44s
Details
2026-01-27 17:04:08 +01:00
kamkow1
600886a7ee Organize resources into process groups 2026-01-27 14:18:05 +01:00
28 changed files with 454 additions and 813 deletions
Expand all files Collapse all files

10
include/m/syscall_defs.h
View File

@@ -7,11 +7,9 @@
#define SYS_UNMAP 4
#define SYS_CLONE 5
#define SYS_SCHED 6
#define SYS_CREATE_MEM 7
#define SYS_UNLINK_MEM 8
#define SYS_CREATE_MUTEX 9
#define SYS_UNLINK_MUTEX 10
#define SYS_LOCK_MUTEX 11
#define SYS_UNLOCK_MUTEX 12
#define SYS_CREATE_MUTEX 7
#define SYS_UNLINK_MUTEX 8
#define SYS_LOCK_MUTEX 9
#define SYS_UNLOCK_MUTEX 10
#endif // _M_SYSCALL_DEFS_H

51
init/init.c
View File

@@ -6,14 +6,13 @@
#include <stdint.h>
#include <string/string.h>
#define EXAMPLE 3
#define EXAMPLE 2
#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 ();

1
kernel/amd64/mm.h
View File

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

152
kernel/amd64/proc.c
View File

@@ -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>
@@ -19,7 +20,6 @@ static atomic_int pids = 1;
struct proc* proc_from_elf (uint8_t* elf_contents) {
struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
int rid;
struct proc* proc = malloc (sizeof (*proc));
if (proc == NULL)
@@ -31,67 +31,18 @@ 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;
}
uintptr_t kstack_paddr = pmm_alloc (KSTACK_SIZE / PAGE_SIZE);
proc->pdata.kernel_stack = kstack_paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
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 =
proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
if (kstk_r == NULL) {
pmm_free (proc->pd->cr3_paddr, 1);
free (proc->pd);
free (proc->resources);
free (proc);
return NULL;
}
proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
struct proc_resource_mem_init ustk_mem_init = {.pages = USTACK_SIZE / PAGE_SIZE,
.managed = false};
rid = atomic_fetch_add (&proc->resources->sys_rids, 1);
struct proc_resource* ustk_r =
proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&ustk_mem_init);
if (ustk_r == NULL) {
kstk_r->ops.cleanup (proc, kstk_r);
free (kstk_r);
pmm_free (proc->pd->cr3_paddr, 1);
free (proc->pd);
free (proc->resources);
free (proc);
return NULL;
}
proc->pdata.user_stack = ustk_r->u.mem.paddr;
proc_map (proc, proc->pdata.user_stack, PROC_USTACK_TOP - USTACK_SIZE, USTACK_SIZE / PAGE_SIZE,
MM_PG_USER | MM_PG_PRESENT | MM_PG_RW);
procgroup_map (proc->procgroup, PROC_USTACK_TOP - USTACK_SIZE, USTACK_SIZE / PAGE_SIZE,
MM_PG_USER | MM_PG_PRESENT | MM_PG_RW, NULL);
proc->flags |= PROC_USTK_PREALLOC;
@@ -109,8 +60,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;
int rid;
spin_lock_ctx_t ctxprt;
struct proc* proc = malloc (sizeof (*proc));
if (proc == NULL)
@@ -124,54 +74,13 @@ 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);
if (pstack_bottom == 0) {
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 =
proc_create_resource (proc, rid, PR_MEM, RV_PRIVATE, (void*)&kstk_mem_init);
if (kstk_r == NULL) {
free (proc);
return NULL;
}
proc->pdata.kernel_stack = kstk_r->u.mem.paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
proc->pdata.user_stack = pstack_bottom + stack_size;
uintptr_t kstack_paddr = pmm_alloc (KSTACK_SIZE / PAGE_SIZE);
proc->pdata.kernel_stack = kstack_paddr + (uintptr_t)hhdm->offset + KSTACK_SIZE;
proc->pdata.regs.ss = GDT_UDATA | 0x03;
proc->pdata.regs.rsp = (uint64_t)vstack_top;
@@ -183,8 +92,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 +117,9 @@ 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);
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);
}
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->pdata.kernel_stack, KSTACK_SIZE / PAGE_SIZE);
/* clean the process */
free (proc);

9
kernel/amd64/proc.h
View File

@@ -4,15 +4,16 @@
#include <amd64/intr.h>
#include <libk/std.h>
/// Top of userspace process' stack
/* Top of userspace process' stack */
#define PROC_USTACK_TOP 0x00007FFFFFFFF000ULL
/// Size of userspace process' stack
/* Size of userspace process' stack */
#define USTACK_SIZE (256 * PAGE_SIZE)
/* proc_map () base address */
#define PROC_MAP_BASE 0x0000700000000000
/// Platform-dependent process data
/* Platform-dependent process data */
struct proc_platformdata {
struct saved_regs regs;
uintptr_t user_stack;
uintptr_t kernel_stack;
uint64_t gs_base;
};

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

5
kernel/amd64/syscall.c
View File

@@ -13,7 +13,7 @@
extern void amd64_syscall_entry (void);
int amd64_syscall_dispatch (void* stack_ptr) {
uintptr_t amd64_syscall_dispatch (void* stack_ptr) {
spin_lock_ctx_t ctxcpu, ctxpr;
amd64_load_kernel_cr3 ();
@@ -35,8 +35,7 @@ int amd64_syscall_dispatch (void* stack_ptr) {
return -ST_SYSCALL_NOT_FOUND;
}
int result = func (caller, regs, regs->rdi, regs->rsi, regs->rdx, regs->r10, regs->r8, regs->r9);
return result;
return func (caller, regs, regs->rdi, regs->rsi, regs->rdx, regs->r10, regs->r8, regs->r9);
}
void syscall_init (void) {

20
kernel/proc/kpproc_fb.h
View File

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

8
kernel/proc/locks.txt
View File

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

33
kernel/proc/mem.c
View File

@@ -1,33 +0,0 @@
#include <libk/std.h>
#include <mm/pmm.h>
#include <proc/mem.h>
#include <proc/proc.h>
#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;
if (!resource->u.mem.managed)
pmm_free (resource->u.mem.paddr, resource->u.mem.pages);
}

27
kernel/proc/mem.h
View File

@@ -1,27 +0,0 @@
#ifndef _KERNEL_PROC_MEM_H
#define _KERNEL_PROC_MEM_H
#include <libk/std.h>
struct proc;
struct proc_resource;
struct proc_resource_mem {
struct proc_resource* resource;
uintptr_t paddr;
size_t pages;
ptrdiff_t alive_pages;
bool managed;
};
struct proc_resource_mem_init {
uintptr_t paddr;
size_t pages;
bool managed;
};
bool proc_create_resource_mem (struct proc_resource_mem* mem, struct proc_resource_mem_init* init);
void proc_cleanup_resource_mem (struct proc* proc, struct proc_resource* resource);
#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);
}
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;

3
kernel/proc/mutex.h
View File

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

169
kernel/proc/proc.c
View File

@@ -9,8 +9,8 @@
#include <limine/requests.h>
#include <mm/liballoc.h>
#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>
@@ -33,104 +33,12 @@ static rw_spin_lock_t proc_tree_lock = RW_SPIN_LOCK_INIT;
static atomic_int sched_cycles = 0;
/* kernel pseudo process */
static struct proc kpproc;
static bool proc_check_elf (uint8_t* elf) {
if (!((elf[0] == 0x7F) && (elf[1] == 'E') && (elf[2] == 'L') && (elf[3] == 'F')))
return false;
return true;
}
bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr, size_t pages,
uint32_t flags) {
spin_lock_ctx_t ctxprpd;
struct proc_mapping* mapping = malloc (sizeof (*mapping));
if (mapping == NULL)
return false;
mapping->paddr = start_paddr;
mapping->vaddr = start_vaddr;
mapping->size = pages * PAGE_SIZE;
flags &= ~(MM_PD_LOCK | MM_PD_RELOAD); /* clear LOCK flag if present, because we lock manualy */
spin_lock (&proc->pd->lock, &ctxprpd);
list_append (proc->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);
}
spin_unlock (&proc->pd->lock, &ctxprpd);
return true;
}
bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages) {
size_t unmap_size = pages * PAGE_SIZE;
uintptr_t end_vaddr = start_vaddr + unmap_size;
struct list_node_link *mapping_link, *mapping_link_tmp;
bool used_tail_mapping = false;
spin_lock_ctx_t ctxprpd;
struct proc_mapping* tail_mapping = malloc (sizeof (*tail_mapping));
if (tail_mapping == NULL)
return false;
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);
uintptr_t m_end = mapping->vaddr + mapping->size;
/* check overlap */
if ((start_vaddr < m_end) && (end_vaddr > mapping->vaddr)) {
/* split in the middle */
if ((start_vaddr > mapping->vaddr) && (end_vaddr < m_end)) {
tail_mapping->vaddr = end_vaddr;
tail_mapping->paddr = mapping->paddr + (end_vaddr - mapping->vaddr);
tail_mapping->size = m_end - end_vaddr;
mapping->size = start_vaddr - mapping->vaddr;
list_insert_after (proc->mappings, &mapping->proc_mappings_link,
&tail_mapping->proc_mappings_link);
used_tail_mapping = true;
break;
} else if ((start_vaddr <= mapping->vaddr) && (end_vaddr < m_end)) { /* shrink left */
size_t diff = end_vaddr - mapping->vaddr;
mapping->vaddr += diff;
mapping->paddr += diff;
mapping->size -= diff;
} 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);
free (mapping);
}
}
}
if (!used_tail_mapping)
free (tail_mapping);
for (uintptr_t vpage = start_vaddr; vpage < end_vaddr; vpage += PAGE_SIZE) {
mm_unmap_page (proc->pd, vpage, 0);
}
spin_unlock (&proc->pd->lock, &ctxprpd);
return true;
}
struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf) {
struct elf_aux aux;
@@ -155,25 +63,16 @@ 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);
if (r == NULL) {
DEBUG ("pmm oom error while loading ELF segments! (tried to alloc %zu blks)\n", blks);
}
uintptr_t p_addr = r->u.mem.paddr;
memset ((void*)((uintptr_t)hhdm->offset + p_addr), 0, blks * PAGE_SIZE);
memcpy ((void*)((uintptr_t)hhdm->offset + p_addr + off),
(void*)((uintptr_t)elf + phdr->p_offset), phdr->p_filesz);
uint32_t pg_flags = MM_PG_USER | MM_PG_PRESENT;
if (phdr->p_flags & PF_W)
pg_flags |= MM_PG_RW;
proc_map (proc, p_addr, v_addr, blks, pg_flags);
uintptr_t p_addr;
procgroup_map (proc->procgroup, v_addr, blks, pg_flags, &p_addr);
memset ((void*)((uintptr_t)hhdm->offset + p_addr), 0, blks * PAGE_SIZE);
memcpy ((void*)((uintptr_t)hhdm->offset + p_addr + off),
(void*)((uintptr_t)elf + phdr->p_offset), phdr->p_filesz);
} break;
}
}
@@ -348,66 +247,12 @@ static void proc_irq_sched (void* arg, void* regs) {
proc_sched ();
}
static void proc_kpproc_init (void) {
struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
memset (&kpproc, 0, sizeof (kpproc));
kpproc.lock = SPIN_LOCK_INIT;
kpproc.state = PROC_PSEUDO;
kpproc.pid = 0;
kpproc.resources = malloc (sizeof (*kpproc.resources));
kpproc.resources->tree = NULL;
kpproc.resources->lock = RW_SPIN_LOCK_INIT;
kpproc.resources->refs = 1;
kpproc.resources->sys_rids = 0;
kpproc.pd = mm_get_kernel_pd ();
kpproc.cpu = thiscpu;
rbtree_insert (struct proc, &proc_tree, &kpproc.proc_tree_link, proc_tree_link, pid);
/* prepare kernel resources */
{
/* frame buffer */
struct limine_framebuffer_response* fb = limine_framebuffer_request.response;
struct kpproc_fb fb_info = {
.paddr = (uintptr_t)fb->framebuffers[0]->address - (uintptr_t)hhdm->offset,
.w = fb->framebuffers[0]->width,
.h = fb->framebuffers[0]->height,
.pitch = fb->framebuffers[0]->pitch,
.bpp = fb->framebuffers[0]->bpp,
.red_mask_size = fb->framebuffers[0]->red_mask_size,
.red_mask_shift = fb->framebuffers[0]->red_mask_shift,
.green_mask_size = fb->framebuffers[0]->green_mask_size,
.green_mask_shift = fb->framebuffers[0]->green_mask_shift,
.blue_mask_size = fb->framebuffers[0]->blue_mask_size,
.blue_mask_shift = fb->framebuffers[0]->blue_mask_shift,
};
DEBUG ("Framebuffer address %p\n", fb_info.paddr);
size_t pages = align_up (sizeof (fb_info), PAGE_SIZE) / PAGE_SIZE;
uintptr_t fb_info_memblk_paddr = pmm_alloc (pages);
memcpy ((struct kpproc_fb*)((uintptr_t)hhdm->offset + fb_info_memblk_paddr), &fb_info,
sizeof (fb_info));
struct proc_resource_mem_init mem_init = {
.pages = pages, .paddr = fb_info_memblk_paddr, .managed = true};
proc_create_resource (&kpproc, 0, PR_MEM, RV_PUBLIC, &mem_init);
}
}
void proc_init (void) {
#if defined(__x86_64__)
irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER);
irq_attach (&proc_irq_sched, NULL, CPU_REQUEST_SCHED);
#endif
proc_kpproc_init ();
struct proc* spin_proc = proc_spawn_rd ("spin.exe");
proc_register (spin_proc, thiscpu);

27
kernel/proc/proc.h
View File

@@ -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>
@@ -21,27 +22,12 @@
#define PROC_READY 0
#define PROC_DEAD 1
#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,25 +38,20 @@ 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);
void proc_kill (struct proc* proc);
bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr, size_t pages,
uint32_t flags);
bool proc_unmap (struct proc* proc, uintptr_t start_vaddr, size_t pages);
struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf);
void proc_register (struct proc* proc, struct cpu* cpu);
struct proc* proc_find_pid (int pid);

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

@@ -0,0 +1,218 @@
#include <libk/rbtree.h>
#include <libk/std.h>
#include <mm/liballoc.h>
#include <mm/pmm.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;
uintptr_t procgroup_map (struct procgroup* procgroup, uintptr_t vaddr, size_t pages, uint32_t flags,
uintptr_t* out_paddr) {
spin_lock_ctx_t ctxprpd;
vaddr = (vaddr == 0) ? PROC_MAP_BASE : vaddr;
struct proc_mapping* mapping = malloc (sizeof (*mapping));
if (mapping == NULL)
return 0;
uintptr_t paddr = pmm_alloc (pages);
if (paddr == PMM_ALLOC_ERR) {
free (mapping);
return 0;
}
if (out_paddr != NULL)
*out_paddr = paddr;
mapping->paddr = paddr;
mapping->vaddr = vaddr;
mapping->size = pages * PAGE_SIZE;
flags &= ~(MM_PD_LOCK | MM_PD_RELOAD); /* clear LOCK flag if present, because we lock manualy */
spin_lock (&procgroup->pd.lock, &ctxprpd);
list_append (procgroup->mappings, &mapping->proc_mappings_link);
for (uintptr_t vpage = vaddr, ppage = paddr; vpage < vaddr + pages * PAGE_SIZE;
vpage += PAGE_SIZE, ppage += PAGE_SIZE) {
mm_map_page (&procgroup->pd, ppage, vpage, flags);
}
spin_unlock (&procgroup->pd.lock, &ctxprpd);
return vaddr;
}
bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t pages) {
size_t unmap_size = pages * PAGE_SIZE;
uintptr_t end_vaddr = start_vaddr + unmap_size;
struct list_node_link *mapping_link, *mapping_link_tmp;
bool used_tail_mapping = false;
spin_lock_ctx_t ctxprpd;
struct proc_mapping* tail_mapping = malloc (sizeof (*tail_mapping));
if (tail_mapping == NULL)
return false;
spin_lock (&procgroup->pd.lock, &ctxprpd);
list_foreach (procgroup->mappings, mapping_link, mapping_link_tmp) {
struct proc_mapping* mapping =
list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
uintptr_t m_start = mapping->vaddr;
uintptr_t m_end = mapping->vaddr + mapping->size;
/* check overlap */
if ((start_vaddr < m_end) && (end_vaddr > mapping->vaddr)) {
uintptr_t free_vstart = (start_vaddr > m_start) ? start_vaddr : m_start;
uintptr_t free_vend = (end_vaddr < m_end) ? end_vaddr : m_end;
size_t free_size = free_vend - free_vstart;
uintptr_t ppage_to_free = mapping->paddr + (free_vstart - m_start);
pmm_free (ppage_to_free, free_size / PAGE_SIZE);
/* split in the middle */
if ((start_vaddr > m_start) && (end_vaddr < m_end)) {
tail_mapping->vaddr = end_vaddr;
tail_mapping->paddr = mapping->paddr + (end_vaddr - m_start);
tail_mapping->size = m_end - end_vaddr;
mapping->size = start_vaddr - m_start;
list_insert_after (procgroup->mappings, &mapping->proc_mappings_link,
&tail_mapping->proc_mappings_link);
used_tail_mapping = true;
break;
} else if ((start_vaddr <= m_start) && (end_vaddr < m_end)) { /* shrink left */
size_t diff = end_vaddr - m_start;
mapping->vaddr += diff;
mapping->paddr += diff;
mapping->size -= diff;
} else if ((start_vaddr > m_start) && (end_vaddr >= m_end)) { /* shrink right */
mapping->size = start_vaddr - m_start;
} else { /* full overlap */
list_remove (procgroup->mappings, &mapping->proc_mappings_link);
free (mapping);
}
}
}
if (!used_tail_mapping)
free (tail_mapping);
for (uintptr_t vpage = start_vaddr; vpage < end_vaddr; vpage += PAGE_SIZE) {
mm_unmap_page (&procgroup->pd, vpage, 0);
}
spin_unlock (&procgroup->pd.lock, &ctxprpd);
return true;
}
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);
}
struct list_node_link *mapping_link, *mapping_link_tmp;
list_foreach (procgroup->mappings, mapping_link, mapping_link_tmp) {
struct proc_mapping* mapping =
list_entry (mapping_link, struct proc_mapping, proc_mappings_link);
pmm_free (mapping->paddr, mapping->size / PAGE_SIZE);
free (mapping);
}
pmm_free (procgroup->pd.cr3_paddr, 1);
free (procgroup);
}
}
int procgroup_get_sys_rid (struct procgroup* procgroup) {
return atomic_fetch_add (&procgroup->sys_rids, 1);
}

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

@@ -0,0 +1,41 @@
#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);
uintptr_t procgroup_map (struct procgroup* procgroup, uintptr_t vaddr, size_t pages, uint32_t flags,
uintptr_t* out_paddr);
bool procgroup_unmap (struct procgroup* procgroup, uintptr_t start_vaddr, size_t pages);
#endif // _KERNEL_PROC_PROCGROUP_H

173
kernel/proc/resource.c
View File

@@ -7,169 +7,54 @@
#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_mutex (struct procgroup* procgroup, int rid) {
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 = proc_find_resource (procgroup, rid);
if (resource != NULL)
return resource;
/* Resource was found either way, so it already exists */
if (resource_check != NULL)
return NULL;
/* create the resource */
struct proc_resource* resource = malloc (sizeof (*resource));
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_mutex;
resource->u.mutex.resource = resource;
resource->rid = rid;
resource->visibility = vis;
resource->created_by_pid = proc->pid;
resource->type = PR_MUTEX;
resource->refs = 1;
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;
}
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;
}
void proc_resource_unlink (struct proc_resource* resource) {
if (atomic_fetch_sub (&resource->refs, 1) == 1) {
resource->ops.cleanup (resource);
free (resource);
}
}

24
kernel/proc/resource.h
View File

@@ -4,40 +4,30 @@
#include <libk/list.h>
#include <libk/rbtree.h>
#include <libk/std.h>
#include <proc/mem.h>
#include <proc/mutex.h>
#include <sync/spin_lock.h>
#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_mutex (struct procgroup* procgroup, int rid);
void proc_resource_unlink (struct proc_resource* resource);
#endif // _KERNEL_PROC_RESOURCE_H

4
kernel/proc/src.mk
View File

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

181
kernel/syscall/syscall.c
View File

@@ -5,9 +5,9 @@
#include <m/status.h>
#include <m/syscall_defs.h>
#include <mm/pmm.h>
#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>
@@ -16,23 +16,26 @@
#include <syscall/syscall.h>
#define DEFINE_SYSCALL(name) \
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)
uintptr_t 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)
#define SYSRESULT(x) ((uintptr_t)(x))
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);
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;
@@ -42,50 +45,26 @@ static void* sys_get_user_buffer (struct proc* proc, uintptr_t uvaddr, size_t si
/* int quit (void) */
DEFINE_SYSCALL (sys_quit) {
proc_kill (proc);
return ST_OK;
return SYSRESULT (ST_OK);
}
/* int test (void) */
DEFINE_SYSCALL (sys_test) {
char c = (char)a1;
DEBUG ("test syscall from %d! %c\n", proc->pid, c);
return ST_OK;
return SYSRESULT (ST_OK);
}
/* int map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) */
/* int map (uintptr_t vaddr, size_t pages, 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 = a1;
size_t pages = (size_t)a2;
uint32_t flags = (uint32_t)a3;
if (vaddr % PAGE_SIZE != 0)
return -ST_UNALIGNED;
return SYSRESULT (-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);
if (mem_resource == NULL) {
return -ST_NOT_FOUND;
}
spin_lock (&mem_resource->lock, &ctxrs);
if (mem_resource->type != PR_MEM) {
spin_unlock (&mem_resource->lock, &ctxrs);
return -ST_BAD_RESOURCE;
}
uintptr_t paddr = mem_resource->u.mem.paddr;
size_t pages = mem_resource->u.mem.pages;
spin_unlock (&mem_resource->lock, &ctxrs);
return proc_map (proc, paddr, vaddr, pages, flags) ? ST_OK : -ST_OOM_ERROR;
return SYSRESULT (procgroup_map (proc->procgroup, vaddr, pages, flags, NULL));
}
/* int unmap (uintptr_t vaddr, size_t pages) */
@@ -94,64 +73,9 @@ DEFINE_SYSCALL (sys_unmap) {
size_t pages = (size_t)a2;
if (vaddr % PAGE_SIZE != 0)
return -ST_UNALIGNED;
return SYSRESULT (-ST_UNALIGNED);
return proc_unmap (proc, vaddr, pages) ? ST_OK : -ST_OOM_ERROR;
}
/* int create_mem (int rid, int vis, 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;
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);
if (mem_resource == NULL)
return -ST_OOM_ERROR;
return mem_resource->rid;
}
/* int unlink_mem (int rid, int vis, size_t pages) */
DEFINE_SYSCALL (sys_unlink_mem) {
spin_lock_ctx_t ctxrs;
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;
struct proc_resource* mem_resource = proc_find_resource (proc, rid, vis);
if (mem_resource == NULL)
return -ST_NOT_FOUND;
spin_lock (&mem_resource->lock, &ctxrs);
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);
}
return ST_OK;
return SYSRESULT (procgroup_unmap (proc->procgroup, vaddr, pages));
}
/* int clone (uintptr_t vstack_top, size_t stack_size, void* entry) */
@@ -165,92 +89,71 @@ DEFINE_SYSCALL (sys_clone) {
DEBUG ("new=%p\n", new);
if (new == NULL) {
return -ST_OOM_ERROR;
return SYSRESULT (-ST_OOM_ERROR);
}
int pid = new->pid;
proc_register (new, NULL);
return pid;
return SYSRESULT (pid);
}
/* int sched (void) */
DEFINE_SYSCALL (sys_sched) {
proc_sched ();
return ST_OK;
return SYSRESULT (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;
return SYSRESULT (-ST_OOM_ERROR);
return mutex_resource->rid;
return SYSRESULT (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;
return SYSRESULT (-ST_NOT_FOUND);
proc_drop_resource (proc, mutex_resource, true);
return ST_OK;
return SYSRESULT (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;
return SYSRESULT (-ST_NOT_FOUND);
proc_mutex_lock (proc, &mutex_resource->u.mutex);
return ST_OK;
return SYSRESULT (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;
return SYSRESULT (-ST_NOT_FOUND);
return proc_mutex_unlock (proc, &mutex_resource->u.mutex) ? ST_OK : -ST_PERMISSION_ERROR;
return SYSRESULT (proc_mutex_unlock (proc, &mutex_resource->u.mutex) ? ST_OK
: -ST_PERMISSION_ERROR);
}
static syscall_handler_func_t handler_table[] = {
@@ -260,8 +163,6 @@ static syscall_handler_func_t handler_table[] = {
[SYS_UNMAP] = &sys_unmap,
[SYS_CLONE] = &sys_clone,
[SYS_SCHED] = &sys_sched,
[SYS_CREATE_MEM] = &sys_create_mem,
[SYS_UNLINK_MEM] = &sys_unlink_mem,
[SYS_CREATE_MUTEX] = &sys_create_mutex,
[SYS_UNLINK_MUTEX] = &sys_unlink_mutex,
[SYS_LOCK_MUTEX] = &sys_lock_mutex,

5
kernel/syscall/syscall.h
View File

@@ -4,8 +4,9 @@
#include <libk/std.h>
#include <proc/proc.h>
typedef int (*syscall_handler_func_t) (struct proc* proc, void* regs, uintptr_t a1, uintptr_t a2,
uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6);
typedef uintptr_t (*syscall_handler_func_t) (struct proc* proc, void* regs, uintptr_t a1,
uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5,
uintptr_t a6);
syscall_handler_func_t syscall_find_handler (int syscall_num);

42
libmsl/alloc/liballoc.c
View File

@@ -6,41 +6,19 @@
#define LIBALLOC_MUTEX 500
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;
void* liballoc_alloc (int pages) { return map (0, pages, MAP_FLAGS | MAP_RW); }
*mem_rid = create_mem (mem_rid_base++, RV_PRIVATE, 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);
return NULL;
}
uintptr_t old_base = current_base;
current_base += pages * PAGE_SIZE;
return (void*)old_base;
}
int liballoc_free (void* ptr, int pages, int mem_rid) {
unmap ((uintptr_t)ptr, pages);
unlink_mem (mem_rid, RV_PRIVATE, pages);
return 0;
}
int liballoc_free (void* ptr, int pages) { return unmap ((uintptr_t)ptr, pages); }
/** Durand's Ridiculously Amazing Super Duper Memory functions. */
@@ -207,7 +185,6 @@ static struct boundary_tag* allocate_new_tag (unsigned int size) {
unsigned int pages;
unsigned int usage;
struct boundary_tag* tag;
int mem_rid;
// This is how much space is required.
usage = size + sizeof (struct boundary_tag);
@@ -221,7 +198,7 @@ static struct boundary_tag* allocate_new_tag (unsigned int size) {
if (pages < (unsigned int)l_pageCount)
pages = l_pageCount;
tag = (struct boundary_tag*)liballoc_alloc (pages, &mem_rid);
tag = (struct boundary_tag*)liballoc_alloc (pages);
if (tag == NULL)
return NULL; // uh oh, we ran out of memory.
@@ -230,7 +207,6 @@ static struct boundary_tag* allocate_new_tag (unsigned int size) {
tag->size = size;
tag->real_size = pages * l_pageSize;
tag->index = -1;
tag->mem_rid = mem_rid;
tag->next = NULL;
tag->prev = NULL;
@@ -353,7 +329,7 @@ void free (void* ptr) {
if (pages < (unsigned int)l_pageCount)
pages = l_pageCount;
liballoc_free (tag, pages, tag->mem_rid);
liballoc_free (tag, pages);
liballoc_unlock ();
return;

6
libmsl/alloc/liballoc.h
View File

@@ -41,8 +41,6 @@ struct boundary_tag {
struct boundary_tag* next; //< Linked list info.
struct boundary_tag* prev; //< Linked list info.
int mem_rid;
};
/** This function is supposed to lock the memory data structures. It
@@ -69,7 +67,7 @@ extern int liballoc_unlock (void);
* \return NULL if the pages were not allocated.
* \return A pointer to the allocated memory.
*/
extern void* liballoc_alloc (int pages, int* mem_rid);
extern void* liballoc_alloc (int pages);
/** This frees previously allocated memory. The void* parameter passed
* to the function is the exact same value returned from a previous
@@ -79,7 +77,7 @@ extern void* liballoc_alloc (int pages, int* mem_rid);
*
* \return 0 if the memory was successfully freed.
*/
extern int liballoc_free (void* ptr, int pages, int mem_rid);
extern int liballoc_free (void* ptr, int pages);
void* malloc (size_t); //< The standard function.
void* realloc (void*, size_t); //< The standard function.

6
libmsl/amd64/syscall.c
View File

@@ -2,8 +2,8 @@
#include <stddef.h>
#include <stdint.h>
int amd64_syscall (int syscall_num, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4,
uintptr_t a5, uintptr_t a6) {
uintptr_t amd64_syscall (int syscall_num, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4,
uintptr_t a5, uintptr_t a6) {
uint64_t result;
__asm__ volatile ("movq %[a4], %%r10\n"
"movq %[a5], %%r8\n"
@@ -13,5 +13,5 @@ int amd64_syscall (int syscall_num, uintptr_t a1, uintptr_t a2, uintptr_t a3, ui
: "a"(syscall_num), "D"(a1), "S"(a2),
"d"(a3), [a4] "r"(a4), [a5] "r"(a5), [a6] "r"(a6)
: "r10", "r8", "r9", "r11", "rcx", "cc", "memory");
return (int)result;
return result;
}

4
libmsl/amd64/syscall.h
View File

@@ -3,7 +3,7 @@
#include <stdint.h>
int amd64_syscall (int syscall_num, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4,
uintptr_t a5, uintptr_t a6);
uintptr_t amd64_syscall (int syscall_num, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4,
uintptr_t a5, uintptr_t a6);
#endif // _LIBMSL_AMD64_SYSCALL_H

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 map (int mem_rid, int vis, uintptr_t vaddr, uint32_t flags) {
return do_syscall (SYS_MAP, mem_rid, vis, vaddr, flags);
void* map (uintptr_t vaddr, size_t pages, uint32_t flags) {
return (void*)do_syscall (SYS_MAP, vaddr, pages, 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); }

18
libmsl/m/system.h
View File

@@ -5,8 +5,7 @@
#include <stdint.h>
#if defined(__x86_64__)
#define PROC_MAP_BASE 0x0000700000000000
#define PAGE_SIZE 4096
#define PAGE_SIZE 4096
#endif
#define MAP_PRESENT (1 << 0)
@@ -14,20 +13,15 @@
#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);
void* map (uintptr_t vaddr, size_t pages, 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 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