Subversion Repositories planix.SVN

#include        "mk.h"

typedef struct Event
{
        int pid;
        Job *job;
} Event;
static Event *events;
static int nevents, nrunning, nproclimit;

typedef struct Process
{
        int pid;
        int status;
        struct Process *b, *f;
} Process;
static Process *phead, *pfree;
static void sched(void);
static void pnew(int, int), pdelete(Process *);

int pidslot(int);

void
run(Job *j)
{
        Job *jj;

        if(jobs){
                for(jj = jobs; jj->next; jj = jj->next)
                        ;
                jj->next = j;
        } else 
                jobs = j;
        j->next = 0;
        /* this code also in waitup after parse redirect */
        if(nrunning < nproclimit)
                sched();
}

static void
sched(void)
{
        char *flags;
        Job *j;
        Bufblock *buf;
        int slot;
        Node *n;
        Envy *e;

        if(jobs == 0){
                usage();
                return;
        }
        j = jobs;
        jobs = j->next;
        if(DEBUG(D_EXEC))
                fprint(1, "firing up job for target %s\n", wtos(j->t, ' '));
        slot = nextslot();
        events[slot].job = j;
        buf = newbuf();
        e = buildenv(j, slot);
        shprint(j->r->recipe, e, buf);
        if(!tflag && (nflag || !(j->r->attr&QUIET)))
                Bwrite(&bout, buf->start, (long)strlen(buf->start));
        freebuf(buf);
        if(nflag||tflag){
                for(n = j->n; n; n = n->next){
                        if(tflag){
                                if(!(n->flags&VIRTUAL))
                                        touch(n->name);
                                else if(explain)
                                        Bprint(&bout, "no touch of virtual '%s'\n", n->name);
                        }
                        n->time = time((long *)0);
                        MADESET(n, MADE);
                }
        } else {
                if(DEBUG(D_EXEC))
                        fprint(1, "recipe='%s'\n", j->r->recipe);       /**/
                Bflush(&bout);
                if(j->r->attr&NOMINUSE)
                        flags = 0;
                else
                        flags = "-e";
                events[slot].pid = execsh(flags, j->r->recipe, 0, e);
                usage();
                nrunning++;
                if(DEBUG(D_EXEC))
                        fprint(1, "pid for target %s = %d\n", wtos(j->t, ' '), events[slot].pid);
        }
}

int
waitup(int echildok, int *retstatus)
{
        Envy *e;
        int pid;
        int slot;
        Symtab *s;
        Word *w;
        Job *j;
        char buf[ERRMAX];
        Bufblock *bp;
        int uarg = 0;
        int done;
        Node *n;
        Process *p;
        extern int runerrs;

        /* first check against the proces slist */
        if(retstatus)
                for(p = phead; p; p = p->f)
                        if(p->pid == *retstatus){
                                *retstatus = p->status;
                                pdelete(p);
                                return(-1);
                        }
again:          /* rogue processes */
        pid = waitfor(buf);
        if(pid == -1){
                if(echildok > 0)
                        return(1);
                else {
                        fprint(2, "mk: (waitup %d) ", echildok);
                        perror("mk wait");
                        Exit();
                }
        }
        if(DEBUG(D_EXEC))
                fprint(1, "waitup got pid=%d, status='%s'\n", pid, buf);
        if(retstatus && pid == *retstatus){
                *retstatus = buf[0]? 1:0;
                return(-1);
        }
        slot = pidslot(pid);
        if(slot < 0){
                if(DEBUG(D_EXEC))
                        fprint(2, "mk: wait returned unexpected process %d\n", pid);
                pnew(pid, buf[0]? 1:0);
                goto again;
        }
        j = events[slot].job;
        usage();
        nrunning--;
        events[slot].pid = -1;
        if(buf[0]){
                e = buildenv(j, slot);
                bp = newbuf();
                shprint(j->r->recipe, e, bp);
                front(bp->start);
                fprint(2, "mk: %s: exit status=%s", bp->start, buf);
                freebuf(bp);
                for(n = j->n, done = 0; n; n = n->next)
                        if(n->flags&DELETE){
                                if(done++ == 0)
                                        fprint(2, ", deleting");
                                fprint(2, " '%s'", n->name);
                                delete(n->name);
                        }
                fprint(2, "\n");
                if(kflag){
                        runerrs++;
                        uarg = 1;
                } else {
                        jobs = 0;
                        Exit();
                }
        }
        for(w = j->t; w; w = w->next){
                if((s = symlook(w->s, S_NODE, 0)) == 0)
                        continue;       /* not interested in this node */
                update(uarg, s->u.ptr);
        }
        if(nrunning < nproclimit)
                sched();
        return(0);
}

void
nproc(void)
{
        Symtab *sym;
        Word *w;

        if(sym = symlook("NPROC", S_VAR, 0)) {
                w = sym->u.ptr;
                if (w && w->s && w->s[0])
                        nproclimit = atoi(w->s);
        }
        if(nproclimit < 1)
                nproclimit = 1;
        if(DEBUG(D_EXEC))
                fprint(1, "nprocs = %d\n", nproclimit);
        if(nproclimit > nevents){
                if(nevents)
                        events = (Event *)Realloc((char *)events, nproclimit*sizeof(Event));
                else
                        events = (Event *)Malloc(nproclimit*sizeof(Event));
                while(nevents < nproclimit)
                        events[nevents++].pid = 0;
        }
}

int
nextslot(void)
{
        int i;

        for(i = 0; i < nproclimit; i++)
                if(events[i].pid <= 0) return i;
        assert(/*out of slots!!*/ 0);
        return 0;       /* cyntax */
}

int
pidslot(int pid)
{
        int i;

        for(i = 0; i < nevents; i++)
                if(events[i].pid == pid) return(i);
        if(DEBUG(D_EXEC))
                fprint(2, "mk: wait returned unexpected process %d\n", pid);
        return(-1);
}


static void
pnew(int pid, int status)
{
        Process *p;

        if(pfree){
                p = pfree;
                pfree = p->f;
        } else
                p = (Process *)Malloc(sizeof(Process));
        p->pid = pid;
        p->status = status;
        p->f = phead;
        phead = p;
        if(p->f)
                p->f->b = p;
        p->b = 0;
}

static void
pdelete(Process *p)
{
        if(p->f)
                p->f->b = p->b;
        if(p->b)
                p->b->f = p->f;
        else
                phead = p->f;
        p->f = pfree;
        pfree = p;
}

void
killchildren(char *msg)
{
        Process *p;

        kflag = 1;      /* to make sure waitup doesn't exit */
        jobs = 0;       /* make sure no more get scheduled */
        for(p = phead; p; p = p->f)
                expunge(p->pid, msg);
        while(waitup(1, (int *)0) == 0)
                ;
        Bprint(&bout, "mk: %s\n", msg);
        Exit();
}

static ulong tslot[1000];
static ulong tick;

void
usage(void)
{
        ulong t;

        t = time(0);
        if(tick)
                tslot[nrunning] += t - tick;
        tick = t;
}

void
prusage(void)
{
        int i;

        usage();
        for(i = 0; i <= nevents; i++)
                fprint(1, "%d: %lud\n", i, tslot[i]);
}