Subversion Repositories planix.SVN

#include        "u.h"
#include        "../port/lib.h"
#include        "mem.h"
#include        "dat.h"
#include        "fns.h"
#include        "error.h"
#include        <pool.h>

static void poolprint(Pool*, char*, ...);
static void ppanic(Pool*, char*, ...);
static void plock(Pool*);
static void punlock(Pool*);

typedef struct Private  Private;
struct Private {
        Lock            lk;
        char            msg[256];       /* a rock for messages to be printed at unlock */
};

static Private pmainpriv;
static Pool pmainmem = {
        .name=  "Main",
        .maxsize=       4*1024*1024,
        .minarena=      128*1024,
        .quantum=       32,
        .alloc= xalloc,
        .merge= xmerge,
        .flags= POOL_TOLERANCE,

        .lock=  plock,
        .unlock=        punlock,
        .print= poolprint,
        .panic= ppanic,

        .private=       &pmainpriv,
};

static Private pimagpriv;
static Pool pimagmem = {
        .name=  "Image",
        .maxsize=       16*1024*1024,
        .minarena=      2*1024*1024,
        .quantum=       32,
        .alloc= xalloc,
        .merge= xmerge,
        .flags= 0,

        .lock=  plock,
        .unlock=        punlock,
        .print= poolprint,
        .panic= ppanic,

        .private=       &pimagpriv,
};

Pool*   mainmem = &pmainmem;
Pool*   imagmem = &pimagmem;

/*
 * because we can't print while we're holding the locks, 
 * we have the save the message and print it once we let go.
 */
static void
poolprint(Pool *p, char *fmt, ...)
{
        va_list v;
        Private *pv;

        pv = p->private;
        va_start(v, fmt);
        vseprint(pv->msg+strlen(pv->msg), pv->msg+sizeof pv->msg, fmt, v);
        va_end(v);
}

static void
ppanic(Pool *p, char *fmt, ...)
{
        va_list v;
        Private *pv;
        char msg[sizeof pv->msg];

        pv = p->private;
        va_start(v, fmt);
        vseprint(pv->msg+strlen(pv->msg), pv->msg+sizeof pv->msg, fmt, v);
        va_end(v);
        memmove(msg, pv->msg, sizeof msg);
        iunlock(&pv->lk);
        panic("%s", msg);
}

static void
plock(Pool *p)
{
        Private *pv;

        pv = p->private;
        ilock(&pv->lk);
        pv->lk.pc = getcallerpc(&p);
        pv->msg[0] = 0;
}

static void
punlock(Pool *p)
{
        Private *pv;
        char msg[sizeof pv->msg];

        pv = p->private;
        if(pv->msg[0] == 0){
                iunlock(&pv->lk);
                return;
        }

        memmove(msg, pv->msg, sizeof msg);
        iunlock(&pv->lk);
        iprint("%.*s", sizeof pv->msg, msg);
}

void
poolsummary(Pool *p)
{
        print("%s max %lud cur %lud free %lud alloc %lud\n", p->name,
                p->maxsize, p->cursize, p->curfree, p->curalloc);
}

void
mallocsummary(void)
{
        poolsummary(mainmem);
        poolsummary(imagmem);
}

/* everything from here down should be the same in libc, libdebugmalloc, and the kernel */
/* - except the code for malloc(), which alternately doesn't clear or does. */
/* - except the code for smalloc(), which lives only in the kernel. */

/*
 * Npadlong is the number of 32-bit longs to leave at the beginning of 
 * each allocated buffer for our own bookkeeping.  We return to the callers
 * a pointer that points immediately after our bookkeeping area.  Incoming pointers
 * must be decremented by that much, and outgoing pointers incremented.
 * The malloc tag is stored at MallocOffset from the beginning of the block,
 * and the realloc tag at ReallocOffset.  The offsets are from the true beginning
 * of the block, not the beginning the caller sees.
 *
 * The extra if(Npadlong != 0) in various places is a hint for the compiler to
 * compile out function calls that would otherwise be no-ops.
 */

/*      non tracing
 *
enum {
        Npadlong        = 0,
        MallocOffset = 0,
        ReallocOffset = 0,
};
 *
 */

/* tracing */
enum {
        Npadlong        = 2,
        MallocOffset = 0,
        ReallocOffset = 1
};


void*
smalloc(ulong size)
{
        void *v;

        for(;;) {
                v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
                if(v != nil)
                        break;
                tsleep(&up->sleep, return0, 0, 100);
        }
        if(Npadlong){
                v = (ulong*)v+Npadlong;
                setmalloctag(v, getcallerpc(&size));
        }
        memset(v, 0, size);
        return v;
}

void*
malloc(ulong size)
{
        void *v;

        v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
        if(v == nil)
                return nil;
        if(Npadlong){
                v = (ulong*)v+Npadlong;
                setmalloctag(v, getcallerpc(&size));
                setrealloctag(v, 0);
        }
        memset(v, 0, size);
        return v;
}

void*
mallocz(ulong size, int clr)
{
        void *v;

        v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
        if(Npadlong && v != nil){
                v = (ulong*)v+Npadlong;
                setmalloctag(v, getcallerpc(&size));
                setrealloctag(v, 0);
        }
        if(clr && v != nil)
                memset(v, 0, size);
        return v;
}

void*
mallocalign(ulong size, ulong align, long offset, ulong span)
{
        void *v;

        v = poolallocalign(mainmem, size+Npadlong*sizeof(ulong), align, offset-Npadlong*sizeof(ulong), span);
        if(Npadlong && v != nil){
                v = (ulong*)v+Npadlong;
                setmalloctag(v, getcallerpc(&size));
                setrealloctag(v, 0);
        }
        if(v)
                memset(v, 0, size);
        return v;
}

void
free(void *v)
{
        if(v != nil)
                poolfree(mainmem, (ulong*)v-Npadlong);
}

void*
realloc(void *v, ulong size)
{
        void *nv;

        if(v != nil)
                v = (ulong*)v-Npadlong;
        if(Npadlong !=0 && size != 0)
                size += Npadlong*sizeof(ulong);

        if(nv = poolrealloc(mainmem, v, size)){
                nv = (ulong*)nv+Npadlong;
                setrealloctag(nv, getcallerpc(&v));
                if(v == nil)
                        setmalloctag(nv, getcallerpc(&v));
        }               
        return nv;
}

ulong
msize(void *v)
{
        return poolmsize(mainmem, (ulong*)v-Npadlong)-Npadlong*sizeof(ulong);
}

void*
calloc(ulong n, ulong szelem)
{
        void *v;
        if(v = mallocz(n*szelem, 1))
                setmalloctag(v, getcallerpc(&n));
        return v;
}

void
setmalloctag(void *v, ulong pc)
{
        ulong *u;
        USED(v, pc);
        if(Npadlong <= MallocOffset || v == nil)
                return;
        u = v;
        u[-Npadlong+MallocOffset] = pc;
}

void
setrealloctag(void *v, ulong pc)
{
        ulong *u;
        USED(v, pc);
        if(Npadlong <= ReallocOffset || v == nil)
                return;
        u = v;
        u[-Npadlong+ReallocOffset] = pc;
}

ulong
getmalloctag(void *v)
{
        USED(v);
        if(Npadlong <= MallocOffset)
                return ~0;
        return ((ulong*)v)[-Npadlong+MallocOffset];
}

ulong
getrealloctag(void *v)
{
        USED(v);
        if(Npadlong <= ReallocOffset)
                return ((ulong*)v)[-Npadlong+ReallocOffset];
        return ~0;
}