> cinap is right, the bug is in the kernel.  we know
> that because it's a lock loop.  that can only happen
> if the kernel screws up.  also, the address is a kernel
> address (starts with 0xf).

Well, here is an acid dump, I'll inspect it in detail, but I'm hoping
someone will beat me to it (not hard at all, I have to confess):

rumble# acid /sys/src/9/pc/9pccpuf
/sys/src/9/pc/9pccpuf:386 plan 9 boot image
/sys/lib/acid/port
/sys/lib/acid/386

# lock 0xf0057d74 loop key 0xdeaddead pc 0xf01e736a held by pc 0xf01e736a proc 
2052

acid: src(0xf01e736a)
/sys/src/9/port/qlock.c:29
 24                     print("qlock: %#p: nlocks %lud\n", getcallerpc(&q), 
up->nlocks.ref);
 25     
 26             if(q->use.key == 0x55555555)
 27                     panic("qlock: q %#p, key 5*\n", q);
 28             lock(&q->use);
>29             rwstats.qlock++;
 30             if(!q->locked) {
 31                     q->locked = 1;
 32                     unlock(&q->use);
 33                     return;
 34             }

# 61:etherread4 pc f01ef8a0 dbgpc        0   Running (Running) ut 2923 st 0 bss 
0 qpc f0148c8a nl 0 nd 0 lpc f0100f6e pri 13

acid: src(0xf01ef8a0)
/sys/src/9/port/taslock.c:96
 91             lockstats.glare++;
 92             for(;;){
 93                     lockstats.inglare++;
 94                     i = 0;
 95                     while(l->key){
>96                             if(conf.nmach < 2 && up && up->edf && 
>(up->edf->flags & Admitted)){
 97                                     /*
 98                                      * Priority inversion, yield on a 
uniprocessor; on a
 99                                      * multiprocessor, the other processor 
will unlock
 100                                     */
 101                                    print("inversion %#p pc %#lux proc %lud 
held by pc %#lux proc %lud\n",
acid: src(0xf0148c8a)
/sys/src/9/ip/tcp.c:2096
 2091           if(waserror()){
 2092                   qunlock(s);
 2093                   nexterror();
 2094           }
 2095           qlock(s);
>2096           qunlock(tcp);
 2097   
 2098           /* fix up window */
 2099           seg.wnd <<= tcb->rcv.scale;
 2100   
 2101           /* every input packet in puts off the keep alive time out */
acid: src(0xf0100f6e)
/sys/src/9/pc/cga.c:112
 107                            return;
 108            }
 109            else
 110                    lock(&cgascreenlock);
 111    
>112            while(n-- > 0)
 113                    cgascreenputc(*s++);
 114    
 115            unlock(&cgascreenlock);
 116    }
 117    

# 2052:  exportfs pc f01e7377 dbgpc     94ad    Pwrite (Ready) ut 55 st 270 bss 
40000 qpc f0145b62 nl 1 nd 0 lpc f01e2c60 pri 10

acid: src(0xf01e7377)
/sys/src/9/port/qlock.c:30
 25     
 26             if(q->use.key == 0x55555555)
 27                     panic("qlock: q %#p, key 5*\n", q);
 28             lock(&q->use);
 29             rwstats.qlock++;
>30             if(!q->locked) {
 31                     q->locked = 1;
 32                     unlock(&q->use);
 33                     return;
 34             }
 35             if(up == 0)
acid: src(0xf0145b62)
/sys/src/9/ip/tcp.c:704
 699    tcpgo(Tcppriv *priv, Tcptimer *t)
 700    {
 701            if(t == nil || t->start == 0)
 702                    return;
 703    
>704            qlock(&priv->tl);
 705            t->count = t->start;
 706            timerstate(priv, t, TcptimerON);
 707            qunlock(&priv->tl);
 708    }
 709    
acid: src(0xf01e2c60)
/sys/src/9/port/proc.c:345
 340    queueproc(Schedq *rq, Proc *p)
 341    {
 342            int pri;
 343    
 344            pri = rq - runq;
>345            lock(runq);
 346            p->priority = pri;
 347            p->rnext = 0;
 348            if(rq->tail)
 349                    rq->tail->rnext = p;
 350            else
acid: 


Reply via email to