kamkow1/my-os-project2
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Split processctl() syscall into multiple smaller ones

Browse Source
This commit is contained in:
Kamil Kowalczyk
2025-10-14 16:37:36 +02:00
parent 8aec45316c
commit c34a253d11
22 changed files with 359 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
kernel/syscall/proc.c Normal file
View File

@ -0,0 +1,237 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "errors.h"
#include "util/util.h"
#include "sysdefs/proc.h"
#include "vfs/vfs.h"
#include "path/path.h"
#include "kprintf.h"
#include "dlmalloc/malloc.h"
#include "ipc/pipe/pipe.h"
#define _MP_MAX 0xff
#define _PATH_MAX VFS_PATH_MAX
int32_t SYSCALL1(sys_proc_kill, pid1) {
uint64_t pid = pid1;
int32_t ret = E_OK;
if (pid == (uint64_t)-1) {
pid = PROCS.current->pid;
}
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
LL_FINDPROP(PROCS.procs, proc, pid, pid);
spinlock_release(&PROCS.spinlock);
proc_kill(proc);
ret = E_DOSCHEDULING;
return ret;
}
int32_t SYSCALL3(sys_proc_spawn, opath1, args1, argslen1) {
int32_t ret = E_OK;
spinlock_acquire(&PROCS.spinlock);
Proc *proc = PROCS.current;
spinlock_release(&PROCS.spinlock);
const char *opath = (const char *)opath1;
if (opath == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
char mp[_MP_MAX];
char path[_PATH_MAX];
path_parse(opath, mp, path);
Proc *newproc = proc_spawnuser(mp, path);
if (newproc == NULL) {
ret = E_SPAWNERROR;
goto done;
}
size_t argslen = argslen1;
char **args = (char **)args1;
if (args != NULL && argslen > 0) {
for (size_t i = 0; i < argslen; i++) {
PROC_ARG(newproc, args[i]);
}
}
for (size_t i = 0; i < PROC_PIPEHANDLES_MAX; i++) {
if (newproc->pipes[i] != NULL) {
ipc_pipefree(newproc->pipes[i]);
dlfree(newproc->pipes[i]);
}
newproc->pipes[i] = proc->pipes[i];
}
proc_register(newproc);
ret = newproc->pid;
done:
return ret;
}
int32_t SYSCALL1(sys_proc_pollstate, pid1) {
uint64_t pid = pid1;
int32_t ret = E_OK;
if (pid == (uint64_t)-1) {
pid = PROCS.current->pid;
}
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
LL_FINDPROP(PROCS.procs, proc, pid, pid);
spinlock_release(&PROCS.spinlock);
if (proc == NULL) {
ret = PROC_DIED;
goto done;
}
ret = proc->state;
done:
return ret;
}
int32_t SYSCALL0(sys_proc_getpid) {
int32_t ret = E_OK;
spinlock_acquire(&PROCS.spinlock);
Proc *proc = PROCS.current;
spinlock_release(&PROCS.spinlock);
ret = proc->pid;
return ret;
}
int32_t SYSCALL1(sys_proc_run, pid1) {
uint64_t pid = pid1;
int32_t ret = E_OK;
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
LL_FINDPROP(PROCS.procs, proc, pid, pid);
spinlock_release(&PROCS.spinlock);
if (proc == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
proc->state = PROC_READY;
done:
return ret;
}
int32_t SYSCALL1(sys_proc_arglen, pid1) {
uint64_t pid = pid1;
int32_t ret = E_OK;
if (pid == (uint64_t)-1) {
pid = PROCS.current->pid;
}
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
LL_FINDPROP(PROCS.procs, proc, pid, pid);
spinlock_release(&PROCS.spinlock);
ret = proc->procargs.len;
return ret;
}
int32_t SYSCALL4(sys_proc_argv, pid1, argslen1, argbuf1, maxargs1) {
uint64_t pid = pid1;
int32_t ret = E_OK;
if (pid == (uint64_t)-1) {
pid = PROCS.current->pid;
}
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
LL_FINDPROP(PROCS.procs, proc, pid, pid);
spinlock_release(&PROCS.spinlock);
size_t *argslen = (size_t *)argslen1;
char **argbuf = (char **)argbuf1;
if (argbuf == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
size_t maxargs = (size_t)maxargs1;
ProcArg *arg, *argtmp;
size_t i;
LL_FOREACH_SAFE_IDX_LIMIT(proc->procargs.list, arg, argtmp, i, maxargs) {
if (argbuf[i] == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
hal_strcpy(argbuf[i], arg->string);
}
*argslen = i;
ret = E_OK;
done:
return ret;
}
int32_t SYSCALL0(sys_proc_listsize) {
int32_t ret;
Proc *p, *ptmp;
size_t i;
spinlock_acquire(&PROCS.spinlock);
LL_FOREACH_SAFE_IDX(PROCS.procs, p, ptmp, i);
spinlock_release(&PROCS.spinlock);
ret = i;
return ret;
}
int32_t SYSCALL2(sys_proc_stat, pidx, pstat1) {
int32_t ret;
ProcStat *stat = (ProcStat *)pstat1;
if (stat == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
Proc *p, *ptmp;
size_t i;
spinlock_acquire(&PROCS.spinlock);
LL_FOREACH_SAFE_IDX(PROCS.procs, p, ptmp, i) {
if (i == pidx) {
stat->pid = p->pid;
hal_strcpy(stat->name, p->name);
stat->state = p->state;
VasRange *vas, *vastmp;
LL_FOREACH_SAFE(p->vas, vas, vastmp) {
stat->usemem += vas->size;
}
break;
}
}
spinlock_release(&PROCS.spinlock);
ret = E_OK;
done:
return ret;
}

18
kernel/syscall/proc.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef SYSCALL_PROC_H_
#define SYSCALL_PROC_H_
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
int32_t SYSCALL1(sys_proc_kill, pid1);
int32_t SYSCALL3(sys_proc_spawn, opath1, args1, argslen1);
int32_t SYSCALL1(sys_proc_pollstate, pid1);
int32_t SYSCALL0(sys_proc_getpid);
int32_t SYSCALL1(sys_proc_run, pid1);
int32_t SYSCALL1(sys_proc_arglen, pid1);
int32_t SYSCALL4(sys_proc_argv, pid1, argslen1, argbuf1, maxargs1);
int32_t SYSCALL0(sys_proc_listsize);
int32_t SYSCALL2(sys_proc_stat, pidx, pstat1);
#endif // SYSCALL_PROC_H_

160
kernel/syscall/processctl.c
View File

@ -1,160 +0,0 @@
#include <stdint.h>
#include "syscall.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "errors.h"
#include "util/util.h"
#include "sysdefs/processctl.h"
#include "vfs/vfs.h"
#include "path/path.h"
#include "kprintf.h"
#include "dlmalloc/malloc.h"
#include "ipc/pipe/pipe.h"
#define PCTL_MP_MAX 0xff
#define PCTL_PATH_MAX VFS_PATH_MAX
int32_t SYSCALL5(sys_processctl, pid1, cmd1, arg1, arg2, arg3) {
uint64_t pid = pid1;
uint64_t cmd = cmd1;
int32_t ret = E_OK;
if (pid == (uint64_t)-1) {
pid = PROCS.current->pid;
}
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
LL_FINDPROP(PROCS.procs, proc, pid, pid);
spinlock_release(&PROCS.spinlock);
if (proc == NULL) {
if (cmd == PCTL_POLLSTATE) {
ret = PROC_DIED;
goto done;
}
ret = E_INVALIDARGUMENT;
goto done;
}
switch (cmd) {
case PCTL_KILL: {
proc_kill(proc);
ret = E_DOSCHEDULING;
} break;
case PCTL_SPAWN: {
const char *opath = (const char *)arg1;
if (opath == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
char mp[PCTL_MP_MAX];
char path[PCTL_PATH_MAX];
path_parse(opath, mp, path);
Proc *newproc = proc_spawnuser(mp, path);
if (newproc == NULL) {
ret = E_SPAWNERROR;
goto done;
}
size_t argslen = arg3;
char **args = (char **)arg2;
if (args != NULL && argslen > 0) {
for (size_t i = 0; i < argslen; i++) {
PROC_ARG(newproc, args[i]);
}
}
for (size_t i = 0; i < PROC_PIPEHANDLES_MAX; i++) {
if (newproc->pipes[i] != NULL) {
ipc_pipefree(newproc->pipes[i]);
dlfree(newproc->pipes[i]);
}
newproc->pipes[i] = proc->pipes[i];
}
proc_register(newproc);
ret = newproc->pid;
} break;
case PCTL_POLLSTATE: {
ret = proc->state;
} break;
case PCTL_RUN: {
proc->state = PROC_READY;
} break;
case PCTL_GETPID: {
ret = proc->pid;
} break;
case PCTL_ARGLEN: {
ret = proc->procargs.len;
} break;
case PCTL_ARGV: {
size_t *argslen = (size_t *)arg1;
char **argbuf = (char **)arg2;
if (argbuf == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
size_t maxargs = (size_t)arg3;
ProcArg *arg, *argtmp;
size_t i;
LL_FOREACH_SAFE_IDX_LIMIT(proc->procargs.list, arg, argtmp, i, maxargs) {
if (argbuf[i] == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
hal_strcpy(argbuf[i], arg->string);
}
*argslen = i;
ret = E_OK;
} break;
case PCTL_PLS_SZ: {
Proc *p, *ptmp;
size_t i;
spinlock_acquire(&PROCS.spinlock);
LL_FOREACH_SAFE_IDX(PROCS.procs, p, ptmp, i);
spinlock_release(&PROCS.spinlock);
ret = i;
} break;
case PCTL_PLS_STAT: {
uint64_t pidx = arg1;
ProcStat *stat = (ProcStat *)arg2;
if (stat == NULL) {
ret = E_INVALIDARGUMENT;
goto done;
}
Proc *p, *ptmp;
size_t i;
spinlock_acquire(&PROCS.spinlock);
LL_FOREACH_SAFE_IDX(PROCS.procs, p, ptmp, i) {
if (i == pidx) {
stat->pid = p->pid;
hal_strcpy(stat->name, p->name);
stat->state = p->state;
VasRange *vas, *vastmp;
LL_FOREACH_SAFE(p->vas, vas, vastmp) {
stat->usemem += vas->size;
}
break;
}
}
spinlock_release(&PROCS.spinlock);
ret = E_OK;
} break;
default: {
ret = E_INVALIDARGUMENT;
} break;
}
done:
return ret;
}

9
kernel/syscall/processctl.h
View File

@ -1,9 +0,0 @@
#ifndef SYSCALL_PROCESSCTL_H_
#define SYSCALL_PROCESSCTL_H_
#include <stdint.h>
#include "syscall.h"
int32_t SYSCALL5(sys_processctl, pid1, cmd1, arg1, arg2, arg3);
#endif // SYSCALL_PROCESSCTL_H_

12
kernel/syscall/syscall.c
View File

@ -2,7 +2,6 @@
#include "syscall.h"
#include "errors.h"
#include "kprintf.h"
#include "processctl.h"
#include "sysdefs/syscall.h"
#include "ioctl.h"
#include "ipcpipe.h"
@ -11,6 +10,7 @@
#include "devctl.h"
#include "randcrypto.h"
#include "vfs.h"
#include "proc.h"
int32_t SYSCALL1(sys_debugprint, string) {
char *p = (char *)string;
@ -20,7 +20,6 @@ int32_t SYSCALL1(sys_debugprint, string) {
SyscallFn SYSCALL_TABLE[SYSCALLS_MAX] = {
[SYS_DEBUGPRINT] = &sys_debugprint,
[SYS_PROCESSCTL] = &sys_processctl,
[SYS_IOCTL] = &sys_ioctl,
[SYS_MMAN_MAP] = &sys_mman_map,
[SYS_MMAN_UNMAP] = &sys_mman_unmap,
@ -34,4 +33,13 @@ SyscallFn SYSCALL_TABLE[SYSCALLS_MAX] = {
[SYS_IPC_PIPEMAKE] = &sys_ipc_pipemake,
[SYS_IPC_PIPEDELETE] = &sys_ipc_pipedelete,
[SYS_IPC_PIPECONNECT] = &sys_ipc_pipeconnect,
[SYS_PROC_KILL] = &sys_proc_kill,
[SYS_PROC_SPAWN] = &sys_proc_spawn,
[SYS_PROC_POLLSTATE] = &sys_proc_pollstate,
[SYS_PROC_GETPID] = &sys_proc_getpid,
[SYS_PROC_RUN] = &sys_proc_run,
[SYS_PROC_ARGLEN] = &sys_proc_arglen,
[SYS_PROC_ARGV] = &sys_proc_argv,
[SYS_PROC_LISTSIZE] = &sys_proc_listsize,
[SYS_PROC_STAT] = &sys_proc_stat,
};