Return to taslock.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/taslock.c, revision 1.1

1.1     ! root        1: #include "u.h"
        !             2: #include "../port/lib.h"
        !             3: #include "mem.h"
        !             4: #include "dat.h"
        !             5: #include "fns.h"
        !             6: #include "../port/error.h"
        !             7: 
        !             8: void
        !             9: lock(Lock *l)
        !            10: {
        !            11:        int i;
        !            12:        ulong pc;
        !            13: 
        !            14:        pc = getcallerpc(((uchar*)&l) - sizeof(l));
        !            15: 
        !            16:        for(i = 0; i < 10000000; i++){
        !            17:                if (tas(&l->key) == 0){
        !            18:                        if(u)
        !            19:                                u->p->hasspin = 1;
        !            20:                        l->pc = pc;
        !            21:                        return;
        !            22:                }
        !            23:        }
        !            24:        l->key = 0;
        !            25:        panic("lock loop 0x%lux key 0x%lux pc 0x%lux held by pc 0x%lux\n",
        !            26:                        l->key, i, pc, l->pc);
        !            27: }
        !            28: 
        !            29: void
        !            30: ilock(Lock *l)
        !            31: {
        !            32:        int i;
        !            33:        ulong pc;
        !            34:        ulong x;
        !            35: 
        !            36:        pc = getcallerpc(((uchar*)&l) - sizeof(l));
        !            37: 
        !            38:        x = splhi();
        !            39:        for(i = 0; i < 10000000; i++){
        !            40:                if (tas(&l->key) == 0){
        !            41:                        l->pc = pc;
        !            42:                        l->sr = x;
        !            43:                        return;
        !            44:                }
        !            45:        }
        !            46:        l->key = 0;
        !            47:        splx(x);
        !            48:        panic("lock loop 0x%lux key 0x%lux pc 0x%lux held by pc 0x%lux\n",
        !            49:                        l->key, i, pc, l->pc);
        !            50: }
        !            51: 
        !            52: int
        !            53: canlock(Lock *l)
        !            54: {
        !            55:        if(tas(&l->key))
        !            56:                return 0;
        !            57:        l->pc = getcallerpc(((uchar*)&l) - sizeof(l));
        !            58:        if(u && u->p)
        !            59:                u->p->hasspin = 1;
        !            60:        return 1;
        !            61: }
        !            62: 
        !            63: void
        !            64: unlock(Lock *l)
        !            65: {
        !            66:        l->pc = 0;
        !            67:        l->key = 0;
        !            68:        if(u && u->p)
        !            69:                u->p->hasspin = 0;
        !            70: }
        !            71: 
        !            72: void
        !            73: iunlock(Lock *l)
        !            74: {
        !            75:        ulong sr;
        !            76: 
        !            77:        sr = l->sr;
        !            78:        l->pc = 0;
        !            79:        l->key = 0;
        !            80:        splx(sr);
        !            81: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.