Annotation of sys/dev/raidframe/rf_debugMem.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_debugMem.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $ */
2: /* $NetBSD: rf_debugMem.c,v 1.7 2000/01/07 03:40:59 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Daniel Stodolsky, Mark Holland, Jim Zelenka
9: *
10: * Permission to use, copy, modify and distribute this software and
11: * its documentation is hereby granted, provided that both the copyright
12: * notice and this permission notice appear in all copies of the
13: * software, derivative works or modified versions, and any portions
14: * thereof, and that both notices appear in supporting documentation.
15: *
16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19: *
20: * Carnegie Mellon requests users of this software to return to
21: *
22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
23: * School of Computer Science
24: * Carnegie Mellon University
25: * Pittsburgh PA 15213-3890
26: *
27: * any improvements or extensions that they make and grant Carnegie the
28: * rights to redistribute these changes.
29: */
30:
31: /*
32: * debugMem.c: Memory usage debugging stuff.
33: *
34: * Malloc, Calloc, and Free are #defined everywhere
35: * to do_malloc, do_calloc, and do_free.
36: *
37: * If RF_UTILITY is nonzero, it means we are compiling one of the
38: * RAIDframe utility programs, such as rfctrl or smd. In this
39: * case, we eliminate all references to the threads package
40: * and to the allocation list stuff.
41: */
42:
43: #include "rf_types.h"
44: #include "rf_threadstuff.h"
45: #include "rf_options.h"
46: #include "rf_debugMem.h"
47: #include "rf_general.h"
48:
49: static long tot_mem_in_use = 0;
50:
51: /* Hash table of information about memory allocations. */
52: #define RF_MH_TABLESIZE 1000
53:
54: struct mh_struct {
55: void *address;
56: int size;
57: int line;
58: char *filen;
59: char allocated;
60: struct mh_struct *next;
61: };
62:
63: static struct mh_struct *mh_table[RF_MH_TABLESIZE];
64:
65: RF_DECLARE_MUTEX(rf_debug_mem_mutex);
66: static int mh_table_initialized = 0;
67:
68: void rf_memory_hash_insert(void *, int, int, char *);
69: int rf_memory_hash_remove(void *, int);
70:
71: void
72: rf_record_malloc(void *p, int size, int line, char *filen)
73: {
74: RF_ASSERT(size != 0);
75:
76: /*RF_LOCK_MUTEX(rf_debug_mem_mutex);*/
77: rf_memory_hash_insert(p, size, line, filen);
78: tot_mem_in_use += size;
79: /*RF_UNLOCK_MUTEX(rf_debug_mem_mutex);*/
80:
81: if ((long) p == rf_memDebugAddress) {
82: printf("Allocate: debug address allocated from line %d file"
83: " %s\n", line, filen);
84: }
85: }
86:
87: void
88: rf_unrecord_malloc(void *p, int sz)
89: {
90: int size;
91:
92: /*RF_LOCK_MUTEX(rf_debug_mem_mutex);*/
93: size = rf_memory_hash_remove(p, sz);
94: tot_mem_in_use -= size;
95: /*RF_UNLOCK_MUTEX(rf_debug_mem_mutex);*/
96: if ((long) p == rf_memDebugAddress) {
97: /* This is really only a flag line for gdb. */
98: printf("Free: Found debug address\n");
99: }
100: }
101:
102: void
103: rf_print_unfreed(void)
104: {
105: int i, foundone = 0;
106: struct mh_struct *p;
107:
108: for (i = 0; i < RF_MH_TABLESIZE; i++) {
109: for (p = mh_table[i]; p; p = p->next)
110: if (p->allocated) {
111: if (!foundone)
112: printf("\n\nThere are unfreed"
113: " memory locations at"
114: " program shutdown:\n");
115: foundone = 1;
116: printf("Addr 0x%lx Size %d line %d file %s\n",
117: (long) p->address, p->size, p->line,
118: p->filen);
119: }
120: }
121: if (tot_mem_in_use) {
122: printf("%ld total bytes in use\n", tot_mem_in_use);
123: }
124: }
125:
126: int
127: rf_ConfigureDebugMem(RF_ShutdownList_t **listp)
128: {
129: int i, rc;
130:
131: rc = rf_create_managed_mutex(listp, &rf_debug_mem_mutex);
132: if (rc) {
133: RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
134: __FILE__, __LINE__, rc);
135: return (rc);
136: }
137: if (rf_memDebug) {
138: for (i = 0; i < RF_MH_TABLESIZE; i++)
139: mh_table[i] = NULL;
140: mh_table_initialized = 1;
141: }
142: return (0);
143: }
144:
145: #define HASHADDR(_a_) ( (((unsigned long) _a_)>>3) % RF_MH_TABLESIZE )
146:
147: void
148: rf_memory_hash_insert(void *addr, int size, int line, char *filen)
149: {
150: unsigned long bucket = HASHADDR(addr);
151: struct mh_struct *p;
152:
153: RF_ASSERT(mh_table_initialized);
154:
155: /* Search for this address in the hash table. */
156: for (p = mh_table[bucket]; p && (p->address != addr); p = p->next);
157: if (!p) {
158: RF_Malloc(p, sizeof(struct mh_struct), (struct mh_struct *));
159: RF_ASSERT(p);
160: p->next = mh_table[bucket];
161: mh_table[bucket] = p;
162: p->address = addr;
163: p->allocated = 0;
164: }
165: if (p->allocated) {
166: printf("ERROR: Reallocated address 0x%lx from line %d,"
167: " file %s without intervening free\n", (long) addr,
168: line, filen);
169: printf(" Last allocated from line %d file %s\n",
170: p->line, p->filen);
171: RF_ASSERT(0);
172: }
173: p->size = size;
174: p->line = line;
175: p->filen = filen;
176: p->allocated = 1;
177: }
178:
179: int
180: rf_memory_hash_remove(void *addr, int sz)
181: {
182: unsigned long bucket = HASHADDR(addr);
183: struct mh_struct *p;
184:
185: RF_ASSERT(mh_table_initialized);
186: for (p = mh_table[bucket]; p && (p->address != addr); p = p->next);
187: if (!p) {
188: printf("ERROR: Freeing never-allocated address 0x%lx\n",
189: (long) addr);
190: RF_PANIC();
191: }
192: if (!p->allocated) {
193: printf("ERROR: Freeing unallocated address 0x%lx."
194: " Last allocation line %d file %s\n", (long) addr,
195: p->line, p->filen);
196: RF_PANIC();
197: }
198: if (sz > 0 && p->size != sz) {
199: /*
200: * This error can be suppressed by using a negative value
201: * as the size to free.
202: */
203: printf("ERROR: Incorrect size at free for address 0x%lx:"
204: " is %d should be %d. Alloc at line %d of file %s\n",
205: (unsigned long) addr, sz, p->size, p->line, p->filen);
206: RF_PANIC();
207: }
208: p->allocated = 0;
209: return (p->size);
210: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_debugMem.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe