debugmalloc.c - 9base - revived minimalist port of Plan 9 userland to Unix | |
git clone git://git.suckless.org/9base | |
Log | |
Files | |
Refs | |
README | |
LICENSE | |
--- | |
debugmalloc.c (3058B) | |
--- | |
1 #include <u.h> | |
2 #define NOPLAN9DEFINES | |
3 #include <libc.h> | |
4 | |
5 /* | |
6 * The Unix libc routines cannot be trusted to do their own locking. | |
7 * Sad but apparently true. | |
8 */ | |
9 static Lock malloclock; | |
10 static int mallocpid; | |
11 | |
12 /* | |
13 * The Unix mallocs don't do nearly enough error checking | |
14 * for my tastes. We'll waste another 24 bytes per guy so that | |
15 * we can. This is severely antisocial, since now free and p9free | |
16 * are not interchangeable. | |
17 */ | |
18 int debugmalloc; | |
19 | |
20 #define Overhead (debugmalloc ? (6*sizeof(ulong)) : 0) | |
21 #define MallocMagic 0xA110C09 | |
22 #define ReallocMagic 0xB110C09 | |
23 #define CallocMagic 0xC110C09 | |
24 #define FreeMagic 0xF533F533 | |
25 #define CheckMagic 0 | |
26 #define END "\x7F\x2E\x55\x23" | |
27 | |
28 static void | |
29 whoops(void *v) | |
30 { | |
31 fprint(2, "bad malloc block %p\n", v); | |
32 abort(); | |
33 } | |
34 | |
35 static void* | |
36 mark(void *v, ulong pc, ulong n, ulong magic) | |
37 { | |
38 ulong *u; | |
39 char *p; | |
40 | |
41 if(!debugmalloc) | |
42 return v; | |
43 | |
44 if(v == nil) | |
45 return nil; | |
46 | |
47 if(magic == FreeMagic || magic == CheckMagic){ | |
48 u = (ulong*)((char*)v-4*sizeof(ulong)); | |
49 if(u[0] != MallocMagic && u[0] != ReallocMagic && u[0] !… | |
50 whoops(v); | |
51 n = u[1]; | |
52 p = (char*)v+n; | |
53 if(memcmp(p, END, 4) != 0) | |
54 whoops(v); | |
55 if(magic != CheckMagic){ | |
56 u[0] = FreeMagic; | |
57 u[1] = u[2] = u[3] = pc; | |
58 if(n > 16){ | |
59 u[4] = u[5] = u[6] = u[7] = pc; | |
60 memset((char*)v+16, 0xFB, n-16); | |
61 } | |
62 } | |
63 return u; | |
64 }else{ | |
65 u = v; | |
66 u[0] = magic; | |
67 u[1] = n; | |
68 u[2] = 0; | |
69 u[3] = 0; | |
70 if(magic == ReallocMagic) | |
71 u[3] = pc; | |
72 else | |
73 u[2] = pc; | |
74 p = (char*)(u+4)+n; | |
75 memmove(p, END, 4); | |
76 return u+4; | |
77 } | |
78 } | |
79 | |
80 void | |
81 setmalloctag(void *v, ulong t) | |
82 { | |
83 ulong *u; | |
84 | |
85 if(!debugmalloc) | |
86 return; | |
87 | |
88 if(v == nil) | |
89 return; | |
90 u = mark(v, 0, 0, 0); | |
91 u[2] = t; | |
92 } | |
93 | |
94 void | |
95 setrealloctag(void *v, ulong t) | |
96 { | |
97 ulong *u; | |
98 | |
99 if(!debugmalloc) | |
100 return; | |
101 | |
102 if(v == nil) | |
103 return; | |
104 u = mark(v, 0, 0, 0); | |
105 u[3] = t; | |
106 } | |
107 | |
108 void* | |
109 p9malloc(ulong n) | |
110 { | |
111 void *v; | |
112 if(n == 0) | |
113 n++; | |
114 /*fprint(2, "%s %d malloc\n", argv0, getpid()); */ | |
115 lock(&malloclock); | |
116 mallocpid = getpid(); | |
117 v = malloc(n+Overhead); | |
118 v = mark(v, getcallerpc(&n), n, MallocMagic); | |
119 unlock(&malloclock); | |
120 /*fprint(2, "%s %d donemalloc\n", argv0, getpid()); */ | |
121 return v; | |
122 } | |
123 | |
124 void | |
125 p9free(void *v) | |
126 { | |
127 if(v == nil) | |
128 return; | |
129 | |
130 /*fprint(2, "%s %d free\n", argv0, getpid()); */ | |
131 lock(&malloclock); | |
132 mallocpid = getpid(); | |
133 v = mark(v, getcallerpc(&v), 0, FreeMagic); | |
134 free(v); | |
135 unlock(&malloclock); | |
136 /*fprint(2, "%s %d donefree\n", argv0, getpid()); */ | |
137 } | |
138 | |
139 void* | |
140 p9calloc(ulong a, ulong b) | |
141 { | |
142 void *v; | |
143 | |
144 /*fprint(2, "%s %d calloc\n", argv0, getpid()); */ | |
145 lock(&malloclock); | |
146 mallocpid = getpid(); | |
147 v = calloc(a*b+Overhead, 1); | |
148 v = mark(v, getcallerpc(&a), a*b, CallocMagic); | |
149 unlock(&malloclock); | |
150 /*fprint(2, "%s %d donecalloc\n", argv0, getpid()); */ | |
151 return v; | |
152 } | |
153 | |
154 void* | |
155 p9realloc(void *v, ulong n) | |
156 { | |
157 /*fprint(2, "%s %d realloc\n", argv0, getpid()); */ | |
158 lock(&malloclock); | |
159 mallocpid = getpid(); | |
160 v = mark(v, getcallerpc(&v), 0, CheckMagic); | |
161 v = realloc(v, n+Overhead); | |
162 v = mark(v, getcallerpc(&v), n, ReallocMagic); | |
163 unlock(&malloclock); | |
164 /*fprint(2, "%s %d donerealloc\n", argv0, getpid()); */ | |
165 return v; | |
166 } |