Subversion Repositories planix.SVN

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

char *VtServerLog = "libventi/server";

int ventilogging;
#define log     not_the_log_library_call

static char Eremoved[] = "[removed]";

enum
{       /* defaults */
        LogChunkSize = 8192,
        LogSize = 65536
};

static struct {
        QLock lk;
        VtLog *hash[1024];
} vl;

static uint
hash(char *s)
{
        uint h;
        uchar *p;

        h = 0;
        for(p=(uchar*)s; *p; p++)
                h = h*37 + *p;
        return h;
}

char**
vtlognames(int *pn)
{
        int i, nname, size;
        VtLog *l;
        char **s, *a, *e;
        
        qlock(&vl.lk);
        size = 0;
        nname = 0;
        for(i=0; i<nelem(vl.hash); i++)
        for(l=vl.hash[i]; l; l=l->next){
                nname++;
                size += strlen(l->name)+1;
        }
        
        s = vtmalloc(nname*sizeof(char*)+size);
        a = (char*)(s+nname);
        e = (char*)s+nname*sizeof(char*)+size;

        nname = 0;
        for(i=0; i<nelem(vl.hash); i++)
        for(l=vl.hash[i]; l; l=l->next){
                strcpy(a, l->name);
                s[nname++] = a;
                a += strlen(a)+1;
        }
        *pn = nname;
        assert(a == e);
        qunlock(&vl.lk);

        return s;
}

VtLog*
vtlogopen(char *name, uint size)
{
        uint h;
        int i, nc;
        char *p;
        VtLog *l, *last;

        if(!ventilogging)
                return nil;

        h = hash(name)%nelem(vl.hash);
        qlock(&vl.lk);
        last = nil;
        for(l=vl.hash[h]; l; last=l, l=l->next)
                if(strcmp(l->name, name) == 0){
                        if(last){       /* move to front */
                                last->next = l->next;
                                l->next = vl.hash[h];
                                vl.hash[h] = l;
                        }
                        l->ref++;
                        qunlock(&vl.lk);
                        return l;
                }

        if(size == 0){
                qunlock(&vl.lk);
                return nil;
        }

        /* allocate */
        nc = (size+LogChunkSize-1)/LogChunkSize;
        l = vtmalloc(sizeof *l + nc*(sizeof(*l->chunk)+LogChunkSize) + strlen(name)+1);
        memset(l, 0, sizeof *l);
        l->chunk = (VtLogChunk*)(l+1);
        l->nchunk = nc;
        l->w = l->chunk;
        p = (char*)(l->chunk+nc);
        for(i=0; i<nc; i++){
                l->chunk[i].p = p;
                l->chunk[i].wp = p;
                p += LogChunkSize;
                l->chunk[i].ep = p;
        }
        strcpy(p, name);
        l->name = p;
        
        /* insert */
        l->next = vl.hash[h];
        vl.hash[h] = l;
        l->ref++;
        
        l->ref++;
        qunlock(&vl.lk);
        return l;
}

void
vtlogclose(VtLog *l)
{
        if(l == nil)
                return;

        qlock(&vl.lk);
        if(--l->ref == 0){
                /* must not be in hash table */
                assert(l->name == Eremoved);
                free(l);
        }else
                assert(l->ref > 0);
        qunlock(&vl.lk);
}

void
vtlogremove(char *name)
{
        uint h;
        VtLog *last, *l;

        h = hash(name)%nelem(vl.hash);
        qlock(&vl.lk);
        last = nil;
        for(l=vl.hash[h]; l; last=l, l=l->next)
                if(strcmp(l->name, name) == 0){
                        if(last)
                                last->next = l->next;
                        else
                                vl.hash[h] = l->next;
                        l->name = Eremoved;
                        l->next = nil;
                        qunlock(&vl.lk);
                        vtlogclose(l);
                        return;
                }
        qunlock(&vl.lk);
}

static int
timefmt(Fmt *fmt)
{
        static uvlong t0;
        uvlong t;

        if(t0 == 0)
                t0 = nsec();
        t = nsec()-t0;
        return fmtprint(fmt, "T+%d.%04d", (uint)(t/1000000000), (uint)(t%1000000000)/100000);
}

void
vtlogvprint(VtLog *l, char *fmt, va_list arg)
{
        int n;
        char *p;
        VtLogChunk *c;
        static int first = 1;

        if(l == nil)
                return;
                
        if(first){
                fmtinstall('T', timefmt);
                first = 0;
        }
                
        
        qlock(&l->lk);
        c = l->w;
        n = c->ep - c->wp;
        if(n < 512){
                c++;
                if(c == l->chunk+l->nchunk)
                        c = l->chunk;
                c->wp = c->p;
                l->w = c;
        }
        p = vseprint(c->wp, c->ep, fmt, arg);
        if(p)
                c->wp = p;
        qunlock(&l->lk);
}

void
vtlogprint(VtLog *l, char *fmt, ...)
{
        va_list arg;
        
        if(l == nil)
                return;
                
        va_start(arg, fmt);
        vtlogvprint(l, fmt, arg);
        va_end(arg);
}

void
vtlog(char *name, char *fmt, ...)
{
        VtLog *l;
        va_list arg;

        l = vtlogopen(name, LogSize);
        if(l == nil)
                return;
        va_start(arg, fmt);
        vtlogvprint(l, fmt, arg);
        va_end(arg);
        vtlogclose(l);
}

void
vtlogdump(int fd, VtLog *l)
{
        int i;
        VtLogChunk *c;

        if(l == nil)
                return;
                
        c = l->w;
        for(i=0; i<l->nchunk; i++){
                if(++c == l->chunk+l->nchunk)
                        c = l->chunk;
                write(fd, c->p, c->wp-c->p);
        }
}