Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <thread.h>

enum {
        Stacksize       = 8*1024,
        Bufsize         = 8*1024,
};

Channel *out;
Channel *quit;
Channel *forkc;
int nread = 0;

typedef struct Str Str;
struct Str {
        char    *buf;
        int     len;
};

void
die(char *s)
{
        fprint(2, "%s\n", s);
        exits(s);
}

void
cwrite(int fd, char *path, char *cmd, int len)
{
        werrstr("");
        if (write(fd, cmd, len) < len) {
                fprint(2, "cwrite: %s: failed writing %d bytes: %r\n",
                        path, len);
                sendp(quit, nil);
                threadexits(nil);
        }
}

Str *
newstr(void)
{
        Str *s;

        s = mallocz(sizeof(Str) + Bufsize, 1);
        if (s == nil)
                sysfatal("malloc");
        s->buf = (char *)&s[1];
        return s;
}

void
reader(void *v)
{
        int cfd, tfd, forking = 0, exiting, pid, newpid;
        char *ctl, *truss;
        Str *s;
        static char start[] = "start";
        static char waitstop[] = "waitstop";

        pid = (int)(uintptr)v;
        ctl = smprint("/proc/%d/ctl", pid);
        if ((cfd = open(ctl, OWRITE)) < 0)
                die(smprint("%s: %r", ctl));
        truss = smprint("/proc/%d/syscall", pid);
        if ((tfd = open(truss, OREAD)) < 0)
                die(smprint("%s: %r", truss));

        /* child was stopped by hang msg earlier */
        cwrite(cfd, ctl, waitstop, sizeof waitstop - 1);

        cwrite(cfd, ctl, "startsyscall", 12);
        s = newstr();
        exiting = 0;
        while((s->len = pread(tfd, s->buf, Bufsize - 1, 0)) >= 0){
                if (forking && s->buf[1] == '=' && s->buf[3] != '-') {
                        forking = 0;
                        newpid = strtol(&s->buf[3], 0, 0);
                        sendp(forkc, (void*)newpid);
                        procrfork(reader, (void*)newpid, Stacksize, 0);
                }

                /*
                 * There are three tests here and they (I hope) guarantee
                 * no false positives.
                 */
                if (strstr(s->buf, " Rfork") != nil) {
                        char *a[8];
                        char *rf;

                        rf = strdup(s->buf);
                        if (tokenize(rf, a, 8) == 5 &&
                            strtoul(a[4], 0, 16) & RFPROC)
                                forking = 1;
                        free(rf);
                } else if (strstr(s->buf, " Exits") != nil)
                        exiting = 1;

                sendp(out, s);  /* print line from /proc/$child/syscall */
                if (exiting) {
                        s = newstr();
                        strcpy(s->buf, "\n");
                        sendp(out, s);
                        break;
                }

                /* flush syscall trace buffer */
                cwrite(cfd, ctl, "startsyscall", 12);
                s = newstr();
        }

        sendp(quit, nil);
        threadexitsall(nil);
}

void
writer(void *)
{
        int newpid;
        Alt a[4];
        Str *s;

        a[0].op = CHANRCV;
        a[0].c = quit;
        a[0].v = nil;
        a[1].op = CHANRCV;
        a[1].c = out;
        a[1].v = &s;
        a[2].op = CHANRCV;
        a[2].c = forkc;
        a[2].v = &newpid;
        a[3].op = CHANEND;

        for(;;)
                switch(alt(a)){
                case 0:                  /* quit */
                        nread--;
                        if(nread <= 0)
                                goto done;
                        break;
                case 1:                 /* out */
                        /* it's a nice null terminated thing */
                        fprint(2, "%s", s->buf);
                        free(s);
                        break;
                case 2:                 /* forkc */
                        // procrfork(reader, (void*)newpid, Stacksize, 0);
                        nread++;
                        break;
                }
done:
        exits(nil);
}

void
usage(void)
{
        fprint(2, "Usage: ratrace [-c cmd [arg...]] | [pid]\n");
        exits("usage");
}

void
hang(void)
{
        int me;
        char *myctl;
        static char hang[] = "hang";

        myctl = smprint("/proc/%d/ctl", getpid());
        me = open(myctl, OWRITE);
        if (me < 0)
                sysfatal("can't open %s: %r", myctl);
        cwrite(me, myctl, hang, sizeof hang - 1);
        close(me);
        free(myctl);
}

void
threadmain(int argc, char **argv)
{
        int pid;
        char *cmd = nil;
        char **args = nil;

        /*
         * don't bother with fancy arg processing, because it picks up options
         * for the command you are starting.  Just check for -c as argv[1]
         * and then take it from there.
         */
        if (argc < 2)
                usage();
        while (argv[1][0] == '-') {
                switch(argv[1][1]) {
                case 'c':
                        if (argc < 3)
                                usage();
                        cmd = strdup(argv[2]);
                        args = &argv[2];
                        break;
                default:
                        usage();
                }
                ++argv;
                --argc;
        }

        /* run a command? */
        if(cmd) {
                pid = fork();
                if (pid < 0)
                        sysfatal("fork failed: %r");
                if(pid == 0) {
                        hang();
                        exec(cmd, args);
                        if(cmd[0] != '/')
                                exec(smprint("/bin/%s", cmd), args);
                        sysfatal("exec %s failed: %r", cmd);
                }
        } else {
                if(argc != 2)
                        usage();
                pid = atoi(argv[1]);
        }

        out   = chancreate(sizeof(char*), 0);
        quit  = chancreate(sizeof(char*), 0);
        forkc = chancreate(sizeof(ulong *), 0);
        nread++;
        procrfork(writer, nil, Stacksize, 0);
        reader((void*)pid);
}