Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <oventi.h>

enum
{
        QueuingW,       /* queuing for write lock */
        QueuingR,       /* queuing for read lock */
};


typedef struct Thread Thread;

struct Thread {
        int pid;
        int ref;
        char *error;
        int state;
        Thread *next;
};

struct VtLock {
        Lock lk;
        Thread *writer;         /* thread writering write lock */
        int readers;            /* number writering read lock */
        Thread *qfirst;
        Thread *qlast;
        uintptr pc;
};

struct VtRendez {
        VtLock *lk;
        Thread *wfirst;
        Thread *wlast;
};

enum {
        ERROR = 0,
};

static Thread **vtRock;

static void     vtThreadInit(void);
static void     threadSleep(Thread*);
static void     threadWakeup(Thread*);

int
vtThread(void (*f)(void*), void *rock)
{
        int tid;

        tid = rfork(RFNOWAIT|RFMEM|RFPROC);
        switch(tid){
        case -1:
                vtOSError();
                return -1;
        case 0:
                break;
        default:
                return tid;
        }
        vtAttach();
        (*f)(rock);
        vtDetach();
        _exits(0);
        return 0;
}

static Thread *
threadLookup(void)
{
        return *vtRock;
}

void
vtAttach(void)
{
        int pid;
        Thread *p;
        static int init;
        static Lock lk;

        lock(&lk);
        if(!init) {
                rfork(RFREND);
                vtThreadInit();
                init = 1;
        }
        unlock(&lk);

        pid = getpid();
        p = *vtRock;
        if(p != nil && p->pid == pid) {
                p->ref++;
                return;
        }
        p = vtMemAllocZ(sizeof(Thread));
        p->ref = 1;
        p->pid = pid;
        *vtRock = p;
}

void
vtDetach(void)
{
        Thread *p;

        p = *vtRock;
        assert(p != nil);
        p->ref--;
        if(p->ref == 0) {
                vtMemFree(p->error);
                vtMemFree(p);
                *vtRock = nil;
        }
}

char *
vtGetError(void)
{
        char *s;

        if(ERROR)
                fprint(2, "vtGetError: %s\n", threadLookup()->error);
        s = threadLookup()->error;
        if(s == nil)
                return "unknown error";
        return s;
}

char*
vtSetError(char* fmt, ...)
{
        Thread *p;
        char *s;
        va_list args;

        p = threadLookup();

        va_start(args, fmt);
        s = vsmprint(fmt, args);
        vtMemFree(p->error);
        p->error = s;
        va_end(args);
        if(ERROR)
                fprint(2, "vtSetError: %s\n", p->error);
        werrstr("%s", p->error);
        return p->error;
}

static void
vtThreadInit(void)
{
        static Lock lk;

        lock(&lk);
        if(vtRock != nil) {
                unlock(&lk);
                return;
        }
        vtRock = privalloc();
        if(vtRock == nil)
                vtFatal("can't allocate thread-private storage");
        unlock(&lk);
}

VtLock*
vtLockAlloc(void)
{
        return vtMemAllocZ(sizeof(VtLock));
}

/*
 * RSC: I think the test is backward.  Let's see who uses it.
 *
void
vtLockInit(VtLock **p)
{
        static Lock lk;

        lock(&lk);
        if(*p != nil)
                *p = vtLockAlloc();
        unlock(&lk);
}
 */

void
vtLockFree(VtLock *p)
{
        if(p == nil)
                return;
        assert(p->writer == nil);
        assert(p->readers == 0);
        assert(p->qfirst == nil);
        vtMemFree(p);
}

VtRendez*
vtRendezAlloc(VtLock *p)
{
        VtRendez *q;

        q = vtMemAllocZ(sizeof(VtRendez));
        q->lk = p;
        setmalloctag(q, getcallerpc(&p));
        return q;
}

void
vtRendezFree(VtRendez *q)
{
        if(q == nil)
                return;
        assert(q->wfirst == nil);
        vtMemFree(q);
}

int
vtCanLock(VtLock *p)
{
        Thread *t;

        lock(&p->lk);
        t = *vtRock;
        if(p->writer == nil && p->readers == 0) {
                p->writer = t;
                unlock(&p->lk);
                return 1;
        }
        unlock(&p->lk);
        return 0;
}


void
vtLock(VtLock *p)
{
        Thread *t;

        lock(&p->lk);
        p->pc = getcallerpc(&p);
        t = *vtRock;
        if(p->writer == nil && p->readers == 0) {
                p->writer = t;
                unlock(&p->lk);
                return;
        }

        /*
         * venti currently contains code that assume locks can be passed between threads :-(
         * assert(p->writer != t);
         */

        if(p->qfirst == nil)
                p->qfirst = t;
        else
                p->qlast->next = t;
        p->qlast = t;
        t->next = nil;
        t->state = QueuingW;
        unlock(&p->lk);

        threadSleep(t);
        assert(p->writer == t && p->readers == 0);
}

int
vtCanRLock(VtLock *p)
{
        lock(&p->lk);
        if(p->writer == nil && p->qfirst == nil) {
                p->readers++;
                unlock(&p->lk);
                return 1;
        }
        unlock(&p->lk);
        return 0;
}

void
vtRLock(VtLock *p)
{
        Thread *t;

        lock(&p->lk);
        t = *vtRock;
        if(p->writer == nil && p->qfirst == nil) {
                p->readers++;
                unlock(&p->lk);
                return;
        }

        /*
         * venti currently contains code that assumes locks can be passed between threads
         * assert(p->writer != t);
         */
        if(p->qfirst == nil)
                p->qfirst = t;
        else
                p->qlast->next = t;
        p->qlast = t;
        t->next = nil;
        t->state = QueuingR;
        unlock(&p->lk);

        threadSleep(t);
        assert(p->writer == nil && p->readers > 0);
}

void
vtUnlock(VtLock *p)
{
        Thread *t, *tt;

        lock(&p->lk);
        /*
         * venti currently has code that assumes lock can be passed between threads :-)
         * assert(p->writer == *vtRock);
         */
        assert(p->writer != nil);
        assert(p->readers == 0);
        t = p->qfirst;
        if(t == nil) {
                p->writer = nil;
                unlock(&p->lk);
                return;
        }
        if(t->state == QueuingW) {
                p->qfirst = t->next;
                p->writer = t;
                unlock(&p->lk);

                threadWakeup(t);
                return;
        }

        p->writer = nil;
        while(t != nil && t->state == QueuingR) {
                tt = t;
                t = t->next;
                p->readers++;

                threadWakeup(tt);
        }
        p->qfirst = t;
        unlock(&p->lk);
}

void
vtRUnlock(VtLock *p)
{
        Thread *t;

        lock(&p->lk);
        assert(p->writer == nil && p->readers > 0);
        p->readers--;
        t = p->qfirst;
        if(p->readers > 0 || t == nil) {
                unlock(&p->lk);
                return;
        }
        assert(t->state == QueuingW);

        p->qfirst = t->next;
        p->writer = t;
        unlock(&p->lk);

        threadWakeup(t);
}

int
vtSleep(VtRendez *q)
{
        Thread *s, *t, *tt;
        VtLock *p;

        p = q->lk;
        lock(&p->lk);
        s = *vtRock;
        /*
         * venti currently contains code that assume locks can be passed between threads :-(
         * assert(p->writer != s);
         */
        assert(p->writer != nil);
        assert(p->readers == 0);
        t = p->qfirst;
        if(t == nil) {
                p->writer = nil;
        } else if(t->state == QueuingW) {
                p->qfirst = t->next;
                p->writer = t;
                threadWakeup(t);
        } else {
                p->writer = nil;
                while(t != nil && t->state == QueuingR) {
                        tt = t;
                        t = t->next;
                        p->readers++;
                        threadWakeup(tt);
                }
        }

        if(q->wfirst == nil)
                q->wfirst = s;
        else
                q->wlast->next = s;
        q->wlast = s;
        s->next = nil;
        unlock(&p->lk);

        threadSleep(s);
        assert(p->writer == s);
        return 1;
}

int
vtWakeup(VtRendez *q)
{
        Thread *t;
        VtLock *p;

        /*
         * take off wait and put on front of queue
         * put on front so guys that have been waiting will not get starved
         */
        p = q->lk;
        lock(&p->lk);
        /*
         * venti currently has code that assumes lock can be passed between threads :-)
         * assert(p->writer == *vtRock);
         */
        assert(p->writer != nil);
        t = q->wfirst;
        if(t == nil) {
                unlock(&p->lk);
                return 0;
        }
        q->wfirst = t->next;
        if(p->qfirst == nil)
                p->qlast = t;
        t->next = p->qfirst;
        p->qfirst = t;
        t->state = QueuingW;
        unlock(&p->lk);

        return 1;
}

int
vtWakeupAll(VtRendez *q)
{
        int i;

        for(i=0; vtWakeup(q); i++)
                ;
        return i;
}

static void
threadSleep(Thread *t)
{
        if(rendezvous(t, (void*)0x22bbdfd6) != (void*)0x44391f14)
                sysfatal("threadSleep: rendezvous failed: %r");
}

static void
threadWakeup(Thread *t)
{
        if(rendezvous(t, (void*)0x44391f14) != (void*)0x22bbdfd6)
                sysfatal("threadWakeup: rendezvous failed: %r");
}