change the junking to be word size. maybe later we can also change the
values to be random or something.

Index: stdlib/malloc.c
===================================================================
RCS file: /cvs/src/lib/libc/stdlib/malloc.c,v
retrieving revision 1.149
diff -u -p -r1.149 malloc.c
--- stdlib/malloc.c     22 Dec 2012 07:32:17 -0000      1.149
+++ stdlib/malloc.c     3 Jul 2013 19:52:27 -0000
@@ -80,14 +80,6 @@
 
 #define PAGEROUND(x)  (((x) + (MALLOC_PAGEMASK)) & ~MALLOC_PAGEMASK)
 
-/*
- * What to use for Junk.  This is the byte value we use to fill with
- * when the 'J' option is enabled. Use SOME_JUNK right after alloc,
- * and SOME_FREEJUNK right before free.
- */
-#define SOME_JUNK              0xd0    /* as in "Duh" :-) */
-#define SOME_FREEJUNK          0xdf
-
 #define MMAP(sz)       mmap(NULL, (size_t)(sz), PROT_READ | PROT_WRITE, \
     MAP_ANON | MAP_PRIVATE, -1, (off_t) 0)
 
@@ -237,6 +229,18 @@ hash(void *p)
 }
 
 static void
+poison(void *p, size_t len)
+{
+       int *ip = p;
+       size_t i;
+       int pval = 0xd0d0caca;
+
+       len = len / 4;
+       for (i = 0; i < len; i++)
+               ip[i] = pval;
+}
+
+static void
 wrterror(char *msg, void *p)
 {
        char            *q = " error: ";
@@ -419,7 +423,7 @@ map(struct dir_info *d, size_t sz, int z
                                        memset(p, 0, sz);
                                else if (mopts.malloc_junk &&
                                    mopts.malloc_freeunmap)
-                                       memset(p, SOME_FREEJUNK, sz);
+                                       poison(p, sz);
                                return p;
                        } else if (r->size > psz)
                                big = r;
@@ -437,7 +441,7 @@ map(struct dir_info *d, size_t sz, int z
                if (zero_fill)
                        memset(p, 0, sz);
                else if (mopts.malloc_junk && mopts.malloc_freeunmap)
-                       memset(p, SOME_FREEJUNK, sz);
+                       poison(p, sz);
                return p;
        }
        p = MMAP(sz);
@@ -975,7 +979,7 @@ malloc_bytes(struct dir_info *d, size_t 
        k <<= bp->shift;
 
        if (mopts.malloc_junk && bp->size > 0)
-               memset((char *)bp->page + k, SOME_JUNK, bp->size);
+               poison((char *)bp->page + k, bp->size);
        return ((char *)bp->page + k);
 }
 
@@ -1073,7 +1077,7 @@ omalloc(size_t sz, int zero_fill, void *
                    MALLOC_LEEWAY) {
                        /* fill whole allocation */
                        if (mopts.malloc_junk)
-                               memset(p, SOME_JUNK, psz - mopts.malloc_guard);
+                               poison(p, psz - mopts.malloc_guard);
                        /* shift towards the end */
                        p = ((char *)p) + ((MALLOC_PAGESIZE - MALLOC_LEEWAY -
                            (sz - mopts.malloc_guard)) & ~(MALLOC_MINSIZE-1));
@@ -1083,11 +1087,10 @@ omalloc(size_t sz, int zero_fill, void *
                } else {
                        if (mopts.malloc_junk) {
                                if (zero_fill)
-                                       memset((char *)p + sz - 
mopts.malloc_guard,
-                                           SOME_JUNK, psz - sz);
+                                       poison((char *)p + sz -
+                                           mopts.malloc_guard, psz - sz);
                                else
-                                       memset(p, SOME_JUNK,
-                                           psz - mopts.malloc_guard);
+                                       poison(p, psz - mopts.malloc_guard);
                        }
                }
 
@@ -1202,8 +1205,7 @@ ofree(void *p)
                        malloc_guarded -= mopts.malloc_guard;
                }
                if (mopts.malloc_junk && !mopts.malloc_freeunmap)
-                       memset(p, SOME_FREEJUNK,
-                           PAGEROUND(sz) - mopts.malloc_guard);
+                       poison(p, PAGEROUND(sz) - mopts.malloc_guard);
                unmap(g_pool, p, PAGEROUND(sz));
                delete(g_pool, r);
        } else {
@@ -1211,7 +1213,7 @@ ofree(void *p)
                int i;
 
                if (mopts.malloc_junk && sz > 0)
-                       memset(p, SOME_FREEJUNK, sz);
+                       poison(p, sz);
                if (!mopts.malloc_freenow) {
                        i = getrnibble();
                        tmp = p;
@@ -1308,7 +1310,7 @@ orealloc(void *p, size_t newsz, void *f)
                                if (q == hint) {
                                        malloc_used += needed;
                                        if (mopts.malloc_junk)
-                                               memset(q, SOME_JUNK, needed);
+                                               poison(q, needed);
                                        r->size = newsz;
                                        STATS_SETF(r, f);
                                        STATS_INC(g_pool->cheap_reallocs);
@@ -1335,7 +1337,7 @@ orealloc(void *p, size_t newsz, void *f)
                        return p;
                } else {
                        if (newsz > oldsz && mopts.malloc_junk)
-                               memset((char *)p + newsz, SOME_JUNK,
+                               poison((char *)p + newsz,
                                    rnewsz - mopts.malloc_guard - newsz);
                        r->size = gnewsz;
                        STATS_SETF(r, f);
@@ -1344,7 +1346,7 @@ orealloc(void *p, size_t newsz, void *f)
        }
        if (newsz <= oldsz && newsz > oldsz / 2 && !mopts.malloc_realloc) {
                if (mopts.malloc_junk && newsz > 0)
-                       memset((char *)p + newsz, SOME_JUNK, oldsz - newsz);
+                       poison((char *)p + newsz, oldsz - newsz);
                STATS_SETF(r, f);
                return p;
        } else if (newsz != oldsz || mopts.malloc_realloc) {
@@ -1516,10 +1518,9 @@ omemalign(size_t alignment, size_t sz, i
 
        if (mopts.malloc_junk) {
                if (zero_fill)
-                       memset((char *)p + sz - mopts.malloc_guard,
-                           SOME_JUNK, psz - sz);
+                       poison((char *)p + sz - mopts.malloc_guard, psz - sz);
                else
-                       memset(p, SOME_JUNK, psz - mopts.malloc_guard);
+                       poison(p, psz - mopts.malloc_guard);
        }
 
        return p;

Reply via email to