1 /*
2 * Copyright (c) 2000-2001, 2004 Sendmail, Inc. and its suppliers.
3 * All rights reserved.
4 *
5 * By using this file, you agree to the terms and conditions set
6 * forth in the LICENSE file which can be found at the top level of
7 * the sendmail distribution.
8 */
9
10 #pragma ident "%Z%%M% %I% %E% SMI"
11
12 #include <sm/gen.h>
13 SM_RCSID("@(#)$Id: heap.c,v 1.51 2004/08/03 20:32:00 ca Exp $")
14
15 /*
16 ** debugging memory allocation package
17 ** See heap.html for documentation.
18 */
19
20 #include <string.h>
21
22 #include <sm/assert.h>
23 #include <sm/debug.h>
24 #include <sm/exc.h>
25 #include <sm/heap.h>
26 #include <sm/io.h>
27 #include <sm/signal.h>
28 #include <sm/xtrap.h>
29
30 /* undef all macro versions of the "functions" so they can be specified here */
31 #undef sm_malloc
32 #undef sm_malloc_x
33 #undef sm_malloc_tagged
34 #undef sm_malloc_tagged_x
35 #undef sm_free
36 #undef sm_free_tagged
37 #undef sm_realloc
38 #if SM_HEAP_CHECK
39 # undef sm_heap_register
40 # undef sm_heap_checkptr
41 # undef sm_heap_report
42 #endif /* SM_HEAP_CHECK */
43
44 #if SM_HEAP_CHECK
45 SM_DEBUG_T SmHeapCheck = SM_DEBUG_INITIALIZER("sm_check_heap",
46 "@(#)$Debug: sm_check_heap - check sm_malloc, sm_realloc, sm_free calls $");
47 # define HEAP_CHECK sm_debug_active(&SmHeapCheck, 1)
48 static int ptrhash __P((void *p));
49 #endif /* SM_HEAP_CHECK */
50
51 const SM_EXC_TYPE_T SmHeapOutOfMemoryType =
52 {
53 SmExcTypeMagic,
54 "F:sm.heap",
55 "",
56 sm_etype_printf,
57 "out of memory",
58 };
59
60 SM_EXC_T SmHeapOutOfMemory = SM_EXC_INITIALIZER(&SmHeapOutOfMemoryType, NULL);
61
62
63 /*
64 ** The behaviour of malloc with size==0 is platform dependent (it
65 ** says so in the C standard): it can return NULL or non-NULL. We
66 ** don't want sm_malloc_x(0) to raise an exception on some platforms
67 ** but not others, so this case requires special handling. We've got
68 ** two choices: "size = 1" or "return NULL". We use the former in the
69 ** following.
70 ** If we had something like autoconf we could figure out the
71 ** behaviour of the platform and either use this hack or just
72 ** use size.
73 */
74
75 #define MALLOC_SIZE(size) ((size) == 0 ? 1 : (size))
76
77 /*
78 ** SM_MALLOC_X -- wrapper around malloc(), raises an exception on error.
79 **
80 ** Parameters:
81 ** size -- size of requested memory.
82 **
83 ** Returns:
84 ** Pointer to memory region.
85 **
86 ** Note:
87 ** sm_malloc_x only gets called from source files in which heap
88 ** debugging is disabled at compile time. Otherwise, a call to
89 ** sm_malloc_x is macro expanded to a call to sm_malloc_tagged_x.
90 **
91 ** Exceptions:
92 ** F:sm_heap -- out of memory
93 */
94
95 void *
sm_malloc_x(size)96 sm_malloc_x(size)
97 size_t size;
98 {
99 void *ptr;
100
101 ENTER_CRITICAL();
102 ptr = malloc(MALLOC_SIZE(size));
103 LEAVE_CRITICAL();
104 if (ptr == NULL)
105 sm_exc_raise_x(&SmHeapOutOfMemory);
106 return ptr;
107 }
108
109 #if !SM_HEAP_CHECK
110
111 /*
112 ** SM_MALLOC -- wrapper around malloc()
113 **
114 ** Parameters:
115 ** size -- size of requested memory.
116 **
117 ** Returns:
118 ** Pointer to memory region.
119 */
120
121 void *
sm_malloc(size)122 sm_malloc(size)
123 size_t size;
124 {
125 void *ptr;
126
127 ENTER_CRITICAL();
128 ptr = malloc(MALLOC_SIZE(size));
129 LEAVE_CRITICAL();
130 return ptr;
131 }
132
133 /*
134 ** SM_REALLOC -- wrapper for realloc()
135 **
136 ** Parameters:
137 ** ptr -- pointer to old memory area.
138 ** size -- size of requested memory.
139 **
140 ** Returns:
141 ** Pointer to new memory area, NULL on failure.
142 */
143
144 void *
sm_realloc(ptr,size)145 sm_realloc(ptr, size)
146 void *ptr;
147 size_t size;
148 {
149 void *newptr;
150
151 ENTER_CRITICAL();
152 newptr = realloc(ptr, MALLOC_SIZE(size));
153 LEAVE_CRITICAL();
154 return newptr;
155 }
156
157 /*
158 ** SM_REALLOC_X -- wrapper for realloc()
159 **
160 ** Parameters:
161 ** ptr -- pointer to old memory area.
162 ** size -- size of requested memory.
163 **
164 ** Returns:
165 ** Pointer to new memory area.
166 **
167 ** Exceptions:
168 ** F:sm_heap -- out of memory
169 */
170
171 void *
sm_realloc_x(ptr,size)172 sm_realloc_x(ptr, size)
173 void *ptr;
174 size_t size;
175 {
176 void *newptr;
177
178 ENTER_CRITICAL();
179 newptr = realloc(ptr, MALLOC_SIZE(size));
180 LEAVE_CRITICAL();
181 if (newptr == NULL)
182 sm_exc_raise_x(&SmHeapOutOfMemory);
183 return newptr;
184 }
185 /*
186 ** SM_FREE -- wrapper around free()
187 **
188 ** Parameters:
189 ** ptr -- pointer to memory region.
190 **
191 ** Returns:
192 ** none.
193 */
194
195 void
sm_free(ptr)196 sm_free(ptr)
197 void *ptr;
198 {
199 if (ptr == NULL)
200 return;
201 ENTER_CRITICAL();
202 free(ptr);
203 LEAVE_CRITICAL();
204 return;
205 }
206
207 #else /* !SM_HEAP_CHECK */
208
209 /*
210 ** Each allocated block is assigned a "group number".
211 ** By default, all blocks are assigned to group #1.
212 ** By convention, group #0 is for memory that is never freed.
213 ** You can use group numbers any way you want, in order to help make
214 ** sense of sm_heap_report output.
215 */
216
217 int SmHeapGroup = 1;
218 int SmHeapMaxGroup = 1;
219
220 /*
221 ** Total number of bytes allocated.
222 ** This is only maintained if the sm_check_heap debug category is active.
223 */
224
225 size_t SmHeapTotal = 0;
226
227 /*
228 ** High water mark: the most that SmHeapTotal has ever been.
229 */
230
231 size_t SmHeapMaxTotal = 0;
232
233 /*
234 ** Maximum number of bytes that may be allocated at any one time.
235 ** 0 means no limit.
236 ** This is only honoured if sm_check_heap is active.
237 */
238
239 SM_DEBUG_T SmHeapLimit = SM_DEBUG_INITIALIZER("sm_heap_limit",
240 "@(#)$Debug: sm_heap_limit - max # of bytes permitted in heap $");
241
242 /*
243 ** This is the data structure that keeps track of all currently
244 ** allocated blocks of memory known to the heap package.
245 */
246
247 typedef struct sm_heap_item SM_HEAP_ITEM_T;
248 struct sm_heap_item
249 {
250 void *hi_ptr;
251 size_t hi_size;
252 char *hi_tag;
253 int hi_num;
254 int hi_group;
255 SM_HEAP_ITEM_T *hi_next;
256 };
257
258 #define SM_HEAP_TABLE_SIZE 256
259 static SM_HEAP_ITEM_T *SmHeapTable[SM_HEAP_TABLE_SIZE];
260
261 /*
262 ** This is a randomly generated table
263 ** which contains exactly one occurrence
264 ** of each of the numbers between 0 and 255.
265 ** It is used by ptrhash.
266 */
267
268 static unsigned char hashtab[SM_HEAP_TABLE_SIZE] =
269 {
270 161, 71, 77,187, 15,229, 9,176,221,119,239, 21, 85,138,203, 86,
271 102, 65, 80,199,235, 32,140, 96,224, 78,126,127,144, 0, 11,179,
272 64, 30,120, 23,225,226, 33, 50,205,167,130,240,174, 99,206, 73,
273 231,210,189,162, 48, 93,246, 54,213,141,135, 39, 41,192,236,193,
274 157, 88, 95,104,188, 63,133,177,234,110,158,214,238,131,233, 91,
275 125, 82, 94, 79, 66, 92,151, 45,252, 98, 26,183, 7,191,171,106,
276 145,154,251,100,113, 5, 74, 62, 76,124, 14,217,200, 75,115,190,
277 103, 28,198,196,169,219, 37,118,150, 18,152,175, 49,136, 6,142,
278 89, 19,243,254, 47,137, 24,166,180, 10, 40,186,202, 46,184, 67,
279 148,108,181, 81, 25,241, 13,139, 58, 38, 84,253,201, 12,116, 17,
280 195, 22,112, 69,255, 43,147,222,111, 56,194,216,149,244, 42,173,
281 232,220,249,105,207, 51,197,242, 72,211,208, 59,122,230,237,170,
282 165, 44, 68,123,129,245,143,101, 8,209,215,247,185, 57,218, 53,
283 114,121, 3,128, 4,204,212,146, 2,155, 83,250, 87, 29, 31,159,
284 60, 27,107,156,227,182, 1, 61, 36,160,109, 97, 90, 20,168,132,
285 223,248, 70,164, 55,172, 34, 52,163,117, 35,153,134, 16,178,228
286 };
287
288 /*
289 ** PTRHASH -- hash a pointer value
290 **
291 ** Parameters:
292 ** p -- pointer.
293 **
294 ** Returns:
295 ** hash value.
296 **
297 ** ptrhash hashes a pointer value to a uniformly distributed random
298 ** number between 0 and 255.
299 **
300 ** This hash algorithm is based on Peter K. Pearson,
301 ** "Fast Hashing of Variable-Length Text Strings",
302 ** in Communications of the ACM, June 1990, vol 33 no 6.
303 */
304
305 static int
ptrhash(p)306 ptrhash(p)
307 void *p;
308 {
309 int h;
310
311 if (sizeof(void*) == 4 && sizeof(unsigned long) == 4)
312 {
313 unsigned long n = (unsigned long)p;
314
315 h = hashtab[n & 0xFF];
316 h = hashtab[h ^ ((n >> 8) & 0xFF)];
317 h = hashtab[h ^ ((n >> 16) & 0xFF)];
318 h = hashtab[h ^ ((n >> 24) & 0xFF)];
319 }
320 # if 0
321 else if (sizeof(void*) == 8 && sizeof(unsigned long) == 8)
322 {
323 unsigned long n = (unsigned long)p;
324
325 h = hashtab[n & 0xFF];
326 h = hashtab[h ^ ((n >> 8) & 0xFF)];
327 h = hashtab[h ^ ((n >> 16) & 0xFF)];
328 h = hashtab[h ^ ((n >> 24) & 0xFF)];
329 h = hashtab[h ^ ((n >> 32) & 0xFF)];
330 h = hashtab[h ^ ((n >> 40) & 0xFF)];
331 h = hashtab[h ^ ((n >> 48) & 0xFF)];
332 h = hashtab[h ^ ((n >> 56) & 0xFF)];
333 }
334 # endif /* 0 */
335 else
336 {
337 unsigned char *cp = (unsigned char *)&p;
338 int i;
339
340 h = 0;
341 for (i = 0; i < sizeof(void*); ++i)
342 h = hashtab[h ^ cp[i]];
343 }
344 return h;
345 }
346
347 /*
348 ** SM_MALLOC_TAGGED -- wrapper around malloc(), debugging version.
349 **
350 ** Parameters:
351 ** size -- size of requested memory.
352 ** tag -- tag for debugging.
353 ** num -- additional value for debugging.
354 ** group -- heap group for debugging.
355 **
356 ** Returns:
357 ** Pointer to memory region.
358 */
359
360 void *
sm_malloc_tagged(size,tag,num,group)361 sm_malloc_tagged(size, tag, num, group)
362 size_t size;
363 char *tag;
364 int num;
365 int group;
366 {
367 void *ptr;
368
369 if (!HEAP_CHECK)
370 {
371 ENTER_CRITICAL();
372 ptr = malloc(MALLOC_SIZE(size));
373 LEAVE_CRITICAL();
374 return ptr;
375 }
376
377 if (sm_xtrap_check())
378 return NULL;
379 if (sm_debug_active(&SmHeapLimit, 1)
380 && sm_debug_level(&SmHeapLimit) < SmHeapTotal + size)
381 return NULL;
382 ENTER_CRITICAL();
383 ptr = malloc(MALLOC_SIZE(size));
384 LEAVE_CRITICAL();
385 if (ptr != NULL && !sm_heap_register(ptr, size, tag, num, group))
386 {
387 ENTER_CRITICAL();
388 free(ptr);
389 LEAVE_CRITICAL();
390 ptr = NULL;
391 }
392 SmHeapTotal += size;
393 if (SmHeapTotal > SmHeapMaxTotal)
394 SmHeapMaxTotal = SmHeapTotal;
395 return ptr;
396 }
397
398 /*
399 ** SM_MALLOC_TAGGED_X -- wrapper around malloc(), debugging version.
400 **
401 ** Parameters:
402 ** size -- size of requested memory.
403 ** tag -- tag for debugging.
404 ** num -- additional value for debugging.
405 ** group -- heap group for debugging.
406 **
407 ** Returns:
408 ** Pointer to memory region.
409 **
410 ** Exceptions:
411 ** F:sm_heap -- out of memory
412 */
413
414 void *
sm_malloc_tagged_x(size,tag,num,group)415 sm_malloc_tagged_x(size, tag, num, group)
416 size_t size;
417 char *tag;
418 int num;
419 int group;
420 {
421 void *ptr;
422
423 if (!HEAP_CHECK)
424 {
425 ENTER_CRITICAL();
426 ptr = malloc(MALLOC_SIZE(size));
427 LEAVE_CRITICAL();
428 if (ptr == NULL)
429 sm_exc_raise_x(&SmHeapOutOfMemory);
430 return ptr;
431 }
432
433 sm_xtrap_raise_x(&SmHeapOutOfMemory);
434 if (sm_debug_active(&SmHeapLimit, 1)
435 && sm_debug_level(&SmHeapLimit) < SmHeapTotal + size)
436 {
437 sm_exc_raise_x(&SmHeapOutOfMemory);
438 }
439 ENTER_CRITICAL();
440 ptr = malloc(MALLOC_SIZE(size));
441 LEAVE_CRITICAL();
442 if (ptr != NULL && !sm_heap_register(ptr, size, tag, num, group))
443 {
444 ENTER_CRITICAL();
445 free(ptr);
446 LEAVE_CRITICAL();
447 ptr = NULL;
448 }
449 if (ptr == NULL)
450 sm_exc_raise_x(&SmHeapOutOfMemory);
451 SmHeapTotal += size;
452 if (SmHeapTotal > SmHeapMaxTotal)
453 SmHeapMaxTotal = SmHeapTotal;
454 return ptr;
455 }
456
457 /*
458 ** SM_HEAP_REGISTER -- register a pointer into the heap for debugging.
459 **
460 ** Parameters:
461 ** ptr -- pointer to register.
462 ** size -- size of requested memory.
463 ** tag -- tag for debugging.
464 ** num -- additional value for debugging.
465 ** group -- heap group for debugging.
466 **
467 ** Returns:
468 ** true iff successfully registered (not yet in table).
469 */
470
471 bool
sm_heap_register(ptr,size,tag,num,group)472 sm_heap_register(ptr, size, tag, num, group)
473 void *ptr;
474 size_t size;
475 char *tag;
476 int num;
477 int group;
478 {
479 int i;
480 SM_HEAP_ITEM_T *hi;
481
482 if (!HEAP_CHECK)
483 return true;
484 SM_REQUIRE(ptr != NULL);
485 i = ptrhash(ptr);
486 # if SM_CHECK_REQUIRE
487
488 /*
489 ** We require that ptr is not already in SmHeapTable.
490 */
491
492 for (hi = SmHeapTable[i]; hi != NULL; hi = hi->hi_next)
493 {
494 if (hi->hi_ptr == ptr)
495 sm_abort("sm_heap_register: ptr %p is already registered (%s:%d)",
496 ptr, hi->hi_tag, hi->hi_num);
497 }
498 # endif /* SM_CHECK_REQUIRE */
499 ENTER_CRITICAL();
500 hi = (SM_HEAP_ITEM_T *) malloc(sizeof(SM_HEAP_ITEM_T));
501 LEAVE_CRITICAL();
502 if (hi == NULL)
503 return false;
504 hi->hi_ptr = ptr;
505 hi->hi_size = size;
506 hi->hi_tag = tag;
507 hi->hi_num = num;
508 hi->hi_group = group;
509 hi->hi_next = SmHeapTable[i];
510 SmHeapTable[i] = hi;
511 return true;
512 }
513 /*
514 ** SM_REALLOC -- wrapper for realloc(), debugging version.
515 **
516 ** Parameters:
517 ** ptr -- pointer to old memory area.
518 ** size -- size of requested memory.
519 **
520 ** Returns:
521 ** Pointer to new memory area, NULL on failure.
522 */
523
524 void *
sm_realloc(ptr,size)525 sm_realloc(ptr, size)
526 void *ptr;
527 size_t size;
528 {
529 void *newptr;
530 SM_HEAP_ITEM_T *hi, **hp;
531
532 if (!HEAP_CHECK)
533 {
534 ENTER_CRITICAL();
535 newptr = realloc(ptr, MALLOC_SIZE(size));
536 LEAVE_CRITICAL();
537 return newptr;
538 }
539
540 if (ptr == NULL)
541 return sm_malloc_tagged(size, "realloc", 0, SmHeapGroup);
542
543 for (hp = &SmHeapTable[ptrhash(ptr)]; *hp != NULL; hp = &(**hp).hi_next)
544 {
545 if ((**hp).hi_ptr == ptr)
546 {
547 if (sm_xtrap_check())
548 return NULL;
549 hi = *hp;
550 if (sm_debug_active(&SmHeapLimit, 1)
551 && sm_debug_level(&SmHeapLimit)
552 < SmHeapTotal - hi->hi_size + size)
553 {
554 return NULL;
555 }
556 ENTER_CRITICAL();
557 newptr = realloc(ptr, MALLOC_SIZE(size));
558 LEAVE_CRITICAL();
559 if (newptr == NULL)
560 return NULL;
561 SmHeapTotal = SmHeapTotal - hi->hi_size + size;
562 if (SmHeapTotal > SmHeapMaxTotal)
563 SmHeapMaxTotal = SmHeapTotal;
564 *hp = hi->hi_next;
565 hi->hi_ptr = newptr;
566 hi->hi_size = size;
567 hp = &SmHeapTable[ptrhash(newptr)];
568 hi->hi_next = *hp;
569 *hp = hi;
570 return newptr;
571 }
572 }
573 sm_abort("sm_realloc: bad argument (%p)", ptr);
574 /* NOTREACHED */
575 return NULL; /* keep Irix compiler happy */
576 }
577
578 /*
579 ** SM_REALLOC_X -- wrapper for realloc(), debugging version.
580 **
581 ** Parameters:
582 ** ptr -- pointer to old memory area.
583 ** size -- size of requested memory.
584 **
585 ** Returns:
586 ** Pointer to new memory area.
587 **
588 ** Exceptions:
589 ** F:sm_heap -- out of memory
590 */
591
592 void *
sm_realloc_x(ptr,size)593 sm_realloc_x(ptr, size)
594 void *ptr;
595 size_t size;
596 {
597 void *newptr;
598 SM_HEAP_ITEM_T *hi, **hp;
599
600 if (!HEAP_CHECK)
601 {
602 ENTER_CRITICAL();
603 newptr = realloc(ptr, MALLOC_SIZE(size));
604 LEAVE_CRITICAL();
605 if (newptr == NULL)
606 sm_exc_raise_x(&SmHeapOutOfMemory);
607 return newptr;
608 }
609
610 if (ptr == NULL)
611 return sm_malloc_tagged_x(size, "realloc", 0, SmHeapGroup);
612
613 for (hp = &SmHeapTable[ptrhash(ptr)]; *hp != NULL; hp = &(**hp).hi_next)
614 {
615 if ((**hp).hi_ptr == ptr)
616 {
617 sm_xtrap_raise_x(&SmHeapOutOfMemory);
618 hi = *hp;
619 if (sm_debug_active(&SmHeapLimit, 1)
620 && sm_debug_level(&SmHeapLimit)
621 < SmHeapTotal - hi->hi_size + size)
622 {
623 sm_exc_raise_x(&SmHeapOutOfMemory);
624 }
625 ENTER_CRITICAL();
626 newptr = realloc(ptr, MALLOC_SIZE(size));
627 LEAVE_CRITICAL();
628 if (newptr == NULL)
629 sm_exc_raise_x(&SmHeapOutOfMemory);
630 SmHeapTotal = SmHeapTotal - hi->hi_size + size;
631 if (SmHeapTotal > SmHeapMaxTotal)
632 SmHeapMaxTotal = SmHeapTotal;
633 *hp = hi->hi_next;
634 hi->hi_ptr = newptr;
635 hi->hi_size = size;
636 hp = &SmHeapTable[ptrhash(newptr)];
637 hi->hi_next = *hp;
638 *hp = hi;
639 return newptr;
640 }
641 }
642 sm_abort("sm_realloc_x: bad argument (%p)", ptr);
643 /* NOTREACHED */
644 return NULL; /* keep Irix compiler happy */
645 }
646
647 /*
648 ** SM_FREE_TAGGED -- wrapper around free(), debugging version.
649 **
650 ** Parameters:
651 ** ptr -- pointer to memory region.
652 ** tag -- tag for debugging.
653 ** num -- additional value for debugging.
654 **
655 ** Returns:
656 ** none.
657 */
658
659 void
sm_free_tagged(ptr,tag,num)660 sm_free_tagged(ptr, tag, num)
661 void *ptr;
662 char *tag;
663 int num;
664 {
665 SM_HEAP_ITEM_T **hp;
666
667 if (ptr == NULL)
668 return;
669 if (!HEAP_CHECK)
670 {
671 ENTER_CRITICAL();
672 free(ptr);
673 LEAVE_CRITICAL();
674 return;
675 }
676 for (hp = &SmHeapTable[ptrhash(ptr)]; *hp != NULL; hp = &(**hp).hi_next)
677 {
678 if ((**hp).hi_ptr == ptr)
679 {
680 SM_HEAP_ITEM_T *hi = *hp;
681
682 *hp = hi->hi_next;
683
684 /*
685 ** Fill the block with zeros before freeing.
686 ** This is intended to catch problems with
687 ** dangling pointers. The block is filled with
688 ** zeros, not with some non-zero value, because
689 ** it is common practice in some C code to store
690 ** a zero in a structure member before freeing the
691 ** structure, as a defense against dangling pointers.
692 */
693
694 (void) memset(ptr, 0, hi->hi_size);
695 SmHeapTotal -= hi->hi_size;
696 ENTER_CRITICAL();
697 free(ptr);
698 free(hi);
699 LEAVE_CRITICAL();
700 return;
701 }
702 }
703 sm_abort("sm_free: bad argument (%p) (%s:%d)", ptr, tag, num);
704 }
705
706 /*
707 ** SM_HEAP_CHECKPTR_TAGGED -- check whether ptr is a valid argument to sm_free
708 **
709 ** Parameters:
710 ** ptr -- pointer to memory region.
711 ** tag -- tag for debugging.
712 ** num -- additional value for debugging.
713 **
714 ** Returns:
715 ** none.
716 **
717 ** Side Effects:
718 ** aborts if check fails.
719 */
720
721 void
sm_heap_checkptr_tagged(ptr,tag,num)722 sm_heap_checkptr_tagged(ptr, tag, num)
723 void *ptr;
724 char *tag;
725 int num;
726 {
727 SM_HEAP_ITEM_T *hp;
728
729 if (!HEAP_CHECK)
730 return;
731 if (ptr == NULL)
732 return;
733 for (hp = SmHeapTable[ptrhash(ptr)]; hp != NULL; hp = hp->hi_next)
734 {
735 if (hp->hi_ptr == ptr)
736 return;
737 }
738 sm_abort("sm_heap_checkptr(%p): bad ptr (%s:%d)", ptr, tag, num);
739 }
740
741 /*
742 ** SM_HEAP_REPORT -- output "map" of used heap.
743 **
744 ** Parameters:
745 ** stream -- the file pointer to write to.
746 ** verbosity -- how much info?
747 **
748 ** Returns:
749 ** none.
750 */
751
752 void
sm_heap_report(stream,verbosity)753 sm_heap_report(stream, verbosity)
754 SM_FILE_T *stream;
755 int verbosity;
756 {
757 int i;
758 unsigned long group0total, group1total, otherstotal, grandtotal;
759
760 if (!HEAP_CHECK || verbosity <= 0)
761 return;
762 group0total = group1total = otherstotal = grandtotal = 0;
763 for (i = 0; i < sizeof(SmHeapTable) / sizeof(SmHeapTable[0]); ++i)
764 {
765 SM_HEAP_ITEM_T *hi = SmHeapTable[i];
766
767 while (hi != NULL)
768 {
769 if (verbosity > 2
770 || (verbosity > 1 && hi->hi_group != 0))
771 {
772 sm_io_fprintf(stream, SM_TIME_DEFAULT,
773 "%4d %*lx %7lu bytes",
774 hi->hi_group,
775 (int) sizeof(void *) * 2,
776 (long)hi->hi_ptr,
777 (unsigned long)hi->hi_size);
778 if (hi->hi_tag != NULL)
779 {
780 sm_io_fprintf(stream, SM_TIME_DEFAULT,
781 " %s",
782 hi->hi_tag);
783 if (hi->hi_num)
784 {
785 sm_io_fprintf(stream,
786 SM_TIME_DEFAULT,
787 ":%d",
788 hi->hi_num);
789 }
790 }
791 sm_io_fprintf(stream, SM_TIME_DEFAULT, "\n");
792 }
793 switch (hi->hi_group)
794 {
795 case 0:
796 group0total += hi->hi_size;
797 break;
798 case 1:
799 group1total += hi->hi_size;
800 break;
801 default:
802 otherstotal += hi->hi_size;
803 break;
804 }
805 grandtotal += hi->hi_size;
806 hi = hi->hi_next;
807 }
808 }
809 sm_io_fprintf(stream, SM_TIME_DEFAULT,
810 "heap max=%lu, total=%lu, ",
811 (unsigned long) SmHeapMaxTotal, grandtotal);
812 sm_io_fprintf(stream, SM_TIME_DEFAULT,
813 "group 0=%lu, group 1=%lu, others=%lu\n",
814 group0total, group1total, otherstotal);
815 if (grandtotal != SmHeapTotal)
816 {
817 sm_io_fprintf(stream, SM_TIME_DEFAULT,
818 "BUG => SmHeapTotal: got %lu, expected %lu\n",
819 (unsigned long) SmHeapTotal, grandtotal);
820 }
821 }
822 #endif /* !SM_HEAP_CHECK */
823