Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>
#include <mach.h>
#define Extern extern
#include "acid.h"
#include "y.tab.h"

static void install(int);

void
nocore(void)
{
        int i;

        if(cormap == 0)
                return;

        for (i = 0; i < cormap->nsegs; i++)
                if (cormap->seg[i].inuse && cormap->seg[i].fd >= 0)
                        close(cormap->seg[i].fd);
        free(cormap);
        cormap = 0;
}

void
sproc(int pid)
{
        Lsym *s;
        char buf[64];
        int i, fcor;

        if(symmap == 0)
                error("no map");

        snprint(buf, sizeof(buf), "/proc/%d/mem", pid);
        fcor = open(buf, ORDWR);
        if(fcor < 0)
                error("setproc: open %s: %r", buf);

        checkqid(symmap->seg[0].fd, pid);

        s = look("pid");
        s->v->ival = pid;

        nocore();
        cormap = attachproc(pid, kernel, fcor, &fhdr);
        if (cormap == 0)
                error("setproc: can't make coremap: %r");
        i = findseg(cormap, "text");
        if (i > 0)
                cormap->seg[i].name = "*text";
        i = findseg(cormap, "data");
        if (i > 0)
                cormap->seg[i].name = "*data";
        install(pid);
}

int
nproc(char **argv)
{
        char buf[128];
        int pid, i, fd;

        pid = fork();
        switch(pid) {
        case -1:
                error("new: fork %r");
        case 0:
                rfork(RFNAMEG|RFNOTEG);

                snprint(buf, sizeof(buf), "/proc/%d/ctl", getpid());
                fd = open(buf, ORDWR);
                if(fd < 0)
                        fatal("new: open %s: %r", buf);
                write(fd, "hang", 4);
                close(fd);

                close(0);
                close(1);
                close(2);
                for(i = 3; i < NFD; i++)
                        close(i);

                open("/dev/cons", OREAD);
                open("/dev/cons", OWRITE);
                open("/dev/cons", OWRITE);
                exec(argv[0], argv);
                fatal("new: exec %s: %r");
        default:
                install(pid);
                msg(pid, "waitstop");
                notes(pid);
                sproc(pid);
                dostop(pid);
                break;
        }

        return pid;
}

void
notes(int pid)
{
        Lsym *s;
        Value *v;
        int i, fd;
        char buf[128];
        List *l, **tail;

        s = look("notes");
        if(s == 0)
                return;
        v = s->v;

        snprint(buf, sizeof(buf), "/proc/%d/note", pid);
        fd = open(buf, OREAD);
        if(fd < 0)
                error("pid=%d: open note: %r", pid);

        v->set = 1;
        v->type = TLIST;
        v->l = 0;
        tail = &v->l;
        for(;;) {
                i = read(fd, buf, sizeof(buf));
                if(i <= 0)
                        break;
                buf[i] = '\0';
                l = al(TSTRING);
                l->string = strnode(buf);
                l->fmt = 's';
                *tail = l;
                tail = &l->next;
        }
        close(fd);
}

void
dostop(int pid)
{
        Lsym *s;
        Node *np, *p;

        s = look("stopped");
        if(s && s->proc) {
                np = an(ONAME, ZN, ZN);
                np->sym = s;
                np->fmt = 'D';
                np->type = TINT;
                p = con(pid);
                p->fmt = 'D';
                np = an(OCALL, np, p);
                execute(np);
        }
}

static void
install(int pid)
{
        Lsym *s;
        List *l;
        char buf[128];
        int i, fd, new, p;

        new = -1;
        for(i = 0; i < Maxproc; i++) {
                p = ptab[i].pid;
                if(p == pid)
                        return;
                if(p == 0 && new == -1)
                        new = i;
        }
        if(new == -1)
                error("no free process slots");

        snprint(buf, sizeof(buf), "/proc/%d/ctl", pid);
        fd = open(buf, OWRITE);
        if(fd < 0)
                error("pid=%d: open ctl: %r", pid);
        ptab[new].pid = pid;
        ptab[new].ctl = fd;

        s = look("proclist");
        l = al(TINT);
        l->fmt = 'D';
        l->ival = pid;
        l->next = s->v->l;
        s->v->l = l;
        s->v->set = 1;
}

void
deinstall(int pid)
{
        int i;
        Lsym *s;
        List *f, **d;

        for(i = 0; i < Maxproc; i++) {
                if(ptab[i].pid == pid) {
                        close(ptab[i].ctl);
                        ptab[i].pid = 0;
                        s = look("proclist");
                        d = &s->v->l;
                        for(f = *d; f; f = f->next) {
                                if(f->ival == pid) {
                                        *d = f->next;
                                        break;
                                }
                        }
                        s = look("pid");
                        if(s->v->ival == pid)
                                s->v->ival = 0;
                        return;
                }
        }
}

void
msg(int pid, char *msg)
{
        int i;
        int l;
        char err[ERRMAX];

        for(i = 0; i < Maxproc; i++) {
                if(ptab[i].pid == pid) {
                        l = strlen(msg);
                        if(write(ptab[i].ctl, msg, l) != l) {
                                errstr(err, sizeof err);
                                if(strcmp(err, "process exited") == 0)
                                        deinstall(pid);
                                error("msg: pid=%d %s: %s", pid, msg, err);
                        }
                        return;
                }
        }
        error("msg: pid=%d: not found for %s", pid, msg);
}

char *
getstatus(int pid)
{
        int fd, n;
        char *argv[16], buf[64];
        static char status[128];

        snprint(buf, sizeof(buf), "/proc/%d/status", pid);
        fd = open(buf, OREAD);
        if(fd < 0)
                error("open %s: %r", buf);

        n = read(fd, status, sizeof(status)-1);
        close(fd);
        if(n <= 0)
                error("read %s: %r", buf);
        status[n] = '\0';

        if(tokenize(status, argv, nelem(argv)-1) < 3)
                error("tokenize %s: %r", buf);

        return argv[2];
}

Waitmsg*
waitfor(int pid)
{
        Waitmsg *w;

        for(;;) {
                if((w = wait()) == nil)
                        error("wait %r");
                if(w->pid == pid)
                        return w;
                free(w);
        }
}