From b7b3406657ef87fef57c3b639296d5cd33a5c3ae Mon Sep 17 00:00:00 2001 From: cinap_lenrek Date: Sun, 2 Feb 2014 16:03:59 +0100 Subject: [PATCH] malloctag: only store lower 32bit of malloc tag, fix getrealloctag as erik quanstro suggests, theres not much of a point in storing the full 64bit pc as one cannot get a code segment bigger than 4G and amd64 makes it hard to use a pc that isnt 64bit sign extension of 32bit. instead, we only store ulong (as originally), but sign extend back when returning in getmalloctag() and getrealloctag(). getrealloctag() used to be broken. its now fixed. --- sys/src/9/port/alloc.c | 42 +++++++++++++++++--------------------- sys/src/libc/port/malloc.c | 41 ++++++++++++++++--------------------- 2 files changed, 37 insertions(+), 46 deletions(-) diff --git a/sys/src/9/port/alloc.c b/sys/src/9/port/alloc.c index b88475e66..fd3e41690 100644 --- a/sys/src/9/port/alloc.c +++ b/sys/src/9/port/alloc.c @@ -135,7 +135,7 @@ mallocsummary(void) /* - except the code for smalloc(), which lives only in the kernel. */ /* - * Npadlong is the number of uintptr's to leave at the beginning of + * Npadlong is the number of ulong's 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. @@ -171,7 +171,7 @@ smalloc(ulong size) void *v; for(;;) { - v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr)); + v = poolalloc(mainmem, size+Npadlong*sizeof(ulong)); if(v != nil) break; if(!waserror()){ @@ -180,7 +180,7 @@ smalloc(ulong size) } } if(Npadlong){ - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); } memset(v, 0, size); @@ -192,11 +192,11 @@ malloc(ulong size) { void *v; - v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr)); + v = poolalloc(mainmem, size+Npadlong*sizeof(ulong)); if(v == nil) return nil; if(Npadlong){ - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); setrealloctag(v, 0); } @@ -209,9 +209,9 @@ mallocz(ulong size, int clr) { void *v; - v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr)); + v = poolalloc(mainmem, size+Npadlong*sizeof(ulong)); if(Npadlong && v != nil){ - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); setrealloctag(v, 0); } @@ -225,9 +225,9 @@ mallocalign(ulong size, ulong align, long offset, ulong span) { void *v; - v = poolallocalign(mainmem, size+Npadlong*sizeof(uintptr), align, offset-Npadlong*sizeof(uintptr), span); + v = poolallocalign(mainmem, size+Npadlong*sizeof(ulong), align, offset-Npadlong*sizeof(ulong), span); if(Npadlong && v != nil){ - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); setrealloctag(v, 0); } @@ -240,7 +240,7 @@ void free(void *v) { if(v != nil) - poolfree(mainmem, (uintptr*)v-Npadlong); + poolfree(mainmem, (ulong*)v-Npadlong); } void* @@ -249,12 +249,12 @@ realloc(void *v, ulong size) void *nv; if(v != nil) - v = (uintptr*)v-Npadlong; + v = (ulong*)v-Npadlong; if(Npadlong !=0 && size != 0) - size += Npadlong*sizeof(uintptr); + size += Npadlong*sizeof(ulong); if(nv = poolrealloc(mainmem, v, size)){ - nv = (uintptr*)nv+Npadlong; + nv = (ulong*)nv+Npadlong; setrealloctag(nv, getcallerpc(&v)); if(v == nil) setmalloctag(nv, getcallerpc(&v)); @@ -265,7 +265,7 @@ realloc(void *v, ulong size) ulong msize(void *v) { - return poolmsize(mainmem, (uintptr*)v-Npadlong)-Npadlong*sizeof(uintptr); + return poolmsize(mainmem, (ulong*)v-Npadlong)-Npadlong*sizeof(ulong); } void* @@ -280,23 +280,19 @@ calloc(ulong n, ulong szelem) void setmalloctag(void *v, uintptr pc) { - uintptr *u; USED(v, pc); if(Npadlong <= MallocOffset || v == nil) return; - u = v; - u[-Npadlong+MallocOffset] = pc; + ((ulong*)v)[-Npadlong+MallocOffset] = (ulong)pc; } void setrealloctag(void *v, uintptr pc) { - uintptr *u; USED(v, pc); if(Npadlong <= ReallocOffset || v == nil) return; - u = v; - u[-Npadlong+ReallocOffset] = pc; + ((ulong*)v)[-Npadlong+ReallocOffset] = (ulong)pc; } uintptr @@ -305,7 +301,7 @@ getmalloctag(void *v) USED(v); if(Npadlong <= MallocOffset) return ~0; - return ((uintptr*)v)[-Npadlong+MallocOffset]; + return (int)((ulong*)v)[-Npadlong+MallocOffset]; } uintptr @@ -313,6 +309,6 @@ getrealloctag(void *v) { USED(v); if(Npadlong <= ReallocOffset) - return ((uintptr*)v)[-Npadlong+ReallocOffset]; - return ~0; + return ~0; + return (int)((ulong*)v)[-Npadlong+ReallocOffset]; } diff --git a/sys/src/libc/port/malloc.c b/sys/src/libc/port/malloc.c index 59fad21a6..af52dce42 100644 --- a/sys/src/libc/port/malloc.c +++ b/sys/src/libc/port/malloc.c @@ -170,7 +170,7 @@ ppanic(Pool *p, char *fmt, ...) /* - except the code for malloc(), which alternately doesn't clear or does. - */ /* - * Npadlong is the number of uintptr's to leave at the beginning of + * Npadlong is the number of ulongs's 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. @@ -204,9 +204,9 @@ malloc(ulong size) { void *v; - v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr)); + v = poolalloc(mainmem, size+Npadlong*sizeof(ulong)); if(Npadlong && v != nil) { - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); setrealloctag(v, 0); } @@ -218,9 +218,9 @@ mallocz(ulong size, int clr) { void *v; - v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr)); + v = poolalloc(mainmem, size+Npadlong*sizeof(ulong)); if(Npadlong && v != nil){ - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); setrealloctag(v, 0); } @@ -234,9 +234,9 @@ mallocalign(ulong size, ulong align, long offset, ulong span) { void *v; - v = poolallocalign(mainmem, size+Npadlong*sizeof(uintptr), align, offset-Npadlong*sizeof(uintptr), span); + v = poolallocalign(mainmem, size+Npadlong*sizeof(ulong), align, offset-Npadlong*sizeof(ulong), span); if(Npadlong && v != nil){ - v = (uintptr*)v+Npadlong; + v = (ulong*)v+Npadlong; setmalloctag(v, getcallerpc(&size)); setrealloctag(v, 0); } @@ -247,7 +247,7 @@ void free(void *v) { if(v != nil) - poolfree(mainmem, (uintptr*)v-Npadlong); + poolfree(mainmem, (ulong*)v-Npadlong); } void* @@ -261,11 +261,11 @@ realloc(void *v, ulong size) } if(v) - v = (uintptr*)v-Npadlong; - size += Npadlong*sizeof(uintptr); + v = (ulong*)v-Npadlong; + size += Npadlong*sizeof(ulong); if(nv = poolrealloc(mainmem, v, size)){ - nv = (uintptr*)nv+Npadlong; + nv = (ulong*)nv+Npadlong; setrealloctag(nv, getcallerpc(&v)); if(v == nil) setmalloctag(nv, getcallerpc(&v)); @@ -276,7 +276,7 @@ realloc(void *v, ulong size) ulong msize(void *v) { - return poolmsize(mainmem, (uintptr*)v-Npadlong)-Npadlong*sizeof(uintptr); + return poolmsize(mainmem, (ulong*)v-Npadlong)-Npadlong*sizeof(ulong); } void* @@ -294,23 +294,19 @@ calloc(ulong n, ulong s) void setmalloctag(void *v, uintptr pc) { - uintptr *u; USED(v, pc); if(Npadlong <= MallocOffset || v == nil) return; - u = v; - u[-Npadlong+MallocOffset] = pc; + ((ulong*)v)[-Npadlong+MallocOffset] = (ulong)pc; } void setrealloctag(void *v, uintptr pc) { - uintptr *u; USED(v, pc); if(Npadlong <= ReallocOffset || v == nil) return; - u = v; - u[-Npadlong+ReallocOffset] = pc; + ((ulong*)v)[-Npadlong+ReallocOffset] = (ulong)pc; } uintptr @@ -319,7 +315,7 @@ getmalloctag(void *v) USED(v); if(Npadlong <= MallocOffset) return ~0; - return ((uintptr*)v)[-Npadlong+MallocOffset]; + return (int)((ulong*)v)[-Npadlong+MallocOffset]; } uintptr @@ -327,8 +323,8 @@ getrealloctag(void *v) { USED(v); if(Npadlong <= ReallocOffset) - return ((uintptr*)v)[-Npadlong+ReallocOffset]; - return ~0; + return ~0; + return (int)((ulong*)v)[-Npadlong+ReallocOffset]; } void* @@ -336,6 +332,5 @@ malloctopoolblock(void *v) { if(v == nil) return nil; - - return &((uintptr*)v)[-Npadlong]; + return &((ulong*)v)[-Npadlong]; }