contrib/sendmail-8.13.4/libsm/heap.c

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