Subversion Repositories planix.SVN

#include "stdinc.h"

#include "9.h"

static struct {
        VtLock* lock;

        Fid*    free;
        int     nfree;
        int     inuse;
} fbox;

static void
fidLock(Fid* fid, int flags)
{
        if(flags & FidFWlock){
                vtLock(fid->lock);
                fid->flags = flags;
        }
        else
                vtRLock(fid->lock);

        /*
         * Callers of file* routines are expected to lock fsys->fs->elk
         * before making any calls in order to make sure the epoch doesn't
         * change underfoot. With the exception of Tversion and Tattach,
         * that implies all 9P functions need to lock on entry and unlock
         * on exit. Fortunately, the general case is the 9P functions do
         * fidGet on entry and fidPut on exit, so this is a convenient place
         * to do the locking.
         * No fsys->fs->elk lock is required if the fid is being created
         * (Tauth, Tattach and Twalk). FidFCreate is always accompanied by
         * FidFWlock so the setting and testing of FidFCreate here and in
         * fidUnlock below is always done under fid->lock.
         * A side effect is that fidFree is called with the fid locked, and
         * must call fidUnlock only after it has disposed of any File
         * resources still held.
         */
        if(!(flags & FidFCreate))
                fsysFsRlock(fid->fsys);
}

static void
fidUnlock(Fid* fid)
{
        if(!(fid->flags & FidFCreate))
                fsysFsRUnlock(fid->fsys);
        if(fid->flags & FidFWlock){
                fid->flags = 0;
                vtUnlock(fid->lock);
                return;
        }
        vtRUnlock(fid->lock);
}

static Fid*
fidAlloc(void)
{
        Fid *fid;

        vtLock(fbox.lock);
        if(fbox.nfree > 0){
                fid = fbox.free;
                fbox.free = fid->hash;
                fbox.nfree--;
        }
        else{
                fid = vtMemAllocZ(sizeof(Fid));
                fid->lock = vtLockAlloc();
                fid->alock = vtLockAlloc();
        }
        fbox.inuse++;
        vtUnlock(fbox.lock);

        fid->con = nil;
        fid->fidno = NOFID;
        fid->ref = 0;
        fid->flags = 0;
        fid->open = FidOCreate;
        assert(fid->fsys == nil);
        assert(fid->file == nil);
        fid->qid = (Qid){0, 0, 0};
        assert(fid->uid == nil);
        assert(fid->uname == nil);
        assert(fid->db == nil);
        assert(fid->excl == nil);
        assert(fid->rpc == nil);
        assert(fid->cuname == nil);
        fid->hash = fid->next = fid->prev = nil;

        return fid;
}

static void
fidFree(Fid* fid)
{
        if(fid->file != nil){
                fileDecRef(fid->file);
                fid->file = nil;
        }
        if(fid->db != nil){
                dirBufFree(fid->db);
                fid->db = nil;
        }
        fidUnlock(fid);

        if(fid->uid != nil){
                vtMemFree(fid->uid);
                fid->uid = nil;
        }
        if(fid->uname != nil){
                vtMemFree(fid->uname);
                fid->uname = nil;
        }
        if(fid->excl != nil)
                exclFree(fid);
        if(fid->rpc != nil){
                close(fid->rpc->afd);
                auth_freerpc(fid->rpc);
                fid->rpc = nil;
        }
        if(fid->fsys != nil){
                fsysPut(fid->fsys);
                fid->fsys = nil;
        }
        if(fid->cuname != nil){
                vtMemFree(fid->cuname);
                fid->cuname = nil;
        }

        vtLock(fbox.lock);
        fbox.inuse--;
        if(fbox.nfree < 10){
                fid->hash = fbox.free;
                fbox.free = fid;
                fbox.nfree++;
        }
        else{
                vtLockFree(fid->alock);
                vtLockFree(fid->lock);
                vtMemFree(fid);
        }
        vtUnlock(fbox.lock);
}

static void
fidUnHash(Fid* fid)
{
        Fid *fp, **hash;

        assert(fid->ref == 0);

        hash = &fid->con->fidhash[fid->fidno % NFidHash];
        for(fp = *hash; fp != nil; fp = fp->hash){
                if(fp == fid){
                        *hash = fp->hash;
                        break;
                }
                hash = &fp->hash;
        }
        assert(fp == fid);

        if(fid->prev != nil)
                fid->prev->next = fid->next;
        else
                fid->con->fhead = fid->next;
        if(fid->next != nil)
                fid->next->prev = fid->prev;
        else
                fid->con->ftail = fid->prev;
        fid->prev = fid->next = nil;

        fid->con->nfid--;
}

Fid*
fidGet(Con* con, u32int fidno, int flags)
{
        Fid *fid, **hash;

        if(fidno == NOFID)
                return nil;

        hash = &con->fidhash[fidno % NFidHash];
        vtLock(con->fidlock);
        for(fid = *hash; fid != nil; fid = fid->hash){
                if(fid->fidno != fidno)
                        continue;

                /*
                 * Already in use is an error
                 * when called from attach, clone or walk.
                 */
                if(flags & FidFCreate){
                        vtUnlock(con->fidlock);
                        vtSetError("%s: fid 0x%ud in use", argv0, fidno);
                        return nil;
                }
                fid->ref++;
                vtUnlock(con->fidlock);

                fidLock(fid, flags);
                if((fid->open & FidOCreate) || fid->fidno == NOFID){
                        fidPut(fid);
                        vtSetError("%s: fid invalid", argv0);
                        return nil;
                }
                return fid;
        }

        if((flags & FidFCreate) && (fid = fidAlloc()) != nil){
                assert(flags & FidFWlock);
                fid->con = con;
                fid->fidno = fidno;
                fid->ref = 1;

                fid->hash = *hash;
                *hash = fid;
                if(con->ftail != nil){
                        fid->prev = con->ftail;
                        con->ftail->next = fid;
                }
                else{
                        con->fhead = fid;
                        fid->prev = nil;
                }
                con->ftail = fid;
                fid->next = nil;

                con->nfid++;
                vtUnlock(con->fidlock);

                /*
                 * The FidOCreate flag is used to prevent any
                 * accidental access to the Fid between unlocking the
                 * hash and acquiring the Fid lock for return.
                 */
                fidLock(fid, flags);
                fid->open &= ~FidOCreate;
                return fid;
        }
        vtUnlock(con->fidlock);

        vtSetError("%s: fid not found", argv0);
        return nil;
}

void
fidPut(Fid* fid)
{
        vtLock(fid->con->fidlock);
        assert(fid->ref > 0);
        fid->ref--;
        vtUnlock(fid->con->fidlock);

        if(fid->ref == 0 && fid->fidno == NOFID){
                fidFree(fid);
                return;
        }
        fidUnlock(fid);
}

void
fidClunk(Fid* fid)
{
        assert(fid->flags & FidFWlock);

        vtLock(fid->con->fidlock);
        assert(fid->ref > 0);
        fid->ref--;
        fidUnHash(fid);
        fid->fidno = NOFID;
        vtUnlock(fid->con->fidlock);

        if(fid->ref > 0){
                /* not reached - fidUnHash requires ref == 0 */
                fidUnlock(fid);
                return;
        }
        fidFree(fid);
}

void
fidClunkAll(Con* con)
{
        Fid *fid;
        u32int fidno;

        vtLock(con->fidlock);
        while(con->fhead != nil){
                fidno = con->fhead->fidno;
                vtUnlock(con->fidlock);
                if((fid = fidGet(con, fidno, FidFWlock)) != nil)
                        fidClunk(fid);
                vtLock(con->fidlock);
        }
        vtUnlock(con->fidlock);
}

void
fidInit(void)
{
        fbox.lock = vtLockAlloc();
}