fix fuckup

[plan9front.git] / sys / src / 9 / port / proc.c

diff --git a/sys/src/9/port/proc.c b/sys/src/9/port/proc.c
index 58fbc7a8b9757ee1fb98cf6e991c1dc0f2fbb325..eadca93ec267f133c7804114f99c2e5527c33d45 100644 (file)
--- a/sys/src/9/port/proc.c
+++ b/sys/src/9/port/proc.c
@@ -1387,7 +1387,7 @@ kproc(char *name, void (*func)(void *), void *arg)
        p->s = up->s;
        p->nerrlab = 0;
        p->slash = up->slash;
-       p->dot = up->dot;
+       p->dot = up->slash;     /* unlike fork, do not inherit the dot for kprocs */
        if(p->dot != nil)
                incref(p->dot);
 
@@ -1420,12 +1420,12 @@ kproc(char *name, void (*func)(void *), void *arg)
  *  reasoning.
  */
 void
-procctl(Proc *p)
+procctl(void)
 {
        char *state;
        ulong s;
 
-       switch(p->procctl) {
+       switch(up->procctl) {
        case Proc_exitbig:
                spllo();
                pprint("Killed: Insufficient physical memory\n");
@@ -1436,26 +1436,26 @@ procctl(Proc *p)
                pexit("Killed", 1);
 
        case Proc_traceme:
-               if(p->nnote == 0)
+               if(up->nnote == 0)
                        return;
                /* No break */
 
        case Proc_stopme:
-               p->procctl = 0;
-               state = p->psstate;
-               p->psstate = "Stopped";
+               up->procctl = 0;
+               state = up->psstate;
+               up->psstate = "Stopped";
                /* free a waiting debugger */
                s = spllo();
-               qlock(&p->debug);
-               if(p->pdbg != nil) {
-                       wakeup(&p->pdbg->sleep);
-                       p->pdbg = nil;
+               qlock(&up->debug);
+               if(up->pdbg != nil) {
+                       wakeup(&up->pdbg->sleep);
+                       up->pdbg = nil;
                }
-               qunlock(&p->debug);
+               qunlock(&up->debug);
                splhi();
-               p->state = Stopped;
+               up->state = Stopped;
                sched();
-               p->psstate = state;
+               up->psstate = state;
                splx(s);
                return;
        }
@@ -1491,6 +1491,32 @@ exhausted(char *resource)
        error(buf);
 }
 
+ulong
+procpagecount(Proc *p)
+{
+       Segment *s;
+       ulong pages;
+       int i;
+
+       eqlock(&p->seglock);
+       if(waserror()){
+               qunlock(&p->seglock);
+               nexterror();
+       }
+       pages = 0;
+       for(i=0; i<NSEG; i++){
+               if((s = p->seg[i]) != nil){
+                       eqlock(s);
+                       pages += mcountseg(s);
+                       qunlock(s);
+               }
+       }
+       qunlock(&p->seglock);
+       poperror();
+
+       return pages;
+}
+
 void
 killbig(char *why)
 {
@@ -1503,25 +1529,20 @@ killbig(char *why)
        kp = nil;
        ep = procalloc.arena+conf.nproc;
        for(p = procalloc.arena; p < ep; p++) {
-               if(p->state == Dead || p->kp || !canqlock(&p->seglock))
+               if(p->state == Dead || p->kp)
                        continue;
-               l = 0;
-               for(i=1; i<NSEG; i++) {
-                       s = p->seg[i];
-                       if(s == nil || !canqlock(s))
-                               continue;
-                       l += mcountseg(s);
-                       qunlock(s);
-               }
-               qunlock(&p->seglock);
-               if(l > max && ((p->procmode&0222) || strcmp(eve, p->user)!=0)) {
+               if((p->noswap || (p->procmode & 0222) == 0) && strcmp(eve, p->user) == 0)
+                       continue;
+               l = procpagecount(p);
+               if(l > max){
                        kp = p;
                        max = l;
                }
        }
-       if(kp == nil || !canqlock(&kp->seglock))
+       if(kp == nil)
                return;
        print("%lud: %s killed: %s\n", kp->pid, kp->text, why);
+       qlock(&kp->seglock);
        for(p = procalloc.arena; p < ep; p++) {
                if(p->state == Dead || p->kp)
                        continue;
@@ -1531,10 +1552,17 @@ killbig(char *why)
        kp->procctl = Proc_exitbig;
        for(i = 0; i < NSEG; i++) {
                s = kp->seg[i];
-               if(s != nil && canqlock(s)) {
-                       mfreeseg(s, s->base, (s->top - s->base)/BY2PG);
-                       qunlock(s);
+               if(s == nil)
+                       continue;
+               switch(s->type & SG_TYPE){
+               case SG_SHARED:
+               case SG_PHYSICAL:
+               case SG_FIXED:
+                       continue;
                }
+               qlock(s);
+               mfreeseg(s, s->base, (s->top - s->base)/BY2PG);
+               qunlock(s);
        }
        qunlock(&kp->seglock);
 }
@@ -1574,14 +1602,14 @@ accounttime(void)
        n = perfticks();
        per = n - m->perf.last;
        m->perf.last = n;
-       per = (m->perf.period*(HZ-1) + per)/HZ;
+       per = ((uvlong)m->perf.period*(HZ-1) + per)/HZ;
        if(per != 0)
                m->perf.period = per;
 
-       m->perf.avg_inidle = (m->perf.avg_inidle*(HZ-1)+m->perf.inidle)/HZ;
+       m->perf.avg_inidle = ((uvlong)m->perf.avg_inidle*(HZ-1)+m->perf.inidle)/HZ;
        m->perf.inidle = 0;
 
-       m->perf.avg_inintr = (m->perf.avg_inintr*(HZ-1)+m->perf.inintr)/HZ;
+       m->perf.avg_inintr = ((uvlong)m->perf.avg_inintr*(HZ-1)+m->perf.inintr)/HZ;
        m->perf.inintr = 0;
 
        /* only one processor gets to compute system load averages */
@@ -1599,8 +1627,9 @@ accounttime(void)
         */
        n = nrun;
        nrun = 0;
-       n = (nrdy+n)*1000;
-       m->load = (m->load*(HZ-1)+n)/HZ;
+       n = (nrdy+n)*1000*100;
+       load = ((uvlong)load*(HZ-1)+n)/HZ;
+       m->load = load/100;
 }
 
 int