Return to qlock.c CVS log

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

Annotation of lucent/sys/src/9/port/qlock.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: 
        !             7: 
        !             8: void
        !             9: qlock(QLock *q)
        !            10: {
        !            11:        Proc *p, *mp;
        !            12: 
        !            13:        if(u)
        !            14:                u->p->qlockpc = getcallerpc(((uchar*)&q) - sizeof(q));
        !            15: 
        !            16:        lock(&q->use);
        !            17:        if(!q->locked) {
        !            18:                q->locked = 1;
        !            19:                unlock(&q->use);
        !            20:                return;
        !            21:        }
        !            22:        p = q->tail;
        !            23:        mp = u->p;
        !            24:        if(p == 0)
        !            25:                q->head = mp;
        !            26:        else
        !            27:                p->qnext = mp;
        !            28:        q->tail = mp;
        !            29:        mp->qnext = 0;
        !            30:        mp->state = Queueing;
        !            31:        unlock(&q->use);
        !            32:        sched();
        !            33: }
        !            34: 
        !            35: int
        !            36: canqlock(QLock *q)
        !            37: {
        !            38:        if(!canlock(&q->use))
        !            39:                return 0;
        !            40: 
        !            41:        if(q->locked){
        !            42:                unlock(&q->use);
        !            43:                return 0;
        !            44:        }
        !            45:        if(u)
        !            46:                u->p->qlockpc = getcallerpc(((uchar*)&q) - sizeof(q));
        !            47:        q->locked = 1;
        !            48:        unlock(&q->use);
        !            49:        return 1;
        !            50: }
        !            51: 
        !            52: void
        !            53: qunlock(QLock *q)
        !            54: {
        !            55:        Proc *p;
        !            56: 
        !            57:        if(u)
        !            58:                u->p->qlockpc = 0;
        !            59:        lock(&q->use);
        !            60:        p = q->head;
        !            61:        if(p) {
        !            62:                q->head = p->qnext;
        !            63:                if(q->head == 0)
        !            64:                        q->tail = 0;
        !            65:                unlock(&q->use);
        !            66:                ready(p);
        !            67:                return;
        !            68:        }
        !            69:        q->locked = 0;
        !            70:        unlock(&q->use);
        !            71: }
        !            72: 
        !            73: void
        !            74: rlock(RWlock *l)
        !            75: {
        !            76:        qlock(&l->x);           /* wait here for writers and exclusion */
        !            77:        lock(l);
        !            78:        l->readers++;
        !            79:        canqlock(&l->k);        /* block writers if we are the first reader */
        !            80:        unlock(l);
        !            81:        qunlock(&l->x);
        !            82: }
        !            83: 
        !            84: void
        !            85: runlock(RWlock *l)
        !            86: {
        !            87:        lock(l);
        !            88:        if(--l->readers == 0)   /* last reader out allows writers */
        !            89:                qunlock(&l->k);
        !            90:        unlock(l);
        !            91: }
        !            92: 
        !            93: void
        !            94: wlock(RWlock *l)
        !            95: {
        !            96:        qlock(&l->x);           /* wait here for writers and exclusion */
        !            97:        qlock(&l->k);           /* wait here for last reader */
        !            98: }
        !            99: 
        !           100: void
        !           101: wunlock(RWlock *l)
        !           102: {
        !           103:        qunlock(&l->x);
        !           104:        qunlock(&l->k);
        !           105: }

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