123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330 |
- #include <u.h>
- #include <libc.h>
- #include <pool.h>
- static void* sbrkalloc(ulong);
- static int sbrkmerge(void*, void*);
- static void plock(Pool*);
- static void punlock(Pool*);
- static void pprint(Pool*, char*, ...);
- static void ppanic(Pool*, char*, ...);
- typedef struct Private Private;
- struct Private {
- Lock lk;
- int printfd; /* gets debugging output if set */
- };
- Private sbrkmempriv;
- static Pool sbrkmem = {
- .name= "sbrkmem",
- .maxsize= 2UL*1024*1024*1024,
- .minarena= 4*1024,
- .quantum= 32,
- .alloc= sbrkalloc,
- .merge= sbrkmerge,
- .flags= 0,
- .lock= plock,
- .unlock= punlock,
- .print= pprint,
- .panic= ppanic,
- .private= &sbrkmempriv,
- };
- Pool *mainmem = &sbrkmem;
- Pool *imagmem = &sbrkmem;
- /*
- * we do minimal bookkeeping so we can tell pool
- * whether two blocks are adjacent and thus mergeable.
- */
- static void*
- sbrkalloc(ulong n)
- {
- ulong *x;
- n += 2*sizeof(ulong); /* two longs for us */
- x = sbrk(n);
- if((int)x == -1)
- return nil;
- x[0] = (n+7)&~7; /* sbrk rounds size up to mult. of 8 */
- x[1] = 0xDeadBeef;
- return x+2;
- }
- static int
- sbrkmerge(void *x, void *y)
- {
- ulong *lx, *ly;
- lx = x;
- if(lx[-1] != 0xDeadBeef)
- abort();
- if((uchar*)lx+lx[-2] == (uchar*)y) {
- ly = y;
- lx[-2] += ly[-2];
- return 1;
- }
- return 0;
- }
- static void
- plock(Pool *p)
- {
- Private *pv;
- pv = p->private;
- lock(&pv->lk);
- }
- static void
- punlock(Pool *p)
- {
- Private *pv;
- pv = p->private;
- unlock(&pv->lk);
- }
- static int
- checkenv(void)
- {
- int n, fd;
- char buf[20];
- fd = open("/env/MALLOCFD", OREAD);
- if(fd < 0)
- return -1;
- if((n = read(fd, buf, sizeof buf)) < 0) {
- close(fd);
- return -1;
- }
- if(n >= sizeof buf)
- n = sizeof(buf)-1;
- buf[n] = 0;
- n = atoi(buf);
- if(n == 0)
- n = -1;
- return n;
- }
- static void
- pprint(Pool *p, char *fmt, ...)
- {
- va_list v;
- Private *pv;
- pv = p->private;
- if(pv->printfd == 0)
- pv->printfd = checkenv();
- if(pv->printfd <= 0)
- pv->printfd = 2;
- va_start(v, fmt);
- vfprint(pv->printfd, fmt, v);
- va_end(v);
- }
- static char panicbuf[256];
- static void
- ppanic(Pool *p, char *fmt, ...)
- {
- va_list v;
- int n;
- char *msg;
- Private *pv;
- pv = p->private;
- assert(canlock(&pv->lk)==0);
- if(pv->printfd == 0)
- pv->printfd = checkenv();
- if(pv->printfd <= 0)
- pv->printfd = 2;
- msg = panicbuf;
- va_start(v, fmt);
- n = vseprint(msg, msg+sizeof panicbuf, fmt, v) - msg;
- write(2, "panic: ", 7);
- write(2, msg, n);
- write(2, "\n", 1);
- if(pv->printfd != 2){
- write(pv->printfd, "panic: ", 7);
- write(pv->printfd, msg, n);
- write(pv->printfd, "\n", 1);
- }
- va_end(v);
- unlock(&pv->lk);
- abort();
- }
- /* - 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. - */
- /*
- * 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*
- malloc(ulong size)
- {
- void *v;
- v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
- if(Npadlong && v != nil) {
- v = (ulong*)v+Npadlong;
- setmalloctag(v, getcallerpc(&size));
- setrealloctag(v, 0);
- }
- 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);
- }
- return v;
- }
- void
- free(void *v)
- {
- if(v != nil)
- poolfree(mainmem, (ulong*)v-Npadlong);
- }
- void*
- realloc(void *v, ulong size)
- {
- void *nv;
- if(size == 0){
- free(v);
- return nil;
- }
- if(v)
- v = (ulong*)v-Npadlong;
- 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;
- }
- void*
- malloctopoolblock(void *v)
- {
- if(v == nil)
- return nil;
- return &((ulong*)v)[-Npadlong];
- }
|