161 lines
3.6 KiB
C
161 lines
3.6 KiB
C
#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;
|
|
}
|