+#include <u.h>
+#include <libc.h>
+#include <ureg.h>
+#include "dat.h"
+#include "fns.h"
+#include "linux.h"
+
+static int timernotefd;
+static void timerproc(void*);
+
+static int
+pidhash(int pid)
+{
+ return (pid - 1) % MAXPROC;
+}
+
+Uproc*
+getproc(int tid)
+{
+ Uproc *p;
+
+ if(tid > 0){
+ p = &proctab.proc[pidhash(tid)];
+ if(p->tid == tid)
+ return p;
+ }
+ return nil;
+}
+
+Uproc*
+getprocn(int n)
+{
+ Uproc *p;
+
+ p = &proctab.proc[n];
+ if(p->tid > 0)
+ return p;
+ return nil;
+}
+
+static Uproc*
+allocproc(void)
+{
+ Uproc *p;
+ int tid, i;
+
+ for(i=0; i<MAXPROC; i++){
+ tid = proctab.nextpid++;
+ p = &proctab.proc[pidhash(tid)];
+ if(p->tid <= 0){
+ proctab.alloc++;
+
+ p->tid = tid;
+ p->pid = tid;
+ p->pgid = tid;
+ p->psid = tid;
+ return p;
+ }
+ }
+
+ trace("allocproc(): out of processes");
+ return nil;
+}
+
+static void
+freeproc(Uproc *p)
+{
+ Uwait *w;
+
+ while(w = p->freewait){
+ p->freewait = w->next;
+ free(w);
+ }
+ exittrace(p);
+ free(p->comm);
+ free(p->root);
+ free(p->cwd);
+ free(p->kcwd);
+ memset(p, 0, sizeof(*p));
+ proctab.alloc--;
+}
+
+void initproc(void)
+{
+ Uproc *p;
+ char buf[1024];
+ int pid;
+
+ proctab.nextpid = 10;
+
+ p = allocproc();
+ p->kpid = getpid();
+ snprint(buf, sizeof(buf), "/proc/%d/note", p->kpid);
+ p->notefd = open(buf, OWRITE);
+ snprint(buf, sizeof(buf), "/proc/%d/args", p->kpid);
+ p->argsfd = open(buf, ORDWR);
+
+ current = p;
+
+ inittrace();
+ inittime();
+ initsignal();
+ initmem();
+ inittls();
+ initfile();
+
+ if((pid = procfork(timerproc, nil, 0)) < 0)
+ panic("initproc: unable to fork timerproc: %r");
+
+ snprint(buf, sizeof(buf), "/proc/%d/note", pid);
+ timernotefd = open(buf, OWRITE);
+
+ current->root = nil;
+ current->cwd = kstrdup(getwd(buf, sizeof(buf)));
+ current->kcwd = kstrdup(current->cwd);
+ current->linkloop = 0;
+ current->starttime = nsec();
+
+ inittrap();
+}
+
+void
+setprocname(char *s)
+{
+ if(current == nil){
+ char buf[32];
+ int fd;
+
+ snprint(buf, sizeof(buf), "/proc/%d/args", getpid());
+ if((fd = open(buf, OWRITE)) >= 0){
+ write(fd, s, strlen(s));
+ close(fd);
+ }
+ } else {
+ write(current->argsfd, s, strlen(s));
+ }
+}
+
+static void
+intrnote(void *, char *msg)
+{
+ if(strncmp(msg, "interrupt", 9) == 0)
+ noted(NCONT);
+ noted(NDFLT);
+}
+
+struct kprocforkargs
+{
+ int flags;
+ void (*func)(void *aux);
+ void *aux;
+};
+
+static int
+kprocfork(void *arg)
+{
+ struct kprocforkargs args;
+ int pid;
+
+ memmove(&args, arg, sizeof(args));
+
+ if((pid = rfork(RFPROC|RFMEM|args.flags)) != 0)
+ return pid;
+
+ notify(intrnote);
+
+ unmapuserspace();
+ current = nil;
+
+ profme();
+ args.func(args.aux);
+ longjmp(exitjmp, 1);
+ return -1;
+}
+
+/*
+ * procfork starts a kernel process running on kstack.
+ * that process will have linux memory segments (stack, private,
+ * shared) unmapped but plan9 segments (text, bss, stack) shared.
+ * here is no Uproc associated with it! current will be set to nil so
+ * you cant call sys_????() functions in here.
+ * procfork returns the plan9 pid. (usefull for posting notes)
+ */
+int procfork(void (*func)(void *aux), void *aux, int flags)
+{
+ struct kprocforkargs args;
+
+ args.flags = flags;
+ args.func = func;
+ args.aux = aux;
+
+ return onstack(kstack, kprocfork, &args);
+}
+
+static void *Intr = (void*)~0;
+
+static char Notifyme[] = "notifyme";
+static char Wakeme[] = "wakeme";
+static char Xchange[] = "xchange";
+
+static char Wakeup[] = "wakeup";
+static char Abort[] = "abort";
+
+int notifyme(int on)
+{
+ Uproc *p;
+
+ p = current;
+ qlock(p);
+ if(on){
+ if(p->notified || signalspending(p)){
+ qunlock(p);
+ return 1;
+ }
+ if(p->state == nil)
+ p->state = Notifyme;
+ } else {
+ p->state = nil;
+ }
+ qunlock(p);
+ return 0;
+}
+
+void wakeme(int on)
+{
+ Uproc *p;
+
+ p = current;
+ qlock(p);
+ if(on){
+ if(p->state == nil)
+ p->state = Wakeme;
+ } else {
+ p->state = nil;
+ }
+ qunlock(p);
+}
+
+int sleepproc(QLock *l, int flags)
+{
+ Uproc *p;
+ void *ret;
+ char *x;
+
+ p = current;
+ qlock(p);
+ x = p->state;
+ if(x == nil || x == Wakeme){
+ p->xstate = x;
+ p->state = Xchange;
+ if(l != nil)
+ qunlock(l);
+ qunlock(p);
+ if(flags && signalspending(p)){
+ ret = Intr;
+ } else {
+ ret = rendezvous(p, Xchange);
+ }
+ if(ret == Intr){
+ qlock(p);
+ if(p->state != Xchange){
+ while((ret = rendezvous(p, Xchange)) == Intr)
+ ;
+ } else {
+ p->state = x;
+ }
+ qunlock(p);
+ }
+ if(l != nil)
+ qlock(l);
+ } else {
+ p->state = Wakeme;
+ ret = x;
+ qunlock(p);
+ }
+ return (ret == Wakeup) ? 0 : -ERESTART;
+}
+
+static int
+wakeup(Uproc *proc, char *m, int force)
+{
+ char *x;
+
+ if(proc != nil){
+ qlock(proc);
+ x = proc->state;
+
+ if(x == Wakeme){
+ proc->state = m;
+ qunlock(proc);
+ return 1;
+ }
+ if(x == Xchange){
+ proc->state = proc->xstate;
+ proc->xstate = nil;
+ qunlock(proc);
+ while(rendezvous(proc, m) == Intr)
+ ;
+ return 1;
+ }
+ if((m != Wakeup) && (proc->notified == 0)){
+ if(x == Notifyme)
+ proc->state = nil;
+ if(x == Notifyme || force){
+ proc->notified = 1;
+ qunlock(proc);
+ write(proc->notefd, "interrupt", 9);
+ return 1;
+ }
+ }
+ qunlock(proc);
+ }
+ return 0;
+}
+
+Uwait* addwaitq(Uwaitq *q)
+{
+ Uproc *p;
+ Uwait *w;
+
+ p = current;
+ if(w = p->freewait){
+ p->freewait = w->next;
+ } else {
+ w = kmalloc(sizeof(*w));
+ }
+
+ w->next = nil;
+
+ w->proc = p;
+ w->file = nil;
+
+ w->q = q;
+ qlock(q);
+ w->nextq = q->w;
+ q->w = w;
+ qunlock(q);
+
+ return w;
+}
+
+void delwaitq(Uwait *w)
+{
+ Uwaitq *q;
+ Uwait **x;
+
+ q = w->q;
+ qlock(q);
+ for(x = &q->w; *x; x=&((*x)->nextq)){
+ if(*x == w){
+ *x = w->nextq;
+ break;
+ }
+ }
+ qunlock(q);
+
+ w->q = nil;
+ w->nextq = nil;
+
+ w->proc = nil;
+ putfile(w->file);
+ w->file = nil;
+
+ w->next = current->freewait;
+ current->freewait = w;
+}
+
+int requeue(Uwaitq *q1, Uwaitq *q2, int nrequeue)
+{
+ int n;
+ Uwait *w;
+
+ n = 1000;
+ for(;;){
+ qlock(q1);
+ if(canqlock(q2))
+ break;
+ qunlock(q1);
+ if(--n <= 0)
+ return 0;
+ sleep(0);
+ }
+ n = 0;
+ while((w = q1->w) && (n < nrequeue)){
+ q1->w = w->nextq;
+ w->q = q2;
+ w->nextq = q2->w;
+ q2->w = w;
+ n++;
+ }
+ qunlock(q2);
+ qunlock(q1);
+ return n;
+}
+
+int wakeq(Uwaitq *q, int nwake)
+{
+ int n;
+ Uwait *w;
+
+ n = 0;
+ if(q != nil){
+ qlock(q);
+ for(w = q->w; w && n < nwake; w=w->nextq)
+ n += wakeup(w->proc, Wakeup, 0);
+ qunlock(q);
+ }
+ return n;
+}
+
+int sleepq(Uwaitq *q, QLock *l, int flags)
+{
+ Uwait *w;
+ int ret;
+
+ w = addwaitq(q);
+ ret = sleepproc(l, flags);
+ delwaitq(w);
+
+ return ret;
+}
+
+static Uproc *alarmq;
+
+int
+procsetalarm(Uproc *proc, vlong t)
+{
+ Uproc **pp;
+ int ret;
+
+ if(proc->alarm && t >= proc->alarm)
+ return 0;
+ ret = (alarmq == nil) || (t < alarmq->alarm);
+ for(pp = &alarmq; *pp; pp = &((*pp)->alarmq)){
+ if(*pp == proc){
+ *pp = proc->alarmq;
+ break;
+ }
+ }
+ for(pp = &alarmq; *pp; pp = &((*pp)->alarmq))
+ if((*pp)->alarm > t)
+ break;
+ proc->alarm = t;
+ proc->alarmq = *pp;
+ *pp = proc;
+ return ret;
+}
+
+void
+setalarm(vlong t)
+{
+ qlock(&proctab);
+ if(procsetalarm(current, t))
+ write(timernotefd, "interrupt", 9);
+ qunlock(&proctab);
+}
+
+/* signal.c */
+extern void alarmtimer(Uproc *proc, vlong now);
+
+static void
+timerproc(void*)
+{
+ Uproc *h;
+ vlong now;
+ long m;
+
+ setprocname("timerproc()");
+
+ while(proctab.alloc > 0){
+ qlock(&proctab);
+ m = 2000;
+ now = nsec();
+ while(h = alarmq){
+ if(now < h->alarm){
+ m = (h->alarm - now) / 1000000;
+ break;
+ }
+ alarmq = h->alarmq;
+ h->alarm = 0;
+ h->alarmq = nil;
+ if(h->timeout){
+ if(now >= h->timeout){
+ h->timeout = 0;
+ wakeup(h, Wakeup, 0);
+ } else
+ procsetalarm(h, h->timeout);
+ }
+ alarmtimer(h, now);
+ }
+ qunlock(&proctab);
+ sleep((m + (1000/HZ-1))/(1000/HZ));
+ }
+}
+
+/*
+static void
+timerproc(void *)
+{
+ Uproc *p;
+ vlong expire, now, wake, dead;
+ int err, i, alive;
+ char c;
+
+ setprocname("timerproc()");
+ dead = 0;
+ for(;;){
+ qlock(&proctab);
+ now = nsec();
+ wake = now + 60000000000LL;
+ alive = 0;
+ for(i=0; i<MAXPROC; i++){
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p->wstate & WEXITED)
+ continue;
+ if(p->kpid <= 0)
+ continue;
+
+ if(now >= dead){
+ if(read(p->argsfd, &c, 1) < 0){
+ err = mkerror();
+ if(err != -EINTR && err != -ERESTART){
+ p->kpid = 0;
+ qunlock(&proctab);
+ exitproc(p, SIGKILL, 1);
+ qlock(&proctab);
+ continue;
+ }
+ }
+ }
+ alive++;
+ expire = p->timeout;
+ if(expire > 0){
+ if(now >= expire){
+ p->timeout = 0;
+ wakeup(p, Wakeup, 0);
+ } else {
+ if(expire < wake)
+ wake = expire;
+ }
+ }
+ expire = alarmtimer(p, now, wake);
+ if(expire < wake)
+ wake = expire;
+ }
+ qunlock(&proctab);
+
+ if(now >= dead)
+ dead = now + 5000000000LL;
+ if(dead < wake)
+ wake = dead;
+ if(alive == 0)
+ break;
+ wake -= now;
+
+ sleep(wake/1000000LL);
+ }
+}
+*/
+
+int sys_waitpid(int pid, int *pexit, int opt)
+{
+ int i, n, m, status;
+ Uproc *p;
+
+ trace("sys_waitpid(%d, %p, %d)", pid, pexit, opt);
+
+ m = WEXITED;
+ if(opt & WUNTRACED)
+ m |= WSTOPPED;
+ if(opt & WCONTINUED)
+ m |= WCONTINUED;
+
+ qlock(&proctab);
+ for(;;){
+ n = 0;
+ for(i=0; i<MAXPROC; i++){
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p == current)
+ continue;
+ if((p->exitsignal != SIGCHLD) && (opt & (WALL|WCLONE))==0)
+ continue;
+ if(p->ppid != current->pid)
+ continue;
+ if(pid > 0){
+ if(p->pid != pid)
+ continue;
+ } else if(pid == 0){
+ if(p->pgid != current->pgid)
+ continue;
+ } else if(pid < -1){
+ if(p->pgid != -pid)
+ continue;
+ }
+ n++;
+ trace("sys_waitpid(): child %d wstate %x", p->pid, p->wstate);
+ if(p->wevent & m)
+ goto found;
+ }
+ if(n == 0){
+ qunlock(&proctab);
+ trace("sys_waitpid(): no children we can wait for");
+ return -ECHILD;
+ }
+ if(opt & WNOHANG){
+ qunlock(&proctab);
+ trace("sys_waitpid(): no exited/stoped/cont children");
+ return 0;
+ }
+ if((i = sleepproc(&proctab, 1)) < 0){
+ qunlock(&proctab);
+ return i;
+ }
+ }
+
+found:
+ pid = p->pid;
+ status = p->exitcode;
+ p->wevent &= ~(p->wevent & m);
+ if(p->wstate & WEXITED){
+ trace("sys_waitpid(): found zombie %d exitcode %d", pid, status);
+ freeproc(p);
+ }
+ qunlock(&proctab);
+ if(pexit)
+ *pexit = status;
+ return pid;
+}
+
+struct linux_rusage {
+ struct linux_timeval ru_utime; /* user time used */
+ struct linux_timeval ru_stime; /* system time used */
+ long ru_maxrss; /* maximum resident set size */
+ long ru_ixrss; /* integral shared memory size */
+ long ru_idrss; /* integral unshared data size */
+ long ru_isrss; /* integral unshared stack size */
+ long ru_minflt; /* page reclaims */
+ long ru_majflt; /* page faults */
+ long ru_nswap; /* swaps */
+ long ru_inblock; /* block input operations */
+ long ru_oublock; /* block output operations */
+ long ru_msgsnd; /* messages sent */
+ long ru_msgrcv; /* messages received */
+ long ru_nsignals; /* signals received */
+ long ru_nvcsw; /* voluntary context switches */
+ long ru_nivcsw; /* involuntary context switches */
+};
+
+int sys_wait4(int pid, int *pexit, int opt, void *prusage)
+{
+ int ret;
+ struct linux_rusage *ru = prusage;
+
+ trace("sys_wait4(%d, %p, %d, %p)", pid, pexit, opt, prusage);
+
+ ret = sys_waitpid(pid, pexit, opt);
+ if(ru != nil)
+ memset(ru, 0, sizeof(*ru));
+
+ return ret;
+}
+
+int
+threadcount(int pid)
+{
+ Uproc *p;
+ int i, n;
+
+ n = 0;
+ for(i = 0; i<MAXPROC; i++){
+ p = getprocn(i);
+ if(p != nil && p->pid == pid)
+ n++;
+ }
+ return n;
+}
+
+int
+killproc(Uproc *p, Usiginfo *info, int group)
+{
+ int i, n;
+ Uproc *w;
+ int sig, err;
+
+ if((err = sendsignal(p, info, group)) <= 0)
+ return err;
+ w = p;
+ sig = info->signo;
+ if(group && !wantssignal(w, sig)){
+ for(i=1, n = p->tid + 1; i<MAXPROC; i++, n++){
+ if((p = getprocn(pidhash(n))) == nil)
+ continue;
+ if(p->pid != w->pid)
+ continue;
+ if(!wantssignal(p, info->signo))
+ continue;
+ w = p;
+ break;
+ }
+ }
+ wakeup(w, Abort, (sig == SIGKILL || sig == SIGSTOP || sig == SIGALRM));
+ return 0;
+}
+
+enum
+{
+ CLD_EXITED = 1,
+ CLD_KILLED,
+ CLD_DUMPED,
+ CLD_TRAPPED,
+ CLD_STOPPED,
+ CLD_CONTINUED,
+};
+
+/*
+ * queue the exit signal into the parent process. this
+ * doesnt do the wakeup like killproc().
+ */
+static int
+sendexitsignal(Uproc *parent, Uproc *proc, int sig, int code)
+{
+ Usiginfo si;
+
+ memset(&si, 0, sizeof(si));
+ switch(si.signo = sig){
+ case SIGCHLD:
+ switch(code & 0xFF){
+ case 0:
+ si.code = CLD_EXITED;
+ break;
+ case SIGSTOP:
+ si.code = CLD_STOPPED;
+ break;
+ case SIGCONT:
+ si.code = CLD_CONTINUED;
+ break;
+ case SIGKILL:
+ si.code = CLD_KILLED;
+ break;
+ default:
+ si.code = CLD_DUMPED;
+ break;
+ }
+ si.chld.pid = proc->pid;
+ si.chld.uid = proc->uid;
+ si.chld.status = code;
+ }
+ return sendsignal(parent, &si, 1);
+}
+
+/*
+ * wakeup all threads who are in the same thread group
+ * as p including p. must be called with proctab locked.
+ */
+static void
+wakeupall(Uproc *p, char *m, int force)
+{
+ int pid, i, n;
+
+ pid = p->pid;
+ for(i=0, n = p->tid; i<MAXPROC; i++, n++)
+ if(p = getprocn(pidhash(n)))
+ if(p->pid == pid)
+ wakeup(p, m, force);
+}
+
+static void
+zap(void *)
+{
+ exitproc(current, 0, 0);
+}
+
+void
+zapthreads(void)
+{
+ Uproc *p;
+ int i, n, z;
+
+ for(;;){
+ z = 0;
+ for(i=1, n = current->tid+1; i<MAXPROC; i++, n++){
+ if((p = getprocn(pidhash(n))) == nil)
+ continue;
+ if(p->pid != current->pid || p == current)
+ continue;
+ if(p->kpid <= 0)
+ continue;
+
+ trace("zapthreads() zapping thread %p", p);
+ p->tracearg = current;
+ p->traceproc = zap;
+ wakeup(p, Abort, 1);
+ z++;
+ }
+ if(z == 0)
+ break;
+ sleepproc(&proctab, 0);
+ }
+}
+
+struct kexitprocargs
+{
+ Uproc *proc;
+ int code;
+ int group;
+};
+
+#pragma profile off
+
+static int
+kexitproc(void *arg)
+{
+ struct kexitprocargs *args;
+ Uproc *proc;
+ int code, group;
+ Uproc *parent, *child, **pp;
+ int i;
+
+ args = arg;
+ proc = args->proc;
+ code = args->code;
+ group = args->group;
+
+ if(proc == current){
+ trace("kexitproc: cleartidptr = %p", proc->cleartidptr);
+ if(okaddr(proc->cleartidptr, sizeof(*proc->cleartidptr), 1))
+ *proc->cleartidptr = 0;
+ sys_futex((ulong*)proc->cleartidptr, 1, MAXPROC, nil, nil, 0);
+
+ qlock(&proctab);
+ exitsignal();
+ qunlock(&proctab);
+
+ exitmem();
+ }
+
+ exitfile(proc);
+
+ close(proc->notefd); proc->notefd = -1;
+ close(proc->argsfd); proc->argsfd = -1;
+
+ qlock(&proctab);
+
+ for(pp = &alarmq; *pp; pp = &((*pp)->alarmq)){
+ if(*pp == proc){
+ *pp = proc->alarmq;
+ proc->alarmq = nil;
+ break;
+ }
+ }
+
+ /* reparent children, and reap when zombies */
+ for(i=0; i<MAXPROC; i++){
+ if((child = getprocn(i)) == nil)
+ continue;
+ if(child->ppid != proc->pid)
+ continue;
+ child->ppid = 0;
+ if(child->wstate & WEXITED)
+ freeproc(child);
+ }
+
+ /* if we got zapped, just free the proc and wakeup zapper */
+ if((proc == current) && (proc->traceproc == zap) && (parent = proc->tracearg)){
+ freeproc(proc);
+ wakeup(parent, Wakeup, 0);
+ goto zapped;
+ }
+
+ if(group && proc == current)
+ zapthreads();
+
+ parent = getproc(proc->ppid);
+ if((threadcount(proc->pid)==1) && parent &&
+ (proc->exitsignal == SIGCHLD) && !ignoressignal(parent, SIGCHLD)){
+
+ /* we are zombie */
+ proc->exitcode = code;
+ proc->wstate = WEXITED;
+ proc->wevent = proc->wstate;
+ if(proc == current){
+ current->kpid = 0;
+ sendexitsignal(parent, proc, proc->exitsignal, code);
+ wakeupall(parent, Abort, 0);
+ qunlock(&proctab);
+ longjmp(exitjmp, 1);
+ } else {
+ sendexitsignal(parent, proc, proc->exitsignal, code);
+ }
+ } else {
+ /* we are clone */
+ if(parent && proc->exitsignal > 0)
+ sendexitsignal(parent, proc, proc->exitsignal, code);
+ freeproc(proc);
+ }
+ if(parent)
+ wakeupall(parent, Abort, 0);
+
+zapped:
+ qunlock(&proctab);
+
+ if(proc == current)
+ longjmp(exitjmp, 1);
+
+ return 0;
+}
+
+void exitproc(Uproc *proc, int code, int group)
+{
+ struct kexitprocargs args;
+
+ trace("exitproc(%p, %d, %d)", proc, code, group);
+
+ args.proc = proc;
+ args.code = code;
+ args.group = group;
+
+ if(proc == current){
+ onstack(kstack, kexitproc, &args);
+ } else {
+ kexitproc(&args);
+ }
+}
+
+struct kstoparg
+{
+ Uproc *stopper;
+ int code;
+};
+
+static void
+stop(void *aux)
+{
+ struct kstoparg *arg = aux;
+
+ stopproc(current, arg->code, 0);
+}
+
+void stopproc(Uproc *proc, int code, int group)
+{
+ struct kstoparg *arg;
+ Uproc *p, *parent;
+ int i, n, z;
+
+ trace("stopproc(%p, %d, %d)", proc, code, group);
+
+ qlock(&proctab);
+ proc->exitcode = code;
+ proc->wstate = WSTOPPED;
+ proc->wevent = proc->wstate;
+
+ if((proc == current) && (proc->traceproc == stop) && (arg = proc->tracearg)){
+ proc->traceproc = nil;
+ proc->tracearg = nil;
+ wakeup(arg->stopper, Wakeup, 0);
+ qunlock(&proctab);
+ return;
+ }
+
+ /* put all threads in the stopped state */
+ arg = nil;
+ while(group){
+ if(arg == nil){
+ arg = kmalloc(sizeof(*arg));
+ arg->stopper = current;
+ arg->code = code;
+ }
+ z = 0;
+ for(i=1, n = proc->tid+1; i<MAXPROC; i++, n++){
+ if((p = getprocn(pidhash(n))) == nil)
+ continue;
+ if(p->pid != proc->pid || p == proc)
+ continue;
+ if(p->kpid <= 0)
+ continue;
+ if(p->wstate & (WSTOPPED | WEXITED))
+ continue;
+
+ trace("stopproc() stopping thread %p", p);
+ p->tracearg = arg;
+ p->traceproc = stop;
+ wakeup(p, Abort, 1);
+ z++;
+ }
+ if(z == 0)
+ break;
+ sleepproc(&proctab, 0);
+ }
+ free(arg);
+
+ if(parent = getproc(proc->ppid)){
+ if(group && !ignoressignal(parent, SIGCHLD))
+ sendexitsignal(parent, proc, SIGCHLD, code);
+ wakeupall(parent, Abort, 0);
+ }
+ qunlock(&proctab);
+}
+
+void contproc(Uproc *proc, int code, int group)
+{
+ Uproc *p, *parent;
+ int i, n;
+
+ trace("contproc(%p, %d, %d)", proc, code, group);
+
+ qlock(&proctab);
+ proc->exitcode = code;
+ proc->wstate = WCONTINUED;
+ proc->wevent = proc->wstate;
+ if(group){
+ for(i=1, n = proc->tid+1; i<MAXPROC; i++, n++){
+ if((p = getprocn(pidhash(n))) == nil)
+ continue;
+ if(p->pid != proc->pid || p == proc)
+ continue;
+ if(p->kpid <= 0)
+ continue;
+ if((p->wstate & WSTOPPED) == 0)
+ continue;
+ if(p->wstate & (WCONTINUED | WEXITED))
+ continue;
+
+ trace("contproc() waking thread %p", p);
+ p->exitcode = code;
+ p->wstate = WCONTINUED;
+ p->wevent = p->wstate;
+ wakeup(p, Wakeup, 0);
+ }
+ }
+ if(parent = getproc(proc->ppid)){
+ if(group && !ignoressignal(parent, SIGCHLD))
+ sendexitsignal(parent, proc, SIGCHLD, code);
+ wakeupall(parent, Abort, 0);
+ }
+ qunlock(&proctab);
+}
+
+int sys_exit(int code)
+{
+ trace("sys_exit(%d)", code);
+
+ exitproc(current, (code & 0xFF)<<8, 0);
+ return -1;
+}
+
+int sys_exit_group(int code)
+{
+ trace("sys_exit_group(%d)", code);
+
+ exitproc(current, (code & 0xFF)<<8, 1);
+ return -1;
+}
+
+struct kcloneprocargs
+{
+ int flags;
+ void *newstack;
+ int *parenttidptr;
+ void *tlsdescr;
+ int *childtidptr;
+};
+
+static int
+kcloneproc(void *arg)
+{
+ struct kcloneprocargs args;
+ struct linux_user_desc tls;
+ Ureg ureg;
+ int rflags, pid, tid;
+ char buf[80];
+ Uproc *new;
+
+ memmove(&args, arg, sizeof(args));
+ memmove(&ureg, current->ureg, sizeof(ureg));
+ if(args.flags & CLONE_SETTLS){
+ if(!okaddr(args.tlsdescr, sizeof(tls), 0))
+ return -EFAULT;
+ memmove(&tls, args.tlsdescr, sizeof(tls));
+ }
+
+ qlock(&proctab);
+ if((new = allocproc()) == nil){
+ qunlock(&proctab);
+ return -EAGAIN;
+ }
+ tid = new->tid;
+
+ if(args.flags & CLONE_PARENT_SETTID){
+ if(!okaddr(args.parenttidptr, sizeof(*args.parenttidptr), 1)){
+ freeproc(new);
+ qunlock(&proctab);
+ return -EFAULT;
+ }
+ *args.parenttidptr = tid;
+ }
+
+ rflags = RFPROC;
+ if(args.flags & CLONE_VM)
+ rflags |= RFMEM;
+
+ qlock(current);
+ if((pid = rfork(rflags)) < 0){
+ freeproc(new);
+ qunlock(current);
+ qunlock(&proctab);
+
+ trace("kcloneproc(): rfork failed: %r");
+ return mkerror();
+ }
+
+ if(pid){
+ /* parent */
+ new->kpid = pid;
+ new->exitsignal = args.flags & 0xFF;
+ new->innote = 0;
+ new->ureg = &ureg;
+ new->syscall = current->syscall;
+ new->sysret = current->sysret;
+ new->comm = nil;
+ new->ncomm = 0;
+ new->linkloop = 0;
+ new->root = current->root ? kstrdup(current->root) : nil;
+ new->cwd = kstrdup(current->cwd);
+ new->kcwd = kstrdup(current->kcwd);
+ new->starttime = nsec();
+
+ snprint(buf, sizeof(buf), "/proc/%d/note", pid);
+ new->notefd = open(buf, OWRITE);
+ snprint(buf, sizeof(buf), "/proc/%d/args", pid);
+ new->argsfd = open(buf, ORDWR);
+
+ if(args.flags & (CLONE_THREAD | CLONE_PARENT)){
+ new->ppid = current->ppid;
+ } else {
+ new->ppid = current->pid;
+ }
+
+ if(args.flags & CLONE_THREAD)
+ new->pid = current->pid;
+
+ new->cleartidptr = nil;
+ if(args.flags & CLONE_CHILD_CLEARTID)
+ new->cleartidptr = args.childtidptr;
+
+ new->pgid = current->pgid;
+ new->psid = current->psid;
+ new->uid = current->uid;
+ new->gid = current->gid;
+
+ clonetrace(new, !(args.flags & CLONE_THREAD));
+ clonesignal(new, !(args.flags & CLONE_SIGHAND), !(args.flags & CLONE_THREAD));
+ clonemem(new, !(args.flags & CLONE_VM));
+ clonefile(new, !(args.flags & CLONE_FILES));
+ clonetls(new);
+ qunlock(&proctab);
+
+ while(rendezvous(new, 0) == (void*)~0)
+ ;
+
+ qunlock(current);
+
+ return tid;
+ }
+
+ /* child */
+ current = new;
+ profme();
+
+ /* wait for parent to copy our resources */
+ while(rendezvous(new, 0) == (void*)~0)
+ ;
+
+ trace("kcloneproc(): hello world");
+
+ if(args.flags & CLONE_SETTLS)
+ sys_set_thread_area(&tls);
+
+ if(args.flags & CLONE_CHILD_SETTID)
+ if(okaddr(args.childtidptr, sizeof(*args.childtidptr), 1))
+ *args.childtidptr = tid;
+
+ if(args.newstack != nil)
+ current->ureg->sp = (ulong)args.newstack;
+ current->sysret(0);
+ retuser();
+
+ return -1;
+}
+
+#pragma profile on
+
+int sys_linux_clone(int flags, void *newstack, int *parenttidptr, int *tlsdescr, void *childtidptr)
+{
+ struct kcloneprocargs a;
+
+ trace("sys_linux_clone(%x, %p, %p, %p, %p)", flags, newstack, parenttidptr, childtidptr, tlsdescr);
+
+ a.flags = flags;
+ a.newstack = newstack;
+ a.parenttidptr = parenttidptr;
+ a.childtidptr = childtidptr;
+ a.tlsdescr = tlsdescr;
+
+ return onstack(kstack, kcloneproc, &a);
+}
+
+int sys_fork(void)
+{
+ trace("sys_fork()");
+
+ return sys_linux_clone(SIGCHLD, nil, nil, nil, nil);
+}
+
+int sys_vfork(void)
+{
+ trace("sys_vfork()");
+
+ return sys_fork();
+}
+
+int sys_getpid(void)
+{
+ trace("sys_getpid()");
+
+ return current->pid;
+}
+
+int sys_getppid(void)
+{
+ trace("sys_getppid()");
+
+ return current->ppid;
+}
+
+int sys_gettid(void)
+{
+ trace("sys_gettid()");
+
+ return current->tid;
+}
+
+int sys_setpgid(int pid, int pgid)
+{
+ int i, n;
+
+ trace("sys_setpgid(%d, %d)", pid, pgid);
+
+ if(pgid == 0)
+ pgid = current->pgid;
+ if(pid == 0)
+ pid = current->pid;
+
+ n = 0;
+ qlock(&proctab);
+ for(i=0; i<MAXPROC; i++){
+ Uproc *p;
+
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p->pid != pid)
+ continue;
+
+ p->pgid = pgid;
+ n++;
+ }
+ qunlock(&proctab);
+
+ return n ? 0 : -ESRCH;
+}
+
+int sys_getpgid(int pid)
+{
+ int i;
+ int pgid;
+
+ trace("sys_getpgid(%d)", pid);
+
+ pgid = -ESRCH;
+ if(pid == 0)
+ return current->pgid;
+ qlock(&proctab);
+ for(i=0; i<MAXPROC; i++){
+ Uproc *p;
+
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p->pid != pid)
+ continue;
+
+ pgid = p->pgid;
+ break;
+ }
+ qunlock(&proctab);
+
+ return pgid;
+}
+
+int sys_getpgrp(void)
+{
+ trace("sys_getpgrp()");
+
+ return sys_getpgid(0);
+}
+
+int sys_getuid(void)
+{
+ trace("sys_getuid()");
+
+ return current->uid;
+}
+
+int sys_getgid(void)
+{
+ trace("sys_getgid()");
+
+ return current->gid;
+}
+
+int sys_setuid(int uid)
+{
+ trace("sys_setuid(%d)", uid);
+
+ current->uid = uid;
+ return 0;
+}
+
+int sys_setgid(int gid)
+{
+ trace("sys_setgid(%d)", gid);
+
+ current->gid = gid;
+ return 0;
+}
+
+int sys_setresuid(int ruid, int euid, int suid)
+{
+ trace("sys_setresuid(%d, %d, %d)", ruid, euid, suid);
+
+ return 0;
+}
+
+int sys_setresgid(int rgid, int egid, int sgid)
+{
+ trace("sys_setresgid(%d, %d, %d)", rgid, egid, sgid);
+
+ return 0;
+}
+int sys_setreuid(int ruid, int euid)
+{
+ trace("sys_setreuid(%d, %d)", ruid, euid);
+
+ return 0;
+}
+
+int sys_setregid(int rgid, int egid)
+{
+ trace("sys_setregid(%d, %d)", rgid, egid);
+
+ return 0;
+}
+
+int sys_getresuid(int *ruid, int *euid, int *suid)
+{
+ trace("sys_getresuid(%p, %p, %p)", ruid, euid, suid);
+
+ if(ruid == nil)
+ return -EINVAL;
+ if(euid == nil)
+ return -EINVAL;
+ if(suid == nil)
+ return -EINVAL;
+
+ *ruid = current->uid;
+ *euid = current->uid;
+ *suid = current->uid;
+
+ return 0;
+}
+
+int sys_getresgid(int *rgid, int *egid, int *sgid)
+{
+ trace("sys_getresgid(%p, %p, %p)", rgid, egid, sgid);
+
+ if(rgid == nil)
+ return -EINVAL;
+ if(egid == nil)
+ return -EINVAL;
+ if(sgid == nil)
+ return -EINVAL;
+
+ *rgid = current->gid;
+ *egid = current->gid;
+ *sgid = current->gid;
+
+ return 0;
+}
+
+int sys_setsid(void)
+{
+ int i;
+
+ trace("sys_setsid()");
+
+ if(current->pid == current->pgid)
+ return -EPERM;
+
+ qlock(&proctab);
+ for(i=0; i<MAXPROC; i++){
+ Uproc *p;
+
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p->pid != current->pid)
+ continue;
+ p->pgid = current->pid;
+ p->psid = current->pid;
+ }
+ qunlock(&proctab);
+
+ settty(nil);
+
+ return current->pgid;
+}
+
+int sys_getsid(int pid)
+{
+ int i, pgid;
+
+ trace("sys_getsid(%d)", pid);
+
+ pgid = -ESRCH;
+ if(pid == 0)
+ pid = current->pid;
+ qlock(&proctab);
+ for(i=0; i<MAXPROC; i++){
+ Uproc *p;
+
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p->pid != pid)
+ continue;
+ if(p->pid != p->psid)
+ continue;
+ pgid = p->pgid;
+ break;
+ }
+ qunlock(&proctab);
+
+ return pgid;
+}
+
+int sys_getgroups(int size, int *groups)
+{
+ trace("sys_getgroups(%d, %p)", size, groups);
+ if(size < 0)
+ return -EINVAL;
+ return 0;
+}
+
+int sys_setgroups(int size, int *groups)
+{
+ trace("sys_setgroups(%d, %p)", size, groups);
+ return 0;
+}
+
+struct linux_utsname
+{
+ char sysname[65];
+ char nodename[65];
+ char release[65];
+ char version[65];
+ char machine[65];
+ char domainname[65];
+};
+
+int sys_uname(void *a)
+{
+ struct linux_utsname *p = a;
+
+ trace("sys_uname(%p)", a);
+
+ strncpy(p->sysname, "Linux", 65);
+ strncpy(p->nodename, sysname(), 65);
+ strncpy(p->release, "3.2.1", 65);
+ strncpy(p->version, "linuxemu", 65);
+ strncpy(p->machine, "i386", 65);
+ strncpy(p->domainname, sysname(), 65);
+
+ return 0;
+}
+
+int sys_personality(ulong p)
+{
+ trace("sys_personality(%lux)", p);
+
+ if(p != 0 && p != 0xffffffff)
+ return -EINVAL;
+ return 0;
+}
+
+int sys_tkill(int tid, int sig)
+{
+ int err;
+
+ trace("sys_tkill(%d, %S)", tid, sig);
+
+ err = -EINVAL;
+ if(tid > 0){
+ Uproc *p;
+
+ err = -ESRCH;
+ qlock(&proctab);
+ if(p = getproc(tid)){
+ Usiginfo si;
+
+ memset(&si, 0, sizeof(si));
+ si.signo = sig;
+ si.code = SI_TKILL;
+ si.kill.pid = current->tid;
+ si.kill.uid = current->uid;
+ err = killproc(p, &si, 0);
+ }
+ qunlock(&proctab);
+ }
+ return err;
+}
+
+int sys_tgkill(int pid, int tid, int sig)
+{
+ int err;
+
+ trace("sys_tgkill(%d, %d, %S)", pid, tid, sig);
+
+ err = -EINVAL;
+ if(tid > 0){
+ Uproc *p;
+
+ err = -ESRCH;
+ qlock(&proctab);
+ if((p = getproc(tid)) && (p->pid == pid)){
+ Usiginfo si;
+
+ memset(&si, 0, sizeof(si));
+ si.signo = sig;
+ si.code = SI_TKILL;
+ si.kill.pid = current->tid;
+ si.kill.uid = current->uid;
+ err = killproc(p, &si, 0);
+ }
+ qunlock(&proctab);
+ }
+ return err;
+}
+
+int sys_rt_sigqueueinfo(int pid, int sig, void *info)
+{
+ int err;
+ Uproc *p;
+ Usiginfo si;
+
+ trace("sys_rt_sigqueueinfo(%d, %S, %p)", pid, sig, info);
+
+ err = -ESRCH;
+ qlock(&proctab);
+ if(p = getproc(pid)){
+ memset(&si, 0, sizeof(si));
+ linux2siginfo(info, &si);
+ si.signo = sig;
+ si.code = SI_QUEUE;
+ err = killproc(p, &si, 1);
+ }
+ qunlock(&proctab);
+ return err;
+}
+
+enum {
+ PIDMAPBITS1 = 8*sizeof(ulong),
+};
+
+int sys_kill(int pid, int sig)
+{
+ int i, j, n;
+ Uproc *p;
+ Usiginfo si;
+ ulong pidmap[(MAXPROC + PIDMAPBITS1-1) / PIDMAPBITS1];
+ ulong m;
+
+ trace("sys_kill(%d, %S)", pid, sig);
+
+ n = 0;
+ memset(pidmap, 0, sizeof(pidmap));
+ qlock(&proctab);
+ for(i=0; i<MAXPROC; i++){
+ if((p = getprocn(i)) == nil)
+ continue;
+ if(p->wstate & WEXITED)
+ continue;
+ if(p->kpid <= 0)
+ continue;
+
+ if(pid == 0){
+ if(p->pgid != current->pgid)
+ continue;
+ } else if(pid == -1){
+ if(p->pid <= 1)
+ continue;
+ if(p->tid == current->tid)
+ continue;
+ } else if(pid < -1) {
+ if(p->pgid != -pid)
+ continue;
+ } else {
+ if(p->pid != pid)
+ continue;
+ }
+
+ /* make sure we send only one signal per pid */
+ j = pidhash(p->pid);
+ m = 1 << (j % PIDMAPBITS1);
+ j /= PIDMAPBITS1;
+ if(pidmap[j] & m)
+ continue;
+ pidmap[j] |= m;
+
+ if(sig > 0){
+ memset(&si, 0, sizeof(si));
+ si.signo = sig;
+ si.code = SI_USER;
+ si.kill.pid = current->tid;
+ si.kill.uid = current->uid;
+ killproc(p, &si, 1);
+ }
+ n++;
+ }
+ qunlock(&proctab);
+ if(n == 0)
+ return -ESRCH;
+ return 0;
+}
+
+int sys_set_tid_address(int *tidptr)
+{
+ trace("sys_set_tid_address(%p)", tidptr);
+
+ current->cleartidptr = tidptr;
+ return current->pid;
+}
+
+struct linux_sched_param
+{
+ int sched_priority;
+};
+
+int sys_sched_setscheduler(int pid, int policy, void *param)
+{
+ trace("sys_sched_setscheduler(%d, %d, %p)", pid, policy, param);
+
+ if(getproc(pid) == nil)
+ return -ESRCH;
+ return 0;
+}
+
+int sys_sched_getscheduler(int pid)
+{
+ trace("sys_sched_getscheduler(%d)", pid);
+
+ if(getproc(pid) == nil)
+ return -ESRCH;
+ return 0;
+}
+
+int sys_sched_setparam(int pid, void *param)
+{
+ trace("sys_sched_setparam(%d, %p)", pid, param);
+
+ if(getproc(pid) == nil)
+ return -ESRCH;
+ return 0;
+}
+
+int sys_sched_getparam(int pid, void *param)
+{
+ struct linux_sched_param *p = param;
+
+ trace("sys_sched_getparam(%d, %p)", pid, param);
+
+ if(getproc(pid) == nil)
+ return -ESRCH;
+ if(p == nil)
+ return -EINVAL;
+ p->sched_priority = 0;
+
+ return 0;
+}
+
+int sys_sched_yield(void)
+{
+ trace("sys_sched_yield()");
+
+ sleep(0);
+ return 0;
+}
+
+enum {
+ RLIMIT_CPU,
+ RLIMIT_FSIZE,
+ RLIMIT_DATA,
+ RLIMIT_STACK,
+ RLIMIT_CORE,
+ RLIMIT_RSS,
+ RLIMIT_NPROC,
+ RLIMIT_NOFILE,
+ RLIMIT_MEMLOCK,
+ RLIMIT_AS,
+ RLIMIT_LOCKS,
+ RLIMIT_SIGPENDING,
+ RLIMIT_MSGQUEUE,
+
+ RLIM_NLIMITS,
+
+ RLIM_INFINITY = ~0UL,
+};
+
+struct linux_rlimit
+{
+ ulong rlim_cur;
+ ulong rlim_max;
+};
+
+int sys_getrlimit(long resource, void *rlim)
+{
+ struct linux_rlimit *r = rlim;
+
+ trace("sys_getrlimit(%ld, %p)", resource, rlim);
+
+ if(resource >= RLIM_NLIMITS)
+ return -EINVAL;
+ if(rlim == nil)
+ return -EFAULT;
+
+ r->rlim_cur = RLIM_INFINITY;
+ r->rlim_max = RLIM_INFINITY;
+
+ switch(resource){
+ case RLIMIT_STACK:
+ r->rlim_cur = USTACK;
+ r->rlim_max = USTACK;
+ break;
+ case RLIMIT_CORE:
+ r->rlim_cur = 0;
+ break;
+ case RLIMIT_NPROC:
+ r->rlim_cur = MAXPROC;
+ r->rlim_max = MAXPROC;
+ break;
+ case RLIMIT_NOFILE:
+ r->rlim_cur = MAXFD;
+ r->rlim_max = MAXFD;
+ break;
+ }
+ return 0;
+}
+
+int sys_setrlimit(long resource, void *rlim)
+{
+ trace("sys_setrlimit(%ld, %p)", resource, rlim);
+
+ if(resource >= RLIM_NLIMITS)
+ return -EINVAL;
+ if(rlim == nil)
+ return -EFAULT;
+
+ return -EPERM;
+}
+
projects / openbsd_emul.git / commitdiff