![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckcmdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / ckermit|
Return to ckcmdb.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 root 1: /*
2: C K C M D B . C -- malloc debugger.
3: */
4:
5: /*
6: Author: Howie Kaye, Columbia University Center for Computing Activities.
7: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
8: York. Permission is granted to any individual or institution to use this
9: software as long as it is not sold for profit. This copyright notice must be
10: retained. This software may not be included in commercial products without
11: written permission of Columbia University.
12: */
13: #include <stdio.h>
14: #include "ckcdeb.h"
15: /*
16: memdebug:
17: variable to control memory debugging.
18: if memdebug == 1, then action is always taken.
19: if memdebug == 0, then no action is taken.
20: if memdebug == -1, then the user is asked (works well with gdb).
21: */
22: int memdebug = -1;
23: int disabled = 0;
24: int inited = 0;
25: /*
26: To use this package, compile your program with:
27: -Dmalloc=dmalloc -Dfree=dfree =Dcalloc=dcalloc ... -DMDEBUG
28: and then link it with ckcmdb.c.
29: */
30: #ifdef MDEBUG
31: /* Use the real ones in this module! */
32: #ifdef malloc
33: #undef malloc
34: #endif /* malloc */
35: #ifdef calloc
36: #undef calloc
37: #endif /* calloc */
38: #ifdef realloc
39: #undef realloc
40: #endif /* realloc */
41: #ifdef free
42: #undef free
43: #endif /* free */
44:
45: char *malloc(), *realloc();
46: char *set_range_check();
47: char *check_range();
48: char *maybe_check_range();
49:
50: #define min(x,y) ((x) < (y) ? (x) : (y))
51: #define RANGE "ABCDEFGHIJKLMNOP"
52: #define INTSIZE sizeof(int)
53: #define LONGSIZE sizeof(long)
54: #define RSIZE sizeof(RANGE)
55: #define RFRONT min((RSIZE/2),LONGSIZE)
56: #define RBACK min((RSIZE-RFRONT),LONGSIZE)
57:
58: char *
59: dmalloc(size) int size; {
60: char *cp;
61:
62: cp = malloc(size + RSIZE + INTSIZE);
63: if (cp) {
64: cp = set_range_check(cp, size);
65: m_insert(cp);
66: }
67: return(cp);
68: }
69:
70: char *
71: dcalloc(nelem, elsize) int nelem, elsize; {
72: char *cp;
73:
74: cp = dmalloc(nelem * elsize);
75: if (cp)
76: bzero(cp, nelem * elsize);
77: return(cp);
78: }
79:
80: char *
81: drealloc(bp,size) char *bp; int size; {
82: char *cp;
83:
84: if (bp == NULL) {
85: maybe_quit("Freeing NULL pointer");
86: } else {
87: m_delete(bp);
88: cp = check_range(bp);
89: }
90: cp = realloc(cp, size + RSIZE + INTSIZE);
91: if (cp) {
92: cp = set_range_check(cp, size);
93: m_insert(cp);
94: }
95: return(cp);
96: }
97:
98: dfree(cp) char *cp; {
99: if (cp == NULL)
100: maybe_quit("Freeing NULL pointer");
101: else {
102: switch(m_delete(cp)) {
103: case 0:
104: cp = maybe_check_range(cp);
105: break;
106: case 1:
107: cp = check_range(cp);
108: break;
109: case 2:
110: break;
111: }
112: }
113: return(free(cp));
114: }
115:
116: char *
117: set_range_check(cp,size) char *cp; int size; {
118: register int i;
119: int tmp = size;
120:
121: for(i = 0; i < INTSIZE; i++) { /* set the size in the string */
122: cp[i] = tmp & 0xff;
123: tmp >>= 8;
124: }
125: cp += INTSIZE; /* skip the size */
126:
127: for(i = 0; i < RFRONT; i++) /* set the front of the range check */
128: cp[i] = RANGE[i]; /* string */
129:
130: cp += RFRONT; /* skip the front range check */
131:
132: for(i = 0; i < RBACK; i++) /* set the back odf the range check */
133: cp[i+size] = RANGE[i+RFRONT];
134:
135: return(cp);
136: }
137:
138: /*
139: Put calls to this routine in your code any place where you want to
140: check whether you've copied too many characters into a malloc'd space.
141: */
142: char *
143: check_range(cp) char *cp; {
144: register char *bp = cp - RFRONT - INTSIZE;
145: char *xp = bp;
146: register int i;
147: int size = 0;
148:
149: for(i = 0 ; i < INTSIZE; i++) { /* get the size out of the string */
150: size <<= 8;
151: size |= bp[INTSIZE-i-1] & 0xff;
152: }
153: bp += INTSIZE;
154:
155: for(i = 0; i < RFRONT; i++) /* check front range check */
156: if (bp[i] != RANGE[i]) {
157: maybe_quit("leftside malloc buffer overrun");
158: break;
159: }
160: bp += RFRONT; /* skip front range check */
161:
162: for(i = 0; i < RBACK; i++) /* check back range check */
163: if (bp[i+size] != RANGE[i+RFRONT]) {
164: maybe_quit("rightside malloc buffer overrun");
165: break;
166: }
167: return(xp);
168: }
169:
170: static char *
171: maybe_check_range(cp) char *cp; {
172: register char *bp = cp - RFRONT - INTSIZE;
173: char *xp = bp;
174: register int i;
175: int size = 0;
176:
177: for(i = 0 ; i < INTSIZE; i++) { /* get the size out of the string */
178: size <<= 8;
179: size |= bp[INTSIZE-i-1] & 0xff;
180: }
181: bp += INTSIZE;
182:
183: for(i = 0; i < RFRONT; i++) /* check front range check */
184: if (bp[i] != RANGE[i]) {
185: return(cp);
186: }
187: bp += RFRONT; /* skip front range check */
188:
189: for(i = 0; i < RBACK; i++) /* check back range check */
190: if (bp[i+size] != RANGE[i+RFRONT]) {
191: fprintf(stderr,"rightside malloc buffer overrun\n");
192: abort();
193: break;
194: }
195: return(xp);
196: }
197:
198: #define BUCKETS 10000
199: char *m_used[BUCKETS];
200: char *m_used2[BUCKETS];
201:
202: VOID
203: m_insert(cp) register char *cp; {
204: register int i;
205:
206: if (disabled)
207: return;
208:
209: for(i = 0; i < BUCKETS; i++)
210: if (m_used[i] == 0) {
211: m_used[i] = cp;
212: return;
213: }
214: disabled ++;
215: }
216:
217: static
218: m_insert2(cp) register char *cp; {
219: register int i;
220:
221: if (disabled)
222: return;
223: for(i = 0; i < BUCKETS; i++)
224: if (m_used2[i] == 0) {
225: m_used2[i] = cp;
226: return;
227: }
228: disabled ++;
229: }
230:
231: VOID
232: m_delete(cp) register char *cp; {
233: register int i;
234:
235: for(i = 0; i < BUCKETS; i++)
236: if (m_used[i] == cp) {
237: m_used[i] = 0;
238: return(1);
239: }
240: for(i = 0; i < BUCKETS; i++)
241: if (m_used2[i] == cp) {
242: m_used2[i] = 0;
243: return(2);
244: }
245: if (disabled)
246: return(0);
247:
248: maybe_quit("Freeing unmalloc'ed pointer");
249: return(0);
250: }
251:
252: VOID
253: m_init() {
254: register int i;
255:
256: inited = 1;
257: disabled = 0;
258: for(i = 0; i < BUCKETS; i++)
259: m_used[i] = 0;
260: }
261:
262: VOID
263: m_done() {
264: register int i,j=0;
265:
266: if (disabled)
267: return;
268: for(i = 0; i < BUCKETS; i++)
269: if (m_used[i] != 0) {
270: if (memdebug) {
271: if (j == 0)
272: fprintf(stderr,"unfree'ed buffers, indices: ");
273: fprintf(stderr,"%d, ", i);
274: j++;
275: }
276: }
277: if (j)
278: fprintf(stderr,"\n");
279: for(i = 0; i < BUCKETS; i++)
280: if (m_used2[i] != 0) {
281: if (memdebug) {
282: if (j == 0)
283: fprintf(stderr,"unfree'ed registered buffers, indices: ");
284: fprintf(stderr,"%d, ", i);
285: j++;
286: }
287: }
288: if (j)
289: fprintf(stderr,"\n");
290: if (j)
291: maybe_quit("Unfree'ed malloc buffers");
292: }
293:
294: VOID
295: m_checkranges() {
296: int i;
297:
298: for ( i = 0; i < BUCKETS; i++)
299: if (m_used[i])
300: check_range(m_used[i]);
301: }
302:
303: static VOID
304: maybe_quit(str) char *str; {
305: debug(F100,"mdebug maybe_quit","",0);
306: if (memdebug == 0)
307: return;
308: fprintf(stderr,"%s\n",str);
309: if (memdebug == 1)
310: abort();
311: if (memdebug == -1)
312: if (ask("Quit? "))
313: abort();
314: }
315:
316: static int
317: ask(str) char *str; {
318: char buf[100];
319: FILE *in;
320: int fd;
321:
322: fd = dup(fileno(stdin));
323: in = fdopen(fd, "r");
324: while(1) {
325: fprintf(stderr,str);
326: fflush(stderr);
327: if (fgets(buf, 99, in) == NULL) /* EOF? */
328: return(0);
329: if (buf[0] == 'n' || buf[0] == 'N') {
330: fclose(in);
331: return(0);
332: }
333: if (buf[0] == 'y' || buf[0] == 'Y') {
334: fclose(in);
335: return(1);
336: }
337: fprintf(stderr,"please answer y/n.\n");
338: }
339: }
340: #endif /* MDEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.