3 * $Id: cbdata.cc,v 1.77 2008/02/26 21:49:34 amosjeffries Exp $
5 * DEBUG: section 45 Callback Data Registry
6 * ORIGINAL AUTHOR: Duane Wessels
7 * Modified by Moez Mahfoudh (08/12/2000)
8 * History added by Robert Collins (2002-10-25)
10 * SQUID Web Proxy Cache http://www.squid-cache.org/
11 * ----------------------------------------------------------
13 * Squid is the result of efforts by numerous individuals from
14 * the Internet community; see the CONTRIBUTORS file for full
15 * details. Many organizations have provided support for Squid's
16 * development; see the SPONSORS file for full details. Squid is
17 * Copyrighted (C) 2001 by the Regents of the University of
18 * California; see the COPYRIGHT file for full details. Squid
19 * incorporates software developed and/or copyrighted by other
20 * sources; see the CREDITS file for full details.
22 * This program is free software; you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation; either version 2 of the License, or
25 * (at your option) any later version.
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
39 \defgroup CBDATAInternal Callback Data Allocator Internals
42 * These routines manage a set of registered callback data pointers.
43 * One of the easiest ways to make Squid coredump is to issue a
44 * callback to for some data structure which has previously been
45 * freed. With these routines, we register (add) callback data
46 * pointers, lock them just before registering the callback function,
47 * validate them before issuing the callback, and then free them
52 #include "CacheManager.h"
60 #define HASHED_CBDATA 1
63 static int cbdataCount
= 0;
65 dlink_list cbdataEntries
;
74 CBDataCall (char const *callLabel
, char const *aFile
, int aLine
) : label(callLabel
), file(aFile
), line(aLine
){}
83 /// \ingroup CBDATAInternal
84 #define OFFSET_OF(TYPE, MEMBER) ((size_t) &(((TYPE) *)0)->(MEMBER))
86 /// \ingroup CBDATAInternal
89 /** \todo examine making cbdata templated on this - so we get type
90 * safe access to data - RBC 20030902 */
93 hash_link hash
; // Must be first
98 void dump(StoreEntry
*)const;
102 void *operator new(size_t size
, void *where
);
103 void operator delete(void *where
, void *where2
);
105 MEMPROXY_CLASS(cndata
);
114 void addHistory(char const *label
, char const *file
, int line
)
116 if (calls
.size() > 1000)
119 calls
.push_back(new CBDataCall(label
, file
, line
));
125 Stack
<CBDataCall
*> calls
;
128 /* cookie used while debugging */
130 void check(int line
) const {assert(cookie
== ((long)this ^ Cookie
));}
131 static const long Cookie
;
134 size_t dataSize() const { return sizeof(data
);}
135 static long MakeOffset();
136 static const long Offset
;
137 /* MUST be the last per-instance member */
143 const long cbdata::Cookie((long)0xDEADBEEF);
145 const long cbdata::Offset(MakeOffset());
148 cbdata::operator new(size_t size
, void *where
)
150 // assert (size == sizeof(cbdata));
155 * Only ever invoked when placement new throws
156 * an exception. Used to prevent an incorrect
160 cbdata::operator delete(void *where
, void *where2
)
168 cbdata
*zero
= (cbdata
*)0L;
169 void **dataOffset
= &zero
->data
;
170 return (long)dataOffset
;
173 MEMPROXY_CLASS_INLINE(cbdata
) /**DOCS_NOSEMI*/
176 static OBJH cbdataDump
;
178 static OBJH cbdataDumpHistory
;
181 /// \ingroup CBDATAInternal
187 *cbdata_index
= NULL
;
189 /// \ingroup CBDATAInternal
190 int cbdata_types
= 0;
193 static hash_table
*cbdata_htable
= NULL
;
196 cbdata_cmp(const void *p1
, const void *p2
)
198 return (char *) p1
- (char *) p2
;
202 cbdata_hash(const void *p
, unsigned int mod
)
204 return ((unsigned long) p
>> 8) % mod
;
214 while ((aCall
= calls
.pop()))
219 FREE
*free_func
= cbdata_index
[type
].free_func
;
232 cbdataInternalInitType(cbdata_type type
, const char *name
, int size
, FREE
* free_func
)
235 assert (type
== cbdata_types
+ 1);
237 cbdata_index
= (CBDataIndex
*)xrealloc(cbdata_index
, (type
+ 1) * sizeof(*cbdata_index
));
238 memset(&cbdata_index
[type
], 0, sizeof(*cbdata_index
));
241 label
= (char *)xmalloc(strlen(name
) + 20);
243 snprintf(label
, strlen(name
) + 20, "cbdata %s (%d)", name
, (int) type
);
246 assert((size_t)cbdata::Offset
== (sizeof(cbdata
) - ((cbdata
*)NULL
)->dataSize()));
247 size
+= cbdata::Offset
;
250 cbdata_index
[type
].pool
= memPoolCreate(label
, size
);
252 cbdata_index
[type
].free_func
= free_func
;
256 cbdata_htable
= hash_create(cbdata_cmp
, 1 << 12, cbdata_hash
);
261 cbdataInternalAddType(cbdata_type type
, const char *name
, int size
, FREE
* free_func
)
266 type
= (cbdata_type
)(cbdata_types
+ 1);
268 cbdataInternalInitType(type
, name
, size
, free_func
);
274 cbdataRegisterWithCacheManager(CacheManager
& manager
)
276 manager
.registerAction("cbdata",
277 "Callback Data Registry Contents",
281 manager
.registerAction("cbdatahistory",
282 "Detailed call history for all current cbdata contents",
283 cbdataDumpHistory
, 0, 1);
289 cbdataInternalAllocDbg(cbdata_type type
, const char *file
, int line
)
291 cbdataInternalAlloc(cbdata_type type
)
296 assert(type
> 0 && type
<= cbdata_types
);
297 /* placement new: the pool alloc gives us cbdata + user type memory space
298 * and we init it with cbdata at the start of it
302 p
= cbdata_index
[type
].pool
->alloc();
304 hash_join(cbdata_htable
, &c
->hash
);
306 c
= new (cbdata_index
[type
].pool
->alloc()) cbdata
;
307 p
= (void *)&c
->data
;
313 c
->cookie
= (long) c
^ cbdata::Cookie
;
319 c
->calls
= Stack
<CBDataCall
*> ();
320 c
->addHistory("Alloc", file
, line
);
321 dlinkAdd(c
, &c
->link
, &cbdataEntries
);
322 debugs(45, 3, "cbdataAlloc: " << p
<< " " << file
<< ":" << line
);
330 cbdataInternalFreeDbg(void *p
, const char *file
, int line
)
332 cbdataInternalFree(void *p
)
337 c
= (cbdata
*) hash_lookup(cbdata_htable
, p
);
339 c
= (cbdata
*) (((char *) p
) - cbdata::Offset
);
343 debugs(45, 3, "cbdataFree: " << p
<< " " << file
<< ":" << line
);
346 debugs(45, 9, "cbdataFree: " << p
);
354 c
->addHistory("Free", file
, line
);
358 debugs(45, 9, "cbdataFree: " << p
<< " has " << c
->locks
<< " locks, not freeing");
363 debugs(45, 9, "cbdataFree: Freeing " << p
);
366 dlinkDelete(&c
->link
, &cbdataEntries
);
369 /* This is ugly. But: operator delete doesn't get
370 * the type parameter, so we can't use that
371 * to free the memory.
372 * So, we free it ourselves.
373 * Note that this means a non-placement
374 * new would be a seriously bad idea.
375 * Lastly, if we where a templated class,
376 * we could use the normal delete operator
377 * and it would Just Work. RBC 20030902
379 cbdata_type theType
= c
->type
;
381 hash_remove_link(cbdata_htable
, &c
->hash
);
383 cbdata_index
[theType
].pool
->free((void *)p
);
385 c
->cbdata::~cbdata();
386 cbdata_index
[theType
].pool
->free(c
);
393 cbdataInternalLockDbg(const void *p
, const char *file
, int line
)
395 cbdataInternalLock(const void *p
)
404 c
= (cbdata
*) hash_lookup(cbdata_htable
, p
);
406 c
= (cbdata
*) (((char *) p
) - cbdata::Offset
);
411 debugs(45, 3, "cbdataLock: " << p
<< "=" << (c
? c
->locks
+ 1 : -1) << " " << file
<< ":" << line
);
413 c
->addHistory("Reference", file
, line
);
417 debugs(45, 9, "cbdataLock: " << p
<< "=" << (c
? c
->locks
+ 1 : -1));
423 assert(c
->locks
< 65535);
430 cbdataInternalUnlockDbg(const void *p
, const char *file
, int line
)
432 cbdataInternalUnlock(const void *p
)
441 c
= (cbdata
*) hash_lookup(cbdata_htable
, p
);
443 c
= (cbdata
*) (((char *) p
) - cbdata::Offset
);
448 debugs(45, 3, "cbdataUnlock: " << p
<< "=" << (c
? c
->locks
- 1 : -1) << " " << file
<< ":" << line
);
450 c
->addHistory("Dereference", file
, line
);
454 debugs(45, 9, "cbdataUnlock: " << p
<< "=" << (c
? c
->locks
- 1 : -1));
462 assert(c
->locks
> 0);
466 if (c
->valid
|| c
->locks
)
471 debugs(45, 9, "cbdataUnlock: Freeing " << p
);
475 dlinkDelete(&c
->link
, &cbdataEntries
);
479 /* This is ugly. But: operator delete doesn't get
480 * the type parameter, so we can't use that
481 * to free the memory.
482 * So, we free it ourselves.
483 * Note that this means a non-placement
484 * new would be a seriously bad idea.
485 * Lastly, if we where a templated class,
486 * we could use the normal delete operator
487 * and it would Just Work. RBC 20030902
489 cbdata_type theType
= c
->type
;
491 hash_remove_link(cbdata_htable
, &c
->hash
);
493 cbdata_index
[theType
].pool
->free((void *)p
);
495 c
->cbdata::~cbdata();
496 cbdata_index
[theType
].pool
->free(c
);
501 cbdataReferenceValid(const void *p
)
506 return 1; /* A NULL pointer cannot become invalid */
508 debugs(45, 9, "cbdataReferenceValid: " << p
);
511 c
= (cbdata
*) hash_lookup(cbdata_htable
, p
);
513 c
= (cbdata
*) (((char *) p
) - cbdata::Offset
);
518 assert(c
->locks
> 0);
525 cbdataInternalReferenceDoneValidDbg(void **pp
, void **tp
, const char *file
, int line
)
527 cbdataInternalReferenceDoneValid(void **pp
, void **tp
)
530 void *p
= (void *) *pp
;
531 int valid
= cbdataReferenceValid(p
);
535 cbdataInternalUnlockDbg(p
, file
, line
);
538 cbdataInternalUnlock(p
);
552 cbdata::dump(StoreEntry
*sentry
) const
555 void *p
= (void *)hash
.key
;
557 void *p
= (void *)&data
;
559 storeAppendPrintf(sentry
, "%c%p\t%d\t%d\t%20s:%-5d\n", valid
? ' ' :
560 '!', p
, type
, locks
, file
, line
);
563 struct CBDataDumper
: public unary_function
<cbdata
, void>
565 CBDataDumper(StoreEntry
*anEntry
):where(anEntry
){}
567 void operator()(cbdata
const &x
)
578 cbdataDump(StoreEntry
* sentry
)
580 storeAppendPrintf(sentry
, "%d cbdata entries\n", cbdataCount
);
583 storeAppendPrintf(sentry
, "Pointer\tType\tLocks\tAllocated by\n");
584 CBDataDumper
dumper(sentry
);
585 for_each (cbdataEntries
, dumper
);
586 storeAppendPrintf(sentry
, "\n");
587 storeAppendPrintf(sentry
, "types\tsize\tallocated\ttotal\n");
589 for (int i
= 1; i
< cbdata_types
; i
++) {
590 MemAllocator
*pool
= cbdata_index
[i
].pool
;
594 int obj_size
= pool
->objectSize();
596 int obj_size
= pool
->objectSize() - cbdata::Offset
;
598 storeAppendPrintf(sentry
, "%s\t%d\t%ld\t%ld\n", pool
->objectType() + 7, obj_size
, (long int)pool
->getMeter().inuse
.level
, (long int)obj_size
* pool
->getMeter().inuse
.level
);
603 storeAppendPrintf(sentry
, "detailed allocation information only available when compiled with CBDATA_DEBUG\n");
607 storeAppendPrintf(sentry
, "\nsee also \"Memory utilization\" for detailed per type statistics\n");
610 CBDATA_CLASS_INIT(generic_cbdata
);
614 struct CBDataCallDumper
: public unary_function
<CBDataCall
, void>
616 CBDataCallDumper (StoreEntry
*anEntry
):where(anEntry
){}
618 void operator()(CBDataCall
const &x
)
620 storeAppendPrintf(where
, "%s\t%s\t%d\n", x
.label
, x
.file
, x
.line
);
626 struct CBDataHistoryDumper
: public CBDataDumper
628 CBDataHistoryDumper(StoreEntry
*anEntry
):CBDataDumper(anEntry
),where(anEntry
), callDumper(anEntry
){}
630 void operator()(cbdata
const &x
)
632 CBDataDumper::operator()(x
);
633 storeAppendPrintf(where
, "\n");
634 storeAppendPrintf(where
, "Action\tFile\tLine\n");
635 for_each (x
.calls
,callDumper
);
636 storeAppendPrintf(where
, "\n");
640 CBDataCallDumper callDumper
;
644 cbdataDumpHistory(StoreEntry
*sentry
)
646 storeAppendPrintf(sentry
, "%d cbdata entries\n", cbdataCount
);
647 storeAppendPrintf(sentry
, "Pointer\tType\tLocks\tAllocated by\n");
648 CBDataHistoryDumper
dumper(sentry
);
649 for_each (cbdataEntries
, dumper
);