Annotation of embedaddon/ntp/lib/isc/mem.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2004-2009 Internet Systems Consortium, Inc. ("ISC")
! 3: * Copyright (C) 1997-2003 Internet Software Consortium.
! 4: *
! 5: * Permission to use, copy, modify, and/or distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
! 10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
! 11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
! 12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
! 13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
! 14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
! 15: * PERFORMANCE OF THIS SOFTWARE.
! 16: */
! 17:
! 18: /* $Id: mem.c,v 1.145.120.4 2009/02/16 03:17:05 marka Exp $ */
! 19:
! 20: /*! \file */
! 21:
! 22: #include <config.h>
! 23:
! 24: #include <stdio.h>
! 25: #include <stdlib.h>
! 26: #include <stddef.h>
! 27:
! 28: #include <limits.h>
! 29:
! 30: #include <isc/magic.h>
! 31: #include <isc/mem.h>
! 32: #include <isc/msgs.h>
! 33: #include <isc/once.h>
! 34: #include <isc/ondestroy.h>
! 35: #include <isc/string.h>
! 36: #include <isc/mutex.h>
! 37: #include <isc/print.h>
! 38: #include <isc/util.h>
! 39: #include <isc/xml.h>
! 40:
! 41: #define MCTXLOCK(m, l) if (((m)->flags & ISC_MEMFLAG_NOLOCK) == 0) LOCK(l)
! 42: #define MCTXUNLOCK(m, l) if (((m)->flags & ISC_MEMFLAG_NOLOCK) == 0) UNLOCK(l)
! 43:
! 44: #ifndef ISC_MEM_DEBUGGING
! 45: #define ISC_MEM_DEBUGGING 0
! 46: #endif
! 47: LIBISC_EXTERNAL_DATA unsigned int isc_mem_debugging = ISC_MEM_DEBUGGING;
! 48:
! 49: /*
! 50: * Constants.
! 51: */
! 52:
! 53: #define DEF_MAX_SIZE 1100
! 54: #define DEF_MEM_TARGET 4096
! 55: #define ALIGNMENT_SIZE 8U /*%< must be a power of 2 */
! 56: #define NUM_BASIC_BLOCKS 64 /*%< must be > 1 */
! 57: #define TABLE_INCREMENT 1024
! 58: #define DEBUGLIST_COUNT 1024
! 59:
! 60: /*
! 61: * Types.
! 62: */
! 63: #if ISC_MEM_TRACKLINES
! 64: typedef struct debuglink debuglink_t;
! 65: struct debuglink {
! 66: ISC_LINK(debuglink_t) link;
! 67: const void *ptr[DEBUGLIST_COUNT];
! 68: unsigned int size[DEBUGLIST_COUNT];
! 69: const char *file[DEBUGLIST_COUNT];
! 70: unsigned int line[DEBUGLIST_COUNT];
! 71: unsigned int count;
! 72: };
! 73:
! 74: #define FLARG_PASS , file, line
! 75: #define FLARG , const char *file, int line
! 76: #else
! 77: #define FLARG_PASS
! 78: #define FLARG
! 79: #endif
! 80:
! 81: typedef struct element element;
! 82: struct element {
! 83: element * next;
! 84: };
! 85:
! 86: typedef struct {
! 87: /*!
! 88: * This structure must be ALIGNMENT_SIZE bytes.
! 89: */
! 90: union {
! 91: size_t size;
! 92: isc_mem_t *ctx;
! 93: char bytes[ALIGNMENT_SIZE];
! 94: } u;
! 95: } size_info;
! 96:
! 97: struct stats {
! 98: unsigned long gets;
! 99: unsigned long totalgets;
! 100: unsigned long blocks;
! 101: unsigned long freefrags;
! 102: };
! 103:
! 104: #define MEM_MAGIC ISC_MAGIC('M', 'e', 'm', 'C')
! 105: #define VALID_CONTEXT(c) ISC_MAGIC_VALID(c, MEM_MAGIC)
! 106:
! 107: #if ISC_MEM_TRACKLINES
! 108: typedef ISC_LIST(debuglink_t) debuglist_t;
! 109: #endif
! 110:
! 111: /* List of all active memory contexts. */
! 112:
! 113: static ISC_LIST(isc_mem_t) contexts;
! 114: static isc_once_t once = ISC_ONCE_INIT;
! 115: static isc_mutex_t lock;
! 116:
! 117: /*%
! 118: * Total size of lost memory due to a bug of external library.
! 119: * Locked by the global lock.
! 120: */
! 121: static isc_uint64_t totallost;
! 122:
! 123: struct isc_mem {
! 124: unsigned int magic;
! 125: isc_ondestroy_t ondestroy;
! 126: unsigned int flags;
! 127: isc_mutex_t lock;
! 128: isc_memalloc_t memalloc;
! 129: isc_memfree_t memfree;
! 130: void * arg;
! 131: size_t max_size;
! 132: isc_boolean_t checkfree;
! 133: struct stats * stats;
! 134: unsigned int references;
! 135: char name[16];
! 136: void * tag;
! 137: size_t quota;
! 138: size_t total;
! 139: size_t inuse;
! 140: size_t maxinuse;
! 141: size_t hi_water;
! 142: size_t lo_water;
! 143: isc_boolean_t hi_called;
! 144: isc_mem_water_t water;
! 145: void * water_arg;
! 146: ISC_LIST(isc_mempool_t) pools;
! 147: unsigned int poolcnt;
! 148:
! 149: /* ISC_MEMFLAG_INTERNAL */
! 150: size_t mem_target;
! 151: element ** freelists;
! 152: element * basic_blocks;
! 153: unsigned char ** basic_table;
! 154: unsigned int basic_table_count;
! 155: unsigned int basic_table_size;
! 156: unsigned char * lowest;
! 157: unsigned char * highest;
! 158:
! 159: #if ISC_MEM_TRACKLINES
! 160: debuglist_t * debuglist;
! 161: unsigned int debuglistcnt;
! 162: #endif
! 163:
! 164: unsigned int memalloc_failures;
! 165: ISC_LINK(isc_mem_t) link;
! 166: };
! 167:
! 168: #define MEMPOOL_MAGIC ISC_MAGIC('M', 'E', 'M', 'p')
! 169: #define VALID_MEMPOOL(c) ISC_MAGIC_VALID(c, MEMPOOL_MAGIC)
! 170:
! 171: struct isc_mempool {
! 172: /* always unlocked */
! 173: unsigned int magic; /*%< magic number */
! 174: isc_mutex_t *lock; /*%< optional lock */
! 175: isc_mem_t *mctx; /*%< our memory context */
! 176: /*%< locked via the memory context's lock */
! 177: ISC_LINK(isc_mempool_t) link; /*%< next pool in this mem context */
! 178: /*%< optionally locked from here down */
! 179: element *items; /*%< low water item list */
! 180: size_t size; /*%< size of each item on this pool */
! 181: unsigned int maxalloc; /*%< max number of items allowed */
! 182: unsigned int allocated; /*%< # of items currently given out */
! 183: unsigned int freecount; /*%< # of items on reserved list */
! 184: unsigned int freemax; /*%< # of items allowed on free list */
! 185: unsigned int fillcount; /*%< # of items to fetch on each fill */
! 186: /*%< Stats only. */
! 187: unsigned int gets; /*%< # of requests to this pool */
! 188: /*%< Debugging only. */
! 189: #if ISC_MEMPOOL_NAMES
! 190: char name[16]; /*%< printed name in stats reports */
! 191: #endif
! 192: };
! 193:
! 194: /*
! 195: * Private Inline-able.
! 196: */
! 197:
! 198: #if ! ISC_MEM_TRACKLINES
! 199: #define ADD_TRACE(a, b, c, d, e)
! 200: #define DELETE_TRACE(a, b, c, d, e)
! 201: #else
! 202: #define ADD_TRACE(a, b, c, d, e) \
! 203: do { \
! 204: if ((isc_mem_debugging & (ISC_MEM_DEBUGTRACE | \
! 205: ISC_MEM_DEBUGRECORD)) != 0 && \
! 206: b != NULL) \
! 207: add_trace_entry(a, b, c, d, e); \
! 208: } while (0)
! 209: #define DELETE_TRACE(a, b, c, d, e) delete_trace_entry(a, b, c, d, e)
! 210:
! 211: static void
! 212: print_active(isc_mem_t *ctx, FILE *out);
! 213:
! 214: /*!
! 215: * mctx must be locked.
! 216: */
! 217: static inline void
! 218: add_trace_entry(isc_mem_t *mctx, const void *ptr, unsigned int size
! 219: FLARG)
! 220: {
! 221: debuglink_t *dl;
! 222: unsigned int i;
! 223:
! 224: if ((isc_mem_debugging & ISC_MEM_DEBUGTRACE) != 0)
! 225: fprintf(stderr, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 226: ISC_MSG_ADDTRACE,
! 227: "add %p size %u "
! 228: "file %s line %u mctx %p\n"),
! 229: ptr, size, file, line, mctx);
! 230:
! 231: if (mctx->debuglist == NULL)
! 232: return;
! 233:
! 234: if (size > mctx->max_size)
! 235: size = mctx->max_size;
! 236:
! 237: dl = ISC_LIST_HEAD(mctx->debuglist[size]);
! 238: while (dl != NULL) {
! 239: if (dl->count == DEBUGLIST_COUNT)
! 240: goto next;
! 241: for (i = 0; i < DEBUGLIST_COUNT; i++) {
! 242: if (dl->ptr[i] == NULL) {
! 243: dl->ptr[i] = ptr;
! 244: dl->size[i] = size;
! 245: dl->file[i] = file;
! 246: dl->line[i] = line;
! 247: dl->count++;
! 248: return;
! 249: }
! 250: }
! 251: next:
! 252: dl = ISC_LIST_NEXT(dl, link);
! 253: }
! 254:
! 255: dl = malloc(sizeof(debuglink_t));
! 256: INSIST(dl != NULL);
! 257:
! 258: ISC_LINK_INIT(dl, link);
! 259: for (i = 1; i < DEBUGLIST_COUNT; i++) {
! 260: dl->ptr[i] = NULL;
! 261: dl->size[i] = 0;
! 262: dl->file[i] = NULL;
! 263: dl->line[i] = 0;
! 264: }
! 265:
! 266: dl->ptr[0] = ptr;
! 267: dl->size[0] = size;
! 268: dl->file[0] = file;
! 269: dl->line[0] = line;
! 270: dl->count = 1;
! 271:
! 272: ISC_LIST_PREPEND(mctx->debuglist[size], dl, link);
! 273: mctx->debuglistcnt++;
! 274: }
! 275:
! 276: static inline void
! 277: delete_trace_entry(isc_mem_t *mctx, const void *ptr, unsigned int size,
! 278: const char *file, unsigned int line)
! 279: {
! 280: debuglink_t *dl;
! 281: unsigned int i;
! 282:
! 283: if ((isc_mem_debugging & ISC_MEM_DEBUGTRACE) != 0)
! 284: fprintf(stderr, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 285: ISC_MSG_DELTRACE,
! 286: "del %p size %u "
! 287: "file %s line %u mctx %p\n"),
! 288: ptr, size, file, line, mctx);
! 289:
! 290: if (mctx->debuglist == NULL)
! 291: return;
! 292:
! 293: if (size > mctx->max_size)
! 294: size = mctx->max_size;
! 295:
! 296: dl = ISC_LIST_HEAD(mctx->debuglist[size]);
! 297: while (dl != NULL) {
! 298: for (i = 0; i < DEBUGLIST_COUNT; i++) {
! 299: if (dl->ptr[i] == ptr) {
! 300: dl->ptr[i] = NULL;
! 301: dl->size[i] = 0;
! 302: dl->file[i] = NULL;
! 303: dl->line[i] = 0;
! 304:
! 305: INSIST(dl->count > 0);
! 306: dl->count--;
! 307: if (dl->count == 0) {
! 308: ISC_LIST_UNLINK(mctx->debuglist[size],
! 309: dl, link);
! 310: free(dl);
! 311: }
! 312: return;
! 313: }
! 314: }
! 315: dl = ISC_LIST_NEXT(dl, link);
! 316: }
! 317:
! 318: /*
! 319: * If we get here, we didn't find the item on the list. We're
! 320: * screwed.
! 321: */
! 322: INSIST(dl != NULL);
! 323: }
! 324: #endif /* ISC_MEM_TRACKLINES */
! 325:
! 326: static inline size_t
! 327: rmsize(size_t size) {
! 328: /*
! 329: * round down to ALIGNMENT_SIZE
! 330: */
! 331: return (size & (~(ALIGNMENT_SIZE - 1)));
! 332: }
! 333:
! 334: static inline size_t
! 335: quantize(size_t size) {
! 336: /*!
! 337: * Round up the result in order to get a size big
! 338: * enough to satisfy the request and be aligned on ALIGNMENT_SIZE
! 339: * byte boundaries.
! 340: */
! 341:
! 342: if (size == 0U)
! 343: return (ALIGNMENT_SIZE);
! 344: return ((size + ALIGNMENT_SIZE - 1) & (~(ALIGNMENT_SIZE - 1)));
! 345: }
! 346:
! 347: static inline isc_boolean_t
! 348: more_basic_blocks(isc_mem_t *ctx) {
! 349: void *new;
! 350: unsigned char *curr, *next;
! 351: unsigned char *first, *last;
! 352: unsigned char **table;
! 353: unsigned int table_size;
! 354: size_t increment;
! 355: int i;
! 356:
! 357: /* Require: we hold the context lock. */
! 358:
! 359: /*
! 360: * Did we hit the quota for this context?
! 361: */
! 362: increment = NUM_BASIC_BLOCKS * ctx->mem_target;
! 363: if (ctx->quota != 0U && ctx->total + increment > ctx->quota)
! 364: return (ISC_FALSE);
! 365:
! 366: INSIST(ctx->basic_table_count <= ctx->basic_table_size);
! 367: if (ctx->basic_table_count == ctx->basic_table_size) {
! 368: table_size = ctx->basic_table_size + TABLE_INCREMENT;
! 369: table = (ctx->memalloc)(ctx->arg,
! 370: table_size * sizeof(unsigned char *));
! 371: if (table == NULL) {
! 372: ctx->memalloc_failures++;
! 373: return (ISC_FALSE);
! 374: }
! 375: if (ctx->basic_table_size != 0) {
! 376: memcpy(table, ctx->basic_table,
! 377: ctx->basic_table_size *
! 378: sizeof(unsigned char *));
! 379: (ctx->memfree)(ctx->arg, ctx->basic_table);
! 380: }
! 381: ctx->basic_table = table;
! 382: ctx->basic_table_size = table_size;
! 383: }
! 384:
! 385: new = (ctx->memalloc)(ctx->arg, NUM_BASIC_BLOCKS * ctx->mem_target);
! 386: if (new == NULL) {
! 387: ctx->memalloc_failures++;
! 388: return (ISC_FALSE);
! 389: }
! 390: ctx->total += increment;
! 391: ctx->basic_table[ctx->basic_table_count] = new;
! 392: ctx->basic_table_count++;
! 393:
! 394: curr = new;
! 395: next = curr + ctx->mem_target;
! 396: for (i = 0; i < (NUM_BASIC_BLOCKS - 1); i++) {
! 397: ((element *)curr)->next = (element *)next;
! 398: curr = next;
! 399: next += ctx->mem_target;
! 400: }
! 401: /*
! 402: * curr is now pointing at the last block in the
! 403: * array.
! 404: */
! 405: ((element *)curr)->next = NULL;
! 406: first = new;
! 407: last = first + NUM_BASIC_BLOCKS * ctx->mem_target - 1;
! 408: if (first < ctx->lowest || ctx->lowest == NULL)
! 409: ctx->lowest = first;
! 410: if (last > ctx->highest)
! 411: ctx->highest = last;
! 412: ctx->basic_blocks = new;
! 413:
! 414: return (ISC_TRUE);
! 415: }
! 416:
! 417: static inline isc_boolean_t
! 418: more_frags(isc_mem_t *ctx, size_t new_size) {
! 419: int i, frags;
! 420: size_t total_size;
! 421: void *new;
! 422: unsigned char *curr, *next;
! 423:
! 424: /*!
! 425: * Try to get more fragments by chopping up a basic block.
! 426: */
! 427:
! 428: if (ctx->basic_blocks == NULL) {
! 429: if (!more_basic_blocks(ctx)) {
! 430: /*
! 431: * We can't get more memory from the OS, or we've
! 432: * hit the quota for this context.
! 433: */
! 434: /*
! 435: * XXXRTH "At quota" notification here.
! 436: */
! 437: return (ISC_FALSE);
! 438: }
! 439: }
! 440:
! 441: total_size = ctx->mem_target;
! 442: new = ctx->basic_blocks;
! 443: ctx->basic_blocks = ctx->basic_blocks->next;
! 444: frags = total_size / new_size;
! 445: ctx->stats[new_size].blocks++;
! 446: ctx->stats[new_size].freefrags += frags;
! 447: /*
! 448: * Set up a linked-list of blocks of size
! 449: * "new_size".
! 450: */
! 451: curr = new;
! 452: next = curr + new_size;
! 453: total_size -= new_size;
! 454: for (i = 0; i < (frags - 1); i++) {
! 455: ((element *)curr)->next = (element *)next;
! 456: curr = next;
! 457: next += new_size;
! 458: total_size -= new_size;
! 459: }
! 460: /*
! 461: * Add the remaining fragment of the basic block to a free list.
! 462: */
! 463: total_size = rmsize(total_size);
! 464: if (total_size > 0U) {
! 465: ((element *)next)->next = ctx->freelists[total_size];
! 466: ctx->freelists[total_size] = (element *)next;
! 467: ctx->stats[total_size].freefrags++;
! 468: }
! 469: /*
! 470: * curr is now pointing at the last block in the
! 471: * array.
! 472: */
! 473: ((element *)curr)->next = NULL;
! 474: ctx->freelists[new_size] = new;
! 475:
! 476: return (ISC_TRUE);
! 477: }
! 478:
! 479: static inline void *
! 480: mem_getunlocked(isc_mem_t *ctx, size_t size) {
! 481: size_t new_size = quantize(size);
! 482: void *ret;
! 483:
! 484: if (size >= ctx->max_size || new_size >= ctx->max_size) {
! 485: /*
! 486: * memget() was called on something beyond our upper limit.
! 487: */
! 488: if (ctx->quota != 0U && ctx->total + size > ctx->quota) {
! 489: ret = NULL;
! 490: goto done;
! 491: }
! 492: ret = (ctx->memalloc)(ctx->arg, size);
! 493: if (ret == NULL) {
! 494: ctx->memalloc_failures++;
! 495: goto done;
! 496: }
! 497: ctx->total += size;
! 498: ctx->inuse += size;
! 499: ctx->stats[ctx->max_size].gets++;
! 500: ctx->stats[ctx->max_size].totalgets++;
! 501: /*
! 502: * If we don't set new_size to size, then the
! 503: * ISC_MEM_FILL code might write over bytes we
! 504: * don't own.
! 505: */
! 506: new_size = size;
! 507: goto done;
! 508: }
! 509:
! 510: /*
! 511: * If there are no blocks in the free list for this size, get a chunk
! 512: * of memory and then break it up into "new_size"-sized blocks, adding
! 513: * them to the free list.
! 514: */
! 515: if (ctx->freelists[new_size] == NULL && !more_frags(ctx, new_size))
! 516: return (NULL);
! 517:
! 518: /*
! 519: * The free list uses the "rounded-up" size "new_size".
! 520: */
! 521: ret = ctx->freelists[new_size];
! 522: ctx->freelists[new_size] = ctx->freelists[new_size]->next;
! 523:
! 524: /*
! 525: * The stats[] uses the _actual_ "size" requested by the
! 526: * caller, with the caveat (in the code above) that "size" >= the
! 527: * max. size (max_size) ends up getting recorded as a call to
! 528: * max_size.
! 529: */
! 530: ctx->stats[size].gets++;
! 531: ctx->stats[size].totalgets++;
! 532: ctx->stats[new_size].freefrags--;
! 533: ctx->inuse += new_size;
! 534:
! 535: done:
! 536:
! 537: #if ISC_MEM_FILL
! 538: if (ret != NULL)
! 539: memset(ret, 0xbe, new_size); /* Mnemonic for "beef". */
! 540: #endif
! 541:
! 542: return (ret);
! 543: }
! 544:
! 545: #if ISC_MEM_FILL && ISC_MEM_CHECKOVERRUN
! 546: static inline void
! 547: check_overrun(void *mem, size_t size, size_t new_size) {
! 548: unsigned char *cp;
! 549:
! 550: cp = (unsigned char *)mem;
! 551: cp += size;
! 552: while (size < new_size) {
! 553: INSIST(*cp == 0xbe);
! 554: cp++;
! 555: size++;
! 556: }
! 557: }
! 558: #endif
! 559:
! 560: static inline void
! 561: mem_putunlocked(isc_mem_t *ctx, void *mem, size_t size) {
! 562: size_t new_size = quantize(size);
! 563:
! 564: if (size == ctx->max_size || new_size >= ctx->max_size) {
! 565: /*
! 566: * memput() called on something beyond our upper limit.
! 567: */
! 568: #if ISC_MEM_FILL
! 569: memset(mem, 0xde, size); /* Mnemonic for "dead". */
! 570: #endif
! 571: (ctx->memfree)(ctx->arg, mem);
! 572: INSIST(ctx->stats[ctx->max_size].gets != 0U);
! 573: ctx->stats[ctx->max_size].gets--;
! 574: INSIST(size <= ctx->total);
! 575: ctx->inuse -= size;
! 576: ctx->total -= size;
! 577: return;
! 578: }
! 579:
! 580: #if ISC_MEM_FILL
! 581: #if ISC_MEM_CHECKOVERRUN
! 582: check_overrun(mem, size, new_size);
! 583: #endif
! 584: memset(mem, 0xde, new_size); /* Mnemonic for "dead". */
! 585: #endif
! 586:
! 587: /*
! 588: * The free list uses the "rounded-up" size "new_size".
! 589: */
! 590: ((element *)mem)->next = ctx->freelists[new_size];
! 591: ctx->freelists[new_size] = (element *)mem;
! 592:
! 593: /*
! 594: * The stats[] uses the _actual_ "size" requested by the
! 595: * caller, with the caveat (in the code above) that "size" >= the
! 596: * max. size (max_size) ends up getting recorded as a call to
! 597: * max_size.
! 598: */
! 599: INSIST(ctx->stats[size].gets != 0U);
! 600: ctx->stats[size].gets--;
! 601: ctx->stats[new_size].freefrags++;
! 602: ctx->inuse -= new_size;
! 603: }
! 604:
! 605: /*!
! 606: * Perform a malloc, doing memory filling and overrun detection as necessary.
! 607: */
! 608: static inline void *
! 609: mem_get(isc_mem_t *ctx, size_t size) {
! 610: char *ret;
! 611:
! 612: #if ISC_MEM_CHECKOVERRUN
! 613: size += 1;
! 614: #endif
! 615:
! 616: ret = (ctx->memalloc)(ctx->arg, size);
! 617: if (ret == NULL)
! 618: ctx->memalloc_failures++;
! 619:
! 620: #if ISC_MEM_FILL
! 621: if (ret != NULL)
! 622: memset(ret, 0xbe, size); /* Mnemonic for "beef". */
! 623: #else
! 624: # if ISC_MEM_CHECKOVERRUN
! 625: if (ret != NULL)
! 626: ret[size-1] = 0xbe;
! 627: # endif
! 628: #endif
! 629:
! 630: return (ret);
! 631: }
! 632:
! 633: /*!
! 634: * Perform a free, doing memory filling and overrun detection as necessary.
! 635: */
! 636: static inline void
! 637: mem_put(isc_mem_t *ctx, void *mem, size_t size) {
! 638: #if ISC_MEM_CHECKOVERRUN
! 639: INSIST(((unsigned char *)mem)[size] == 0xbe);
! 640: #endif
! 641: #if ISC_MEM_FILL
! 642: memset(mem, 0xde, size); /* Mnemonic for "dead". */
! 643: #else
! 644: UNUSED(size);
! 645: #endif
! 646: (ctx->memfree)(ctx->arg, mem);
! 647: }
! 648:
! 649: /*!
! 650: * Update internal counters after a memory get.
! 651: */
! 652: static inline void
! 653: mem_getstats(isc_mem_t *ctx, size_t size) {
! 654: ctx->total += size;
! 655: ctx->inuse += size;
! 656:
! 657: if (size > ctx->max_size) {
! 658: ctx->stats[ctx->max_size].gets++;
! 659: ctx->stats[ctx->max_size].totalgets++;
! 660: } else {
! 661: ctx->stats[size].gets++;
! 662: ctx->stats[size].totalgets++;
! 663: }
! 664: }
! 665:
! 666: /*!
! 667: * Update internal counters after a memory put.
! 668: */
! 669: static inline void
! 670: mem_putstats(isc_mem_t *ctx, void *ptr, size_t size) {
! 671: UNUSED(ptr);
! 672:
! 673: INSIST(ctx->inuse >= size);
! 674: ctx->inuse -= size;
! 675:
! 676: if (size > ctx->max_size) {
! 677: INSIST(ctx->stats[ctx->max_size].gets > 0U);
! 678: ctx->stats[ctx->max_size].gets--;
! 679: } else {
! 680: INSIST(ctx->stats[size].gets > 0U);
! 681: ctx->stats[size].gets--;
! 682: }
! 683: }
! 684:
! 685: /*
! 686: * Private.
! 687: */
! 688:
! 689: static void *
! 690: default_memalloc(void *arg, size_t size) {
! 691: UNUSED(arg);
! 692: if (size == 0U)
! 693: size = 1;
! 694: return (malloc(size));
! 695: }
! 696:
! 697: static void
! 698: default_memfree(void *arg, void *ptr) {
! 699: UNUSED(arg);
! 700: free(ptr);
! 701: }
! 702:
! 703: static void
! 704: initialize_action(void) {
! 705: RUNTIME_CHECK(isc_mutex_init(&lock) == ISC_R_SUCCESS);
! 706: ISC_LIST_INIT(contexts);
! 707: totallost = 0;
! 708: }
! 709:
! 710: /*
! 711: * Public.
! 712: */
! 713:
! 714: isc_result_t
! 715: isc_mem_createx(size_t init_max_size, size_t target_size,
! 716: isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
! 717: isc_mem_t **ctxp)
! 718: {
! 719: return (isc_mem_createx2(init_max_size, target_size, memalloc, memfree,
! 720: arg, ctxp, ISC_MEMFLAG_DEFAULT));
! 721:
! 722: }
! 723:
! 724: isc_result_t
! 725: isc_mem_createx2(size_t init_max_size, size_t target_size,
! 726: isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
! 727: isc_mem_t **ctxp, unsigned int flags)
! 728: {
! 729: isc_mem_t *ctx;
! 730: isc_result_t result;
! 731:
! 732: REQUIRE(ctxp != NULL && *ctxp == NULL);
! 733: REQUIRE(memalloc != NULL);
! 734: REQUIRE(memfree != NULL);
! 735:
! 736: INSIST((ALIGNMENT_SIZE & (ALIGNMENT_SIZE - 1)) == 0);
! 737:
! 738: RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
! 739:
! 740: ctx = (memalloc)(arg, sizeof(*ctx));
! 741: if (ctx == NULL)
! 742: return (ISC_R_NOMEMORY);
! 743:
! 744: if ((flags & ISC_MEMFLAG_NOLOCK) == 0) {
! 745: result = isc_mutex_init(&ctx->lock);
! 746: if (result != ISC_R_SUCCESS) {
! 747: (memfree)(arg, ctx);
! 748: return (result);
! 749: }
! 750: }
! 751:
! 752: if (init_max_size == 0U)
! 753: ctx->max_size = DEF_MAX_SIZE;
! 754: else
! 755: ctx->max_size = init_max_size;
! 756: ctx->flags = flags;
! 757: ctx->references = 1;
! 758: memset(ctx->name, 0, sizeof(ctx->name));
! 759: ctx->tag = NULL;
! 760: ctx->quota = 0;
! 761: ctx->total = 0;
! 762: ctx->inuse = 0;
! 763: ctx->maxinuse = 0;
! 764: ctx->hi_water = 0;
! 765: ctx->lo_water = 0;
! 766: ctx->hi_called = ISC_FALSE;
! 767: ctx->water = NULL;
! 768: ctx->water_arg = NULL;
! 769: ctx->magic = MEM_MAGIC;
! 770: isc_ondestroy_init(&ctx->ondestroy);
! 771: ctx->memalloc = memalloc;
! 772: ctx->memfree = memfree;
! 773: ctx->arg = arg;
! 774: ctx->stats = NULL;
! 775: ctx->checkfree = ISC_TRUE;
! 776: #if ISC_MEM_TRACKLINES
! 777: ctx->debuglist = NULL;
! 778: ctx->debuglistcnt = 0;
! 779: #endif
! 780: ISC_LIST_INIT(ctx->pools);
! 781: ctx->poolcnt = 0;
! 782: ctx->freelists = NULL;
! 783: ctx->basic_blocks = NULL;
! 784: ctx->basic_table = NULL;
! 785: ctx->basic_table_count = 0;
! 786: ctx->basic_table_size = 0;
! 787: ctx->lowest = NULL;
! 788: ctx->highest = NULL;
! 789:
! 790: ctx->stats = (memalloc)(arg,
! 791: (ctx->max_size+1) * sizeof(struct stats));
! 792: if (ctx->stats == NULL) {
! 793: result = ISC_R_NOMEMORY;
! 794: goto error;
! 795: }
! 796: memset(ctx->stats, 0, (ctx->max_size + 1) * sizeof(struct stats));
! 797:
! 798: if ((flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 799: if (target_size == 0U)
! 800: ctx->mem_target = DEF_MEM_TARGET;
! 801: else
! 802: ctx->mem_target = target_size;
! 803: ctx->freelists = (memalloc)(arg, ctx->max_size *
! 804: sizeof(element *));
! 805: if (ctx->freelists == NULL) {
! 806: result = ISC_R_NOMEMORY;
! 807: goto error;
! 808: }
! 809: memset(ctx->freelists, 0,
! 810: ctx->max_size * sizeof(element *));
! 811: }
! 812:
! 813: #if ISC_MEM_TRACKLINES
! 814: if ((isc_mem_debugging & ISC_MEM_DEBUGRECORD) != 0) {
! 815: unsigned int i;
! 816:
! 817: ctx->debuglist = (memalloc)(arg,
! 818: (ctx->max_size+1) * sizeof(debuglist_t));
! 819: if (ctx->debuglist == NULL) {
! 820: result = ISC_R_NOMEMORY;
! 821: goto error;
! 822: }
! 823: for (i = 0; i <= ctx->max_size; i++)
! 824: ISC_LIST_INIT(ctx->debuglist[i]);
! 825: }
! 826: #endif
! 827:
! 828: ctx->memalloc_failures = 0;
! 829:
! 830: LOCK(&lock);
! 831: ISC_LIST_INITANDAPPEND(contexts, ctx, link);
! 832: UNLOCK(&lock);
! 833:
! 834: *ctxp = ctx;
! 835: return (ISC_R_SUCCESS);
! 836:
! 837: error:
! 838: if (ctx != NULL) {
! 839: if (ctx->stats != NULL)
! 840: (memfree)(arg, ctx->stats);
! 841: if (ctx->freelists != NULL)
! 842: (memfree)(arg, ctx->freelists);
! 843: #if ISC_MEM_TRACKLINES
! 844: if (ctx->debuglist != NULL)
! 845: (ctx->memfree)(ctx->arg, ctx->debuglist);
! 846: #endif /* ISC_MEM_TRACKLINES */
! 847: if ((ctx->flags & ISC_MEMFLAG_NOLOCK) == 0)
! 848: DESTROYLOCK(&ctx->lock);
! 849: (memfree)(arg, ctx);
! 850: }
! 851:
! 852: return (result);
! 853: }
! 854:
! 855: isc_result_t
! 856: isc_mem_create(size_t init_max_size, size_t target_size,
! 857: isc_mem_t **ctxp)
! 858: {
! 859: return (isc_mem_createx2(init_max_size, target_size,
! 860: default_memalloc, default_memfree, NULL,
! 861: ctxp, ISC_MEMFLAG_DEFAULT));
! 862: }
! 863:
! 864: isc_result_t
! 865: isc_mem_create2(size_t init_max_size, size_t target_size,
! 866: isc_mem_t **ctxp, unsigned int flags)
! 867: {
! 868: return (isc_mem_createx2(init_max_size, target_size,
! 869: default_memalloc, default_memfree, NULL,
! 870: ctxp, flags));
! 871: }
! 872:
! 873: static void
! 874: destroy(isc_mem_t *ctx) {
! 875: unsigned int i;
! 876: isc_ondestroy_t ondest;
! 877:
! 878: ctx->magic = 0;
! 879:
! 880: LOCK(&lock);
! 881: ISC_LIST_UNLINK(contexts, ctx, link);
! 882: totallost += ctx->inuse;
! 883: UNLOCK(&lock);
! 884:
! 885: INSIST(ISC_LIST_EMPTY(ctx->pools));
! 886:
! 887: #if ISC_MEM_TRACKLINES
! 888: if (ctx->debuglist != NULL) {
! 889: if (ctx->checkfree) {
! 890: for (i = 0; i <= ctx->max_size; i++) {
! 891: if (!ISC_LIST_EMPTY(ctx->debuglist[i]))
! 892: print_active(ctx, stderr);
! 893: INSIST(ISC_LIST_EMPTY(ctx->debuglist[i]));
! 894: }
! 895: } else {
! 896: debuglink_t *dl;
! 897:
! 898: for (i = 0; i <= ctx->max_size; i++)
! 899: for (dl = ISC_LIST_HEAD(ctx->debuglist[i]);
! 900: dl != NULL;
! 901: dl = ISC_LIST_HEAD(ctx->debuglist[i])) {
! 902: ISC_LIST_UNLINK(ctx->debuglist[i],
! 903: dl, link);
! 904: free(dl);
! 905: }
! 906: }
! 907: (ctx->memfree)(ctx->arg, ctx->debuglist);
! 908: }
! 909: #endif
! 910: INSIST(ctx->references == 0);
! 911:
! 912: if (ctx->checkfree) {
! 913: for (i = 0; i <= ctx->max_size; i++) {
! 914: #if ISC_MEM_TRACKLINES
! 915: if (ctx->stats[i].gets != 0U)
! 916: print_active(ctx, stderr);
! 917: #endif
! 918: INSIST(ctx->stats[i].gets == 0U);
! 919: }
! 920: }
! 921:
! 922: (ctx->memfree)(ctx->arg, ctx->stats);
! 923:
! 924: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 925: for (i = 0; i < ctx->basic_table_count; i++)
! 926: (ctx->memfree)(ctx->arg, ctx->basic_table[i]);
! 927: (ctx->memfree)(ctx->arg, ctx->freelists);
! 928: if (ctx->basic_table != NULL)
! 929: (ctx->memfree)(ctx->arg, ctx->basic_table);
! 930: }
! 931:
! 932: ondest = ctx->ondestroy;
! 933:
! 934: if ((ctx->flags & ISC_MEMFLAG_NOLOCK) == 0)
! 935: DESTROYLOCK(&ctx->lock);
! 936: (ctx->memfree)(ctx->arg, ctx);
! 937:
! 938: isc_ondestroy_notify(&ondest, ctx);
! 939: }
! 940:
! 941: void
! 942: isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
! 943: REQUIRE(VALID_CONTEXT(source));
! 944: REQUIRE(targetp != NULL && *targetp == NULL);
! 945:
! 946: MCTXLOCK(source, &source->lock);
! 947: source->references++;
! 948: MCTXUNLOCK(source, &source->lock);
! 949:
! 950: *targetp = source;
! 951: }
! 952:
! 953: void
! 954: isc_mem_detach(isc_mem_t **ctxp) {
! 955: isc_mem_t *ctx;
! 956: isc_boolean_t want_destroy = ISC_FALSE;
! 957:
! 958: REQUIRE(ctxp != NULL);
! 959: ctx = *ctxp;
! 960: REQUIRE(VALID_CONTEXT(ctx));
! 961:
! 962: MCTXLOCK(ctx, &ctx->lock);
! 963: INSIST(ctx->references > 0);
! 964: ctx->references--;
! 965: if (ctx->references == 0)
! 966: want_destroy = ISC_TRUE;
! 967: MCTXUNLOCK(ctx, &ctx->lock);
! 968:
! 969: if (want_destroy)
! 970: destroy(ctx);
! 971:
! 972: *ctxp = NULL;
! 973: }
! 974:
! 975: /*
! 976: * isc_mem_putanddetach() is the equivalent of:
! 977: *
! 978: * mctx = NULL;
! 979: * isc_mem_attach(ptr->mctx, &mctx);
! 980: * isc_mem_detach(&ptr->mctx);
! 981: * isc_mem_put(mctx, ptr, sizeof(*ptr);
! 982: * isc_mem_detach(&mctx);
! 983: */
! 984:
! 985: void
! 986: isc__mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG) {
! 987: isc_mem_t *ctx;
! 988: isc_boolean_t want_destroy = ISC_FALSE;
! 989: size_info *si;
! 990: size_t oldsize;
! 991:
! 992: REQUIRE(ctxp != NULL);
! 993: ctx = *ctxp;
! 994: REQUIRE(VALID_CONTEXT(ctx));
! 995: REQUIRE(ptr != NULL);
! 996:
! 997: /*
! 998: * Must be before mem_putunlocked() as ctxp is usually within
! 999: * [ptr..ptr+size).
! 1000: */
! 1001: *ctxp = NULL;
! 1002:
! 1003: if ((isc_mem_debugging & (ISC_MEM_DEBUGSIZE|ISC_MEM_DEBUGCTX)) != 0) {
! 1004: if ((isc_mem_debugging & ISC_MEM_DEBUGSIZE) != 0) {
! 1005: si = &(((size_info *)ptr)[-1]);
! 1006: oldsize = si->u.size - ALIGNMENT_SIZE;
! 1007: if ((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0)
! 1008: oldsize -= ALIGNMENT_SIZE;
! 1009: INSIST(oldsize == size);
! 1010: }
! 1011: isc__mem_free(ctx, ptr FLARG_PASS);
! 1012:
! 1013: MCTXLOCK(ctx, &ctx->lock);
! 1014: ctx->references--;
! 1015: if (ctx->references == 0)
! 1016: want_destroy = ISC_TRUE;
! 1017: MCTXUNLOCK(ctx, &ctx->lock);
! 1018: if (want_destroy)
! 1019: destroy(ctx);
! 1020:
! 1021: return;
! 1022: }
! 1023:
! 1024: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1025: MCTXLOCK(ctx, &ctx->lock);
! 1026: mem_putunlocked(ctx, ptr, size);
! 1027: } else {
! 1028: mem_put(ctx, ptr, size);
! 1029: MCTXLOCK(ctx, &ctx->lock);
! 1030: mem_putstats(ctx, ptr, size);
! 1031: }
! 1032:
! 1033: DELETE_TRACE(ctx, ptr, size, file, line);
! 1034: INSIST(ctx->references > 0);
! 1035: ctx->references--;
! 1036: if (ctx->references == 0)
! 1037: want_destroy = ISC_TRUE;
! 1038:
! 1039: MCTXUNLOCK(ctx, &ctx->lock);
! 1040:
! 1041: if (want_destroy)
! 1042: destroy(ctx);
! 1043: }
! 1044:
! 1045: void
! 1046: isc_mem_destroy(isc_mem_t **ctxp) {
! 1047: isc_mem_t *ctx;
! 1048:
! 1049: /*
! 1050: * This routine provides legacy support for callers who use mctxs
! 1051: * without attaching/detaching.
! 1052: */
! 1053:
! 1054: REQUIRE(ctxp != NULL);
! 1055: ctx = *ctxp;
! 1056: REQUIRE(VALID_CONTEXT(ctx));
! 1057:
! 1058: MCTXLOCK(ctx, &ctx->lock);
! 1059: #if ISC_MEM_TRACKLINES
! 1060: if (ctx->references != 1)
! 1061: print_active(ctx, stderr);
! 1062: #endif
! 1063: REQUIRE(ctx->references == 1);
! 1064: ctx->references--;
! 1065: MCTXUNLOCK(ctx, &ctx->lock);
! 1066:
! 1067: destroy(ctx);
! 1068:
! 1069: *ctxp = NULL;
! 1070: }
! 1071:
! 1072: isc_result_t
! 1073: isc_mem_ondestroy(isc_mem_t *ctx, isc_task_t *task, isc_event_t **event) {
! 1074: isc_result_t res;
! 1075:
! 1076: MCTXLOCK(ctx, &ctx->lock);
! 1077: res = isc_ondestroy_register(&ctx->ondestroy, task, event);
! 1078: MCTXUNLOCK(ctx, &ctx->lock);
! 1079:
! 1080: return (res);
! 1081: }
! 1082:
! 1083:
! 1084: void *
! 1085: isc__mem_get(isc_mem_t *ctx, size_t size FLARG) {
! 1086: void *ptr;
! 1087: isc_boolean_t call_water = ISC_FALSE;
! 1088:
! 1089: REQUIRE(VALID_CONTEXT(ctx));
! 1090:
! 1091: if ((isc_mem_debugging & (ISC_MEM_DEBUGSIZE|ISC_MEM_DEBUGCTX)) != 0)
! 1092: return (isc__mem_allocate(ctx, size FLARG_PASS));
! 1093:
! 1094: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1095: MCTXLOCK(ctx, &ctx->lock);
! 1096: ptr = mem_getunlocked(ctx, size);
! 1097: } else {
! 1098: ptr = mem_get(ctx, size);
! 1099: MCTXLOCK(ctx, &ctx->lock);
! 1100: if (ptr != NULL)
! 1101: mem_getstats(ctx, size);
! 1102: }
! 1103:
! 1104: ADD_TRACE(ctx, ptr, size, file, line);
! 1105: if (ctx->hi_water != 0U && !ctx->hi_called &&
! 1106: ctx->inuse > ctx->hi_water) {
! 1107: call_water = ISC_TRUE;
! 1108: }
! 1109: if (ctx->inuse > ctx->maxinuse) {
! 1110: ctx->maxinuse = ctx->inuse;
! 1111: if (ctx->hi_water != 0U && ctx->inuse > ctx->hi_water &&
! 1112: (isc_mem_debugging & ISC_MEM_DEBUGUSAGE) != 0)
! 1113: fprintf(stderr, "maxinuse = %lu\n",
! 1114: (unsigned long)ctx->inuse);
! 1115: }
! 1116: MCTXUNLOCK(ctx, &ctx->lock);
! 1117:
! 1118: if (call_water)
! 1119: (ctx->water)(ctx->water_arg, ISC_MEM_HIWATER);
! 1120:
! 1121: return (ptr);
! 1122: }
! 1123:
! 1124: void
! 1125: isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG)
! 1126: {
! 1127: isc_boolean_t call_water = ISC_FALSE;
! 1128: size_info *si;
! 1129: size_t oldsize;
! 1130:
! 1131: REQUIRE(VALID_CONTEXT(ctx));
! 1132: REQUIRE(ptr != NULL);
! 1133:
! 1134: if ((isc_mem_debugging & (ISC_MEM_DEBUGSIZE|ISC_MEM_DEBUGCTX)) != 0) {
! 1135: if ((isc_mem_debugging & ISC_MEM_DEBUGSIZE) != 0) {
! 1136: si = &(((size_info *)ptr)[-1]);
! 1137: oldsize = si->u.size - ALIGNMENT_SIZE;
! 1138: if ((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0)
! 1139: oldsize -= ALIGNMENT_SIZE;
! 1140: INSIST(oldsize == size);
! 1141: }
! 1142: isc__mem_free(ctx, ptr FLARG_PASS);
! 1143: return;
! 1144: }
! 1145:
! 1146: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1147: MCTXLOCK(ctx, &ctx->lock);
! 1148: mem_putunlocked(ctx, ptr, size);
! 1149: } else {
! 1150: mem_put(ctx, ptr, size);
! 1151: MCTXLOCK(ctx, &ctx->lock);
! 1152: mem_putstats(ctx, ptr, size);
! 1153: }
! 1154:
! 1155: DELETE_TRACE(ctx, ptr, size, file, line);
! 1156:
! 1157: /*
! 1158: * The check against ctx->lo_water == 0 is for the condition
! 1159: * when the context was pushed over hi_water but then had
! 1160: * isc_mem_setwater() called with 0 for hi_water and lo_water.
! 1161: */
! 1162: if (ctx->hi_called &&
! 1163: (ctx->inuse < ctx->lo_water || ctx->lo_water == 0U)) {
! 1164: if (ctx->water != NULL)
! 1165: call_water = ISC_TRUE;
! 1166: }
! 1167: MCTXUNLOCK(ctx, &ctx->lock);
! 1168:
! 1169: if (call_water)
! 1170: (ctx->water)(ctx->water_arg, ISC_MEM_LOWATER);
! 1171: }
! 1172:
! 1173: void
! 1174: isc_mem_waterack(isc_mem_t *ctx, int flag) {
! 1175: REQUIRE(VALID_CONTEXT(ctx));
! 1176:
! 1177: MCTXLOCK(ctx, &ctx->lock);
! 1178: if (flag == ISC_MEM_LOWATER)
! 1179: ctx->hi_called = ISC_FALSE;
! 1180: else if (flag == ISC_MEM_HIWATER)
! 1181: ctx->hi_called = ISC_TRUE;
! 1182: MCTXUNLOCK(ctx, &ctx->lock);
! 1183: }
! 1184:
! 1185: #if ISC_MEM_TRACKLINES
! 1186: static void
! 1187: print_active(isc_mem_t *mctx, FILE *out) {
! 1188: if (mctx->debuglist != NULL) {
! 1189: debuglink_t *dl;
! 1190: unsigned int i, j;
! 1191: const char *format;
! 1192: isc_boolean_t found;
! 1193:
! 1194: fprintf(out, "%s", isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1195: ISC_MSG_DUMPALLOC,
! 1196: "Dump of all outstanding "
! 1197: "memory allocations:\n"));
! 1198: found = ISC_FALSE;
! 1199: format = isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1200: ISC_MSG_PTRFILELINE,
! 1201: "\tptr %p size %u file %s line %u\n");
! 1202: for (i = 0; i <= mctx->max_size; i++) {
! 1203: dl = ISC_LIST_HEAD(mctx->debuglist[i]);
! 1204:
! 1205: if (dl != NULL)
! 1206: found = ISC_TRUE;
! 1207:
! 1208: while (dl != NULL) {
! 1209: for (j = 0; j < DEBUGLIST_COUNT; j++)
! 1210: if (dl->ptr[j] != NULL)
! 1211: fprintf(out, format,
! 1212: dl->ptr[j],
! 1213: dl->size[j],
! 1214: dl->file[j],
! 1215: dl->line[j]);
! 1216: dl = ISC_LIST_NEXT(dl, link);
! 1217: }
! 1218: }
! 1219: if (!found)
! 1220: fprintf(out, "%s", isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1221: ISC_MSG_NONE, "\tNone.\n"));
! 1222: }
! 1223: }
! 1224: #endif
! 1225:
! 1226: /*
! 1227: * Print the stats[] on the stream "out" with suitable formatting.
! 1228: */
! 1229: void
! 1230: isc_mem_stats(isc_mem_t *ctx, FILE *out) {
! 1231: size_t i;
! 1232: const struct stats *s;
! 1233: const isc_mempool_t *pool;
! 1234:
! 1235: REQUIRE(VALID_CONTEXT(ctx));
! 1236: MCTXLOCK(ctx, &ctx->lock);
! 1237:
! 1238: for (i = 0; i <= ctx->max_size; i++) {
! 1239: s = &ctx->stats[i];
! 1240:
! 1241: if (s->totalgets == 0U && s->gets == 0U)
! 1242: continue;
! 1243: fprintf(out, "%s%5lu: %11lu gets, %11lu rem",
! 1244: (i == ctx->max_size) ? ">=" : " ",
! 1245: (unsigned long) i, s->totalgets, s->gets);
! 1246: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0 &&
! 1247: (s->blocks != 0U || s->freefrags != 0U))
! 1248: fprintf(out, " (%lu bl, %lu ff)",
! 1249: s->blocks, s->freefrags);
! 1250: fputc('\n', out);
! 1251: }
! 1252:
! 1253: /*
! 1254: * Note that since a pool can be locked now, these stats might be
! 1255: * somewhat off if the pool is in active use at the time the stats
! 1256: * are dumped. The link fields are protected by the isc_mem_t's
! 1257: * lock, however, so walking this list and extracting integers from
! 1258: * stats fields is always safe.
! 1259: */
! 1260: pool = ISC_LIST_HEAD(ctx->pools);
! 1261: if (pool != NULL) {
! 1262: fprintf(out, "%s", isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1263: ISC_MSG_POOLSTATS,
! 1264: "[Pool statistics]\n"));
! 1265: fprintf(out, "%15s %10s %10s %10s %10s %10s %10s %10s %1s\n",
! 1266: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1267: ISC_MSG_POOLNAME, "name"),
! 1268: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1269: ISC_MSG_POOLSIZE, "size"),
! 1270: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1271: ISC_MSG_POOLMAXALLOC, "maxalloc"),
! 1272: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1273: ISC_MSG_POOLALLOCATED, "allocated"),
! 1274: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1275: ISC_MSG_POOLFREECOUNT, "freecount"),
! 1276: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1277: ISC_MSG_POOLFREEMAX, "freemax"),
! 1278: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1279: ISC_MSG_POOLFILLCOUNT, "fillcount"),
! 1280: isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
! 1281: ISC_MSG_POOLGETS, "gets"),
! 1282: "L");
! 1283: }
! 1284: while (pool != NULL) {
! 1285: fprintf(out, "%15s %10lu %10u %10u %10u %10u %10u %10u %s\n",
! 1286: pool->name, (unsigned long) pool->size, pool->maxalloc,
! 1287: pool->allocated, pool->freecount, pool->freemax,
! 1288: pool->fillcount, pool->gets,
! 1289: (pool->lock == NULL ? "N" : "Y"));
! 1290: pool = ISC_LIST_NEXT(pool, link);
! 1291: }
! 1292:
! 1293: #if ISC_MEM_TRACKLINES
! 1294: print_active(ctx, out);
! 1295: #endif
! 1296:
! 1297: MCTXUNLOCK(ctx, &ctx->lock);
! 1298: }
! 1299:
! 1300: /*
! 1301: * Replacements for malloc() and free() -- they implicitly remember the
! 1302: * size of the object allocated (with some additional overhead).
! 1303: */
! 1304:
! 1305: static void *
! 1306: isc__mem_allocateunlocked(isc_mem_t *ctx, size_t size) {
! 1307: size_info *si;
! 1308:
! 1309: size += ALIGNMENT_SIZE;
! 1310: if ((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0)
! 1311: size += ALIGNMENT_SIZE;
! 1312:
! 1313: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0)
! 1314: si = mem_getunlocked(ctx, size);
! 1315: else
! 1316: si = mem_get(ctx, size);
! 1317:
! 1318: if (si == NULL)
! 1319: return (NULL);
! 1320: if ((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0) {
! 1321: si->u.ctx = ctx;
! 1322: si++;
! 1323: }
! 1324: si->u.size = size;
! 1325: return (&si[1]);
! 1326: }
! 1327:
! 1328: void *
! 1329: isc__mem_allocate(isc_mem_t *ctx, size_t size FLARG) {
! 1330: size_info *si;
! 1331: isc_boolean_t call_water = ISC_FALSE;
! 1332:
! 1333: REQUIRE(VALID_CONTEXT(ctx));
! 1334:
! 1335: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1336: MCTXLOCK(ctx, &ctx->lock);
! 1337: si = isc__mem_allocateunlocked(ctx, size);
! 1338: } else {
! 1339: si = isc__mem_allocateunlocked(ctx, size);
! 1340: MCTXLOCK(ctx, &ctx->lock);
! 1341: if (si != NULL)
! 1342: mem_getstats(ctx, si[-1].u.size);
! 1343: }
! 1344:
! 1345: #if ISC_MEM_TRACKLINES
! 1346: ADD_TRACE(ctx, si, si[-1].u.size, file, line);
! 1347: #endif
! 1348: if (ctx->hi_water != 0U && !ctx->hi_called &&
! 1349: ctx->inuse > ctx->hi_water) {
! 1350: ctx->hi_called = ISC_TRUE;
! 1351: call_water = ISC_TRUE;
! 1352: }
! 1353: if (ctx->inuse > ctx->maxinuse) {
! 1354: ctx->maxinuse = ctx->inuse;
! 1355: if (ctx->hi_water != 0U && ctx->inuse > ctx->hi_water &&
! 1356: (isc_mem_debugging & ISC_MEM_DEBUGUSAGE) != 0)
! 1357: fprintf(stderr, "maxinuse = %lu\n",
! 1358: (unsigned long)ctx->inuse);
! 1359: }
! 1360: MCTXUNLOCK(ctx, &ctx->lock);
! 1361:
! 1362: if (call_water)
! 1363: (ctx->water)(ctx->water_arg, ISC_MEM_HIWATER);
! 1364:
! 1365: return (si);
! 1366: }
! 1367:
! 1368: void *
! 1369: isc__mem_reallocate(isc_mem_t *ctx, void *ptr, size_t size FLARG) {
! 1370: void *new_ptr = NULL;
! 1371: size_t oldsize, copysize;
! 1372:
! 1373: REQUIRE(VALID_CONTEXT(ctx));
! 1374:
! 1375: /*
! 1376: * This function emulates the realloc(3) standard library function:
! 1377: * - if size > 0, allocate new memory; and if ptr is non NULL, copy
! 1378: * as much of the old contents to the new buffer and free the old one.
! 1379: * Note that when allocation fails the original pointer is intact;
! 1380: * the caller must free it.
! 1381: * - if size is 0 and ptr is non NULL, simply free the given ptr.
! 1382: * - this function returns:
! 1383: * pointer to the newly allocated memory, or
! 1384: * NULL if allocation fails or doesn't happen.
! 1385: */
! 1386: if (size > 0U) {
! 1387: new_ptr = isc__mem_allocate(ctx, size FLARG_PASS);
! 1388: if (new_ptr != NULL && ptr != NULL) {
! 1389: oldsize = (((size_info *)ptr)[-1]).u.size;
! 1390: INSIST(oldsize >= ALIGNMENT_SIZE);
! 1391: oldsize -= ALIGNMENT_SIZE;
! 1392: copysize = oldsize > size ? size : oldsize;
! 1393: memcpy(new_ptr, ptr, copysize);
! 1394: isc__mem_free(ctx, ptr FLARG_PASS);
! 1395: }
! 1396: } else if (ptr != NULL)
! 1397: isc__mem_free(ctx, ptr FLARG_PASS);
! 1398:
! 1399: return (new_ptr);
! 1400: }
! 1401:
! 1402: void
! 1403: isc__mem_free(isc_mem_t *ctx, void *ptr FLARG) {
! 1404: size_info *si;
! 1405: size_t size;
! 1406: isc_boolean_t call_water= ISC_FALSE;
! 1407:
! 1408: REQUIRE(VALID_CONTEXT(ctx));
! 1409: REQUIRE(ptr != NULL);
! 1410:
! 1411: if ((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0) {
! 1412: si = &(((size_info *)ptr)[-2]);
! 1413: REQUIRE(si->u.ctx == ctx);
! 1414: size = si[1].u.size;
! 1415: } else {
! 1416: si = &(((size_info *)ptr)[-1]);
! 1417: size = si->u.size;
! 1418: }
! 1419:
! 1420: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1421: MCTXLOCK(ctx, &ctx->lock);
! 1422: mem_putunlocked(ctx, si, size);
! 1423: } else {
! 1424: mem_put(ctx, si, size);
! 1425: MCTXLOCK(ctx, &ctx->lock);
! 1426: mem_putstats(ctx, si, size);
! 1427: }
! 1428:
! 1429: DELETE_TRACE(ctx, ptr, size, file, line);
! 1430:
! 1431: /*
! 1432: * The check against ctx->lo_water == 0 is for the condition
! 1433: * when the context was pushed over hi_water but then had
! 1434: * isc_mem_setwater() called with 0 for hi_water and lo_water.
! 1435: */
! 1436: if (ctx->hi_called &&
! 1437: (ctx->inuse < ctx->lo_water || ctx->lo_water == 0U)) {
! 1438: ctx->hi_called = ISC_FALSE;
! 1439:
! 1440: if (ctx->water != NULL)
! 1441: call_water = ISC_TRUE;
! 1442: }
! 1443: MCTXUNLOCK(ctx, &ctx->lock);
! 1444:
! 1445: if (call_water)
! 1446: (ctx->water)(ctx->water_arg, ISC_MEM_LOWATER);
! 1447: }
! 1448:
! 1449:
! 1450: /*
! 1451: * Other useful things.
! 1452: */
! 1453:
! 1454: char *
! 1455: isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) {
! 1456: size_t len;
! 1457: char *ns;
! 1458:
! 1459: REQUIRE(VALID_CONTEXT(mctx));
! 1460: REQUIRE(s != NULL);
! 1461:
! 1462: len = strlen(s);
! 1463:
! 1464: ns = isc__mem_allocate(mctx, len + 1 FLARG_PASS);
! 1465:
! 1466: if (ns != NULL)
! 1467: strncpy(ns, s, len + 1);
! 1468:
! 1469: return (ns);
! 1470: }
! 1471:
! 1472: void
! 1473: isc_mem_setdestroycheck(isc_mem_t *ctx, isc_boolean_t flag) {
! 1474: REQUIRE(VALID_CONTEXT(ctx));
! 1475: MCTXLOCK(ctx, &ctx->lock);
! 1476:
! 1477: ctx->checkfree = flag;
! 1478:
! 1479: MCTXUNLOCK(ctx, &ctx->lock);
! 1480: }
! 1481:
! 1482: /*
! 1483: * Quotas
! 1484: */
! 1485:
! 1486: void
! 1487: isc_mem_setquota(isc_mem_t *ctx, size_t quota) {
! 1488: REQUIRE(VALID_CONTEXT(ctx));
! 1489: MCTXLOCK(ctx, &ctx->lock);
! 1490:
! 1491: ctx->quota = quota;
! 1492:
! 1493: MCTXUNLOCK(ctx, &ctx->lock);
! 1494: }
! 1495:
! 1496: size_t
! 1497: isc_mem_getquota(isc_mem_t *ctx) {
! 1498: size_t quota;
! 1499:
! 1500: REQUIRE(VALID_CONTEXT(ctx));
! 1501: MCTXLOCK(ctx, &ctx->lock);
! 1502:
! 1503: quota = ctx->quota;
! 1504:
! 1505: MCTXUNLOCK(ctx, &ctx->lock);
! 1506:
! 1507: return (quota);
! 1508: }
! 1509:
! 1510: size_t
! 1511: isc_mem_inuse(isc_mem_t *ctx) {
! 1512: size_t inuse;
! 1513:
! 1514: REQUIRE(VALID_CONTEXT(ctx));
! 1515: MCTXLOCK(ctx, &ctx->lock);
! 1516:
! 1517: inuse = ctx->inuse;
! 1518:
! 1519: MCTXUNLOCK(ctx, &ctx->lock);
! 1520:
! 1521: return (inuse);
! 1522: }
! 1523:
! 1524: void
! 1525: isc_mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
! 1526: size_t hiwater, size_t lowater)
! 1527: {
! 1528: isc_boolean_t callwater = ISC_FALSE;
! 1529: isc_mem_water_t oldwater;
! 1530: void *oldwater_arg;
! 1531:
! 1532: REQUIRE(VALID_CONTEXT(ctx));
! 1533: REQUIRE(hiwater >= lowater);
! 1534:
! 1535: MCTXLOCK(ctx, &ctx->lock);
! 1536: oldwater = ctx->water;
! 1537: oldwater_arg = ctx->water_arg;
! 1538: if (water == NULL) {
! 1539: callwater = ctx->hi_called;
! 1540: ctx->water = NULL;
! 1541: ctx->water_arg = NULL;
! 1542: ctx->hi_water = 0;
! 1543: ctx->lo_water = 0;
! 1544: ctx->hi_called = ISC_FALSE;
! 1545: } else {
! 1546: if (ctx->hi_called &&
! 1547: (ctx->water != water || ctx->water_arg != water_arg ||
! 1548: ctx->inuse < lowater || lowater == 0U))
! 1549: callwater = ISC_TRUE;
! 1550: ctx->water = water;
! 1551: ctx->water_arg = water_arg;
! 1552: ctx->hi_water = hiwater;
! 1553: ctx->lo_water = lowater;
! 1554: ctx->hi_called = ISC_FALSE;
! 1555: }
! 1556: MCTXUNLOCK(ctx, &ctx->lock);
! 1557:
! 1558: if (callwater && oldwater != NULL)
! 1559: (oldwater)(oldwater_arg, ISC_MEM_LOWATER);
! 1560: }
! 1561:
! 1562: void
! 1563: isc_mem_setname(isc_mem_t *ctx, const char *name, void *tag) {
! 1564: REQUIRE(VALID_CONTEXT(ctx));
! 1565:
! 1566: LOCK(&ctx->lock);
! 1567: memset(ctx->name, 0, sizeof(ctx->name));
! 1568: strncpy(ctx->name, name, sizeof(ctx->name) - 1);
! 1569: ctx->tag = tag;
! 1570: UNLOCK(&ctx->lock);
! 1571: }
! 1572:
! 1573: const char *
! 1574: isc_mem_getname(isc_mem_t *ctx) {
! 1575: REQUIRE(VALID_CONTEXT(ctx));
! 1576:
! 1577: return (ctx->name);
! 1578: }
! 1579:
! 1580: void *
! 1581: isc_mem_gettag(isc_mem_t *ctx) {
! 1582: REQUIRE(VALID_CONTEXT(ctx));
! 1583:
! 1584: return (ctx->tag);
! 1585: }
! 1586:
! 1587: /*
! 1588: * Memory pool stuff
! 1589: */
! 1590:
! 1591: isc_result_t
! 1592: isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) {
! 1593: isc_mempool_t *mpctx;
! 1594:
! 1595: REQUIRE(VALID_CONTEXT(mctx));
! 1596: REQUIRE(size > 0U);
! 1597: REQUIRE(mpctxp != NULL && *mpctxp == NULL);
! 1598:
! 1599: /*
! 1600: * Allocate space for this pool, initialize values, and if all works
! 1601: * well, attach to the memory context.
! 1602: */
! 1603: mpctx = isc_mem_get(mctx, sizeof(isc_mempool_t));
! 1604: if (mpctx == NULL)
! 1605: return (ISC_R_NOMEMORY);
! 1606:
! 1607: mpctx->magic = MEMPOOL_MAGIC;
! 1608: mpctx->lock = NULL;
! 1609: mpctx->mctx = mctx;
! 1610: mpctx->size = size;
! 1611: mpctx->maxalloc = UINT_MAX;
! 1612: mpctx->allocated = 0;
! 1613: mpctx->freecount = 0;
! 1614: mpctx->freemax = 1;
! 1615: mpctx->fillcount = 1;
! 1616: mpctx->gets = 0;
! 1617: #if ISC_MEMPOOL_NAMES
! 1618: mpctx->name[0] = 0;
! 1619: #endif
! 1620: mpctx->items = NULL;
! 1621:
! 1622: *mpctxp = mpctx;
! 1623:
! 1624: MCTXLOCK(mctx, &mctx->lock);
! 1625: ISC_LIST_INITANDAPPEND(mctx->pools, mpctx, link);
! 1626: mctx->poolcnt++;
! 1627: MCTXUNLOCK(mctx, &mctx->lock);
! 1628:
! 1629: return (ISC_R_SUCCESS);
! 1630: }
! 1631:
! 1632: void
! 1633: isc_mempool_setname(isc_mempool_t *mpctx, const char *name) {
! 1634: REQUIRE(name != NULL);
! 1635:
! 1636: #if ISC_MEMPOOL_NAMES
! 1637: if (mpctx->lock != NULL)
! 1638: LOCK(mpctx->lock);
! 1639:
! 1640: strncpy(mpctx->name, name, sizeof(mpctx->name) - 1);
! 1641: mpctx->name[sizeof(mpctx->name) - 1] = '\0';
! 1642:
! 1643: if (mpctx->lock != NULL)
! 1644: UNLOCK(mpctx->lock);
! 1645: #else
! 1646: UNUSED(mpctx);
! 1647: UNUSED(name);
! 1648: #endif
! 1649: }
! 1650:
! 1651: void
! 1652: isc_mempool_destroy(isc_mempool_t **mpctxp) {
! 1653: isc_mempool_t *mpctx;
! 1654: isc_mem_t *mctx;
! 1655: isc_mutex_t *lock;
! 1656: element *item;
! 1657:
! 1658: REQUIRE(mpctxp != NULL);
! 1659: mpctx = *mpctxp;
! 1660: REQUIRE(VALID_MEMPOOL(mpctx));
! 1661: #if ISC_MEMPOOL_NAMES
! 1662: if (mpctx->allocated > 0)
! 1663: UNEXPECTED_ERROR(__FILE__, __LINE__,
! 1664: "isc_mempool_destroy(): mempool %s "
! 1665: "leaked memory",
! 1666: mpctx->name);
! 1667: #endif
! 1668: REQUIRE(mpctx->allocated == 0);
! 1669:
! 1670: mctx = mpctx->mctx;
! 1671:
! 1672: lock = mpctx->lock;
! 1673:
! 1674: if (lock != NULL)
! 1675: LOCK(lock);
! 1676:
! 1677: /*
! 1678: * Return any items on the free list
! 1679: */
! 1680: MCTXLOCK(mctx, &mctx->lock);
! 1681: while (mpctx->items != NULL) {
! 1682: INSIST(mpctx->freecount > 0);
! 1683: mpctx->freecount--;
! 1684: item = mpctx->items;
! 1685: mpctx->items = item->next;
! 1686:
! 1687: if ((mctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1688: mem_putunlocked(mctx, item, mpctx->size);
! 1689: } else {
! 1690: mem_put(mctx, item, mpctx->size);
! 1691: mem_putstats(mctx, item, mpctx->size);
! 1692: }
! 1693: }
! 1694: MCTXUNLOCK(mctx, &mctx->lock);
! 1695:
! 1696: /*
! 1697: * Remove our linked list entry from the memory context.
! 1698: */
! 1699: MCTXLOCK(mctx, &mctx->lock);
! 1700: ISC_LIST_UNLINK(mctx->pools, mpctx, link);
! 1701: mctx->poolcnt--;
! 1702: MCTXUNLOCK(mctx, &mctx->lock);
! 1703:
! 1704: mpctx->magic = 0;
! 1705:
! 1706: isc_mem_put(mpctx->mctx, mpctx, sizeof(isc_mempool_t));
! 1707:
! 1708: if (lock != NULL)
! 1709: UNLOCK(lock);
! 1710:
! 1711: *mpctxp = NULL;
! 1712: }
! 1713:
! 1714: void
! 1715: isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock) {
! 1716: REQUIRE(VALID_MEMPOOL(mpctx));
! 1717: REQUIRE(mpctx->lock == NULL);
! 1718: REQUIRE(lock != NULL);
! 1719:
! 1720: mpctx->lock = lock;
! 1721: }
! 1722:
! 1723: void *
! 1724: isc__mempool_get(isc_mempool_t *mpctx FLARG) {
! 1725: element *item;
! 1726: isc_mem_t *mctx;
! 1727: unsigned int i;
! 1728:
! 1729: REQUIRE(VALID_MEMPOOL(mpctx));
! 1730:
! 1731: mctx = mpctx->mctx;
! 1732:
! 1733: if (mpctx->lock != NULL)
! 1734: LOCK(mpctx->lock);
! 1735:
! 1736: /*
! 1737: * Don't let the caller go over quota
! 1738: */
! 1739: if (mpctx->allocated >= mpctx->maxalloc) {
! 1740: item = NULL;
! 1741: goto out;
! 1742: }
! 1743:
! 1744: /*
! 1745: * if we have a free list item, return the first here
! 1746: */
! 1747: item = mpctx->items;
! 1748: if (item != NULL) {
! 1749: mpctx->items = item->next;
! 1750: INSIST(mpctx->freecount > 0);
! 1751: mpctx->freecount--;
! 1752: mpctx->gets++;
! 1753: mpctx->allocated++;
! 1754: goto out;
! 1755: }
! 1756:
! 1757: /*
! 1758: * We need to dip into the well. Lock the memory context here and
! 1759: * fill up our free list.
! 1760: */
! 1761: MCTXLOCK(mctx, &mctx->lock);
! 1762: for (i = 0; i < mpctx->fillcount; i++) {
! 1763: if ((mctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1764: item = mem_getunlocked(mctx, mpctx->size);
! 1765: } else {
! 1766: item = mem_get(mctx, mpctx->size);
! 1767: if (item != NULL)
! 1768: mem_getstats(mctx, mpctx->size);
! 1769: }
! 1770: if (item == NULL)
! 1771: break;
! 1772: item->next = mpctx->items;
! 1773: mpctx->items = item;
! 1774: mpctx->freecount++;
! 1775: }
! 1776: MCTXUNLOCK(mctx, &mctx->lock);
! 1777:
! 1778: /*
! 1779: * If we didn't get any items, return NULL.
! 1780: */
! 1781: item = mpctx->items;
! 1782: if (item == NULL)
! 1783: goto out;
! 1784:
! 1785: mpctx->items = item->next;
! 1786: mpctx->freecount--;
! 1787: mpctx->gets++;
! 1788: mpctx->allocated++;
! 1789:
! 1790: out:
! 1791: if (mpctx->lock != NULL)
! 1792: UNLOCK(mpctx->lock);
! 1793:
! 1794: #if ISC_MEM_TRACKLINES
! 1795: if (item != NULL) {
! 1796: MCTXLOCK(mctx, &mctx->lock);
! 1797: ADD_TRACE(mctx, item, mpctx->size, file, line);
! 1798: MCTXUNLOCK(mctx, &mctx->lock);
! 1799: }
! 1800: #endif /* ISC_MEM_TRACKLINES */
! 1801:
! 1802: return (item);
! 1803: }
! 1804:
! 1805: void
! 1806: isc__mempool_put(isc_mempool_t *mpctx, void *mem FLARG) {
! 1807: isc_mem_t *mctx;
! 1808: element *item;
! 1809:
! 1810: REQUIRE(VALID_MEMPOOL(mpctx));
! 1811: REQUIRE(mem != NULL);
! 1812:
! 1813: mctx = mpctx->mctx;
! 1814:
! 1815: if (mpctx->lock != NULL)
! 1816: LOCK(mpctx->lock);
! 1817:
! 1818: INSIST(mpctx->allocated > 0);
! 1819: mpctx->allocated--;
! 1820:
! 1821: #if ISC_MEM_TRACKLINES
! 1822: MCTXLOCK(mctx, &mctx->lock);
! 1823: DELETE_TRACE(mctx, mem, mpctx->size, file, line);
! 1824: MCTXUNLOCK(mctx, &mctx->lock);
! 1825: #endif /* ISC_MEM_TRACKLINES */
! 1826:
! 1827: /*
! 1828: * If our free list is full, return this to the mctx directly.
! 1829: */
! 1830: if (mpctx->freecount >= mpctx->freemax) {
! 1831: if ((mctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 1832: MCTXLOCK(mctx, &mctx->lock);
! 1833: mem_putunlocked(mctx, mem, mpctx->size);
! 1834: MCTXUNLOCK(mctx, &mctx->lock);
! 1835: } else {
! 1836: mem_put(mctx, mem, mpctx->size);
! 1837: MCTXLOCK(mctx, &mctx->lock);
! 1838: mem_putstats(mctx, mem, mpctx->size);
! 1839: MCTXUNLOCK(mctx, &mctx->lock);
! 1840: }
! 1841: if (mpctx->lock != NULL)
! 1842: UNLOCK(mpctx->lock);
! 1843: return;
! 1844: }
! 1845:
! 1846: /*
! 1847: * Otherwise, attach it to our free list and bump the counter.
! 1848: */
! 1849: mpctx->freecount++;
! 1850: item = (element *)mem;
! 1851: item->next = mpctx->items;
! 1852: mpctx->items = item;
! 1853:
! 1854: if (mpctx->lock != NULL)
! 1855: UNLOCK(mpctx->lock);
! 1856: }
! 1857:
! 1858: /*
! 1859: * Quotas
! 1860: */
! 1861:
! 1862: void
! 1863: isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit) {
! 1864: REQUIRE(VALID_MEMPOOL(mpctx));
! 1865:
! 1866: if (mpctx->lock != NULL)
! 1867: LOCK(mpctx->lock);
! 1868:
! 1869: mpctx->freemax = limit;
! 1870:
! 1871: if (mpctx->lock != NULL)
! 1872: UNLOCK(mpctx->lock);
! 1873: }
! 1874:
! 1875: unsigned int
! 1876: isc_mempool_getfreemax(isc_mempool_t *mpctx) {
! 1877: unsigned int freemax;
! 1878:
! 1879: REQUIRE(VALID_MEMPOOL(mpctx));
! 1880:
! 1881: if (mpctx->lock != NULL)
! 1882: LOCK(mpctx->lock);
! 1883:
! 1884: freemax = mpctx->freemax;
! 1885:
! 1886: if (mpctx->lock != NULL)
! 1887: UNLOCK(mpctx->lock);
! 1888:
! 1889: return (freemax);
! 1890: }
! 1891:
! 1892: unsigned int
! 1893: isc_mempool_getfreecount(isc_mempool_t *mpctx) {
! 1894: unsigned int freecount;
! 1895:
! 1896: REQUIRE(VALID_MEMPOOL(mpctx));
! 1897:
! 1898: if (mpctx->lock != NULL)
! 1899: LOCK(mpctx->lock);
! 1900:
! 1901: freecount = mpctx->freecount;
! 1902:
! 1903: if (mpctx->lock != NULL)
! 1904: UNLOCK(mpctx->lock);
! 1905:
! 1906: return (freecount);
! 1907: }
! 1908:
! 1909: void
! 1910: isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit) {
! 1911: REQUIRE(limit > 0);
! 1912:
! 1913: REQUIRE(VALID_MEMPOOL(mpctx));
! 1914:
! 1915: if (mpctx->lock != NULL)
! 1916: LOCK(mpctx->lock);
! 1917:
! 1918: mpctx->maxalloc = limit;
! 1919:
! 1920: if (mpctx->lock != NULL)
! 1921: UNLOCK(mpctx->lock);
! 1922: }
! 1923:
! 1924: unsigned int
! 1925: isc_mempool_getmaxalloc(isc_mempool_t *mpctx) {
! 1926: unsigned int maxalloc;
! 1927:
! 1928: REQUIRE(VALID_MEMPOOL(mpctx));
! 1929:
! 1930: if (mpctx->lock != NULL)
! 1931: LOCK(mpctx->lock);
! 1932:
! 1933: maxalloc = mpctx->maxalloc;
! 1934:
! 1935: if (mpctx->lock != NULL)
! 1936: UNLOCK(mpctx->lock);
! 1937:
! 1938: return (maxalloc);
! 1939: }
! 1940:
! 1941: unsigned int
! 1942: isc_mempool_getallocated(isc_mempool_t *mpctx) {
! 1943: unsigned int allocated;
! 1944:
! 1945: REQUIRE(VALID_MEMPOOL(mpctx));
! 1946:
! 1947: if (mpctx->lock != NULL)
! 1948: LOCK(mpctx->lock);
! 1949:
! 1950: allocated = mpctx->allocated;
! 1951:
! 1952: if (mpctx->lock != NULL)
! 1953: UNLOCK(mpctx->lock);
! 1954:
! 1955: return (allocated);
! 1956: }
! 1957:
! 1958: void
! 1959: isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit) {
! 1960: REQUIRE(limit > 0);
! 1961: REQUIRE(VALID_MEMPOOL(mpctx));
! 1962:
! 1963: if (mpctx->lock != NULL)
! 1964: LOCK(mpctx->lock);
! 1965:
! 1966: mpctx->fillcount = limit;
! 1967:
! 1968: if (mpctx->lock != NULL)
! 1969: UNLOCK(mpctx->lock);
! 1970: }
! 1971:
! 1972: unsigned int
! 1973: isc_mempool_getfillcount(isc_mempool_t *mpctx) {
! 1974: unsigned int fillcount;
! 1975:
! 1976: REQUIRE(VALID_MEMPOOL(mpctx));
! 1977:
! 1978: if (mpctx->lock != NULL)
! 1979: LOCK(mpctx->lock);
! 1980:
! 1981: fillcount = mpctx->fillcount;
! 1982:
! 1983: if (mpctx->lock != NULL)
! 1984: UNLOCK(mpctx->lock);
! 1985:
! 1986: return (fillcount);
! 1987: }
! 1988:
! 1989: void
! 1990: isc_mem_printactive(isc_mem_t *ctx, FILE *file) {
! 1991:
! 1992: REQUIRE(VALID_CONTEXT(ctx));
! 1993: REQUIRE(file != NULL);
! 1994:
! 1995: #if !ISC_MEM_TRACKLINES
! 1996: UNUSED(ctx);
! 1997: UNUSED(file);
! 1998: #else
! 1999: print_active(ctx, file);
! 2000: #endif
! 2001: }
! 2002:
! 2003: void
! 2004: isc_mem_printallactive(FILE *file) {
! 2005: #if !ISC_MEM_TRACKLINES
! 2006: UNUSED(file);
! 2007: #else
! 2008: isc_mem_t *ctx;
! 2009:
! 2010: RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
! 2011:
! 2012: LOCK(&lock);
! 2013: for (ctx = ISC_LIST_HEAD(contexts);
! 2014: ctx != NULL;
! 2015: ctx = ISC_LIST_NEXT(ctx, link)) {
! 2016: fprintf(file, "context: %p\n", ctx);
! 2017: print_active(ctx, file);
! 2018: }
! 2019: UNLOCK(&lock);
! 2020: #endif
! 2021: }
! 2022:
! 2023: void
! 2024: isc_mem_checkdestroyed(FILE *file) {
! 2025:
! 2026: RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
! 2027:
! 2028: LOCK(&lock);
! 2029: if (!ISC_LIST_EMPTY(contexts)) {
! 2030: #if ISC_MEM_TRACKLINES
! 2031: isc_mem_t *ctx;
! 2032:
! 2033: for (ctx = ISC_LIST_HEAD(contexts);
! 2034: ctx != NULL;
! 2035: ctx = ISC_LIST_NEXT(ctx, link)) {
! 2036: fprintf(file, "context: %p\n", ctx);
! 2037: print_active(ctx, file);
! 2038: }
! 2039: fflush(file);
! 2040: #endif
! 2041: INSIST(0);
! 2042: }
! 2043: UNLOCK(&lock);
! 2044: }
! 2045:
! 2046: unsigned int
! 2047: isc_mem_references(isc_mem_t *ctx) {
! 2048: unsigned int references;
! 2049: REQUIRE(VALID_CONTEXT(ctx));
! 2050:
! 2051: MCTXLOCK(ctx, &ctx->lock);
! 2052: references = ctx->references;
! 2053: MCTXUNLOCK(ctx, &ctx->lock);
! 2054:
! 2055: return (references);
! 2056: }
! 2057:
! 2058: #ifdef HAVE_LIBXML2
! 2059:
! 2060: typedef struct summarystat {
! 2061: isc_uint64_t total;
! 2062: isc_uint64_t inuse;
! 2063: isc_uint64_t blocksize;
! 2064: isc_uint64_t contextsize;
! 2065: } summarystat_t;
! 2066:
! 2067: static void
! 2068: renderctx(isc_mem_t *ctx, summarystat_t *summary, xmlTextWriterPtr writer) {
! 2069: REQUIRE(VALID_CONTEXT(ctx));
! 2070:
! 2071: xmlTextWriterStartElement(writer, ISC_XMLCHAR "context");
! 2072:
! 2073: xmlTextWriterStartElement(writer, ISC_XMLCHAR "id");
! 2074: xmlTextWriterWriteFormatString(writer, "%p", ctx);
! 2075: xmlTextWriterEndElement(writer); /* id */
! 2076:
! 2077: if (ctx->name[0] != 0) {
! 2078: xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
! 2079: xmlTextWriterWriteFormatString(writer, "%s", ctx->name);
! 2080: xmlTextWriterEndElement(writer); /* name */
! 2081: }
! 2082:
! 2083: REQUIRE(VALID_CONTEXT(ctx));
! 2084: MCTXLOCK(ctx, &ctx->lock);
! 2085:
! 2086: summary->contextsize += sizeof(*ctx) +
! 2087: (ctx->max_size + 1) * sizeof(struct stats) +
! 2088: ctx->max_size * sizeof(element *) +
! 2089: ctx->basic_table_count * sizeof(char *);
! 2090: #if ISC_MEM_TRACKLINES
! 2091: if (ctx->debuglist != NULL) {
! 2092: summary->contextsize +=
! 2093: (ctx->max_size + 1) * sizeof(debuglist_t) +
! 2094: ctx->debuglistcnt * sizeof(debuglink_t);
! 2095: }
! 2096: #endif
! 2097: xmlTextWriterStartElement(writer, ISC_XMLCHAR "references");
! 2098: xmlTextWriterWriteFormatString(writer, "%d", ctx->references);
! 2099: xmlTextWriterEndElement(writer); /* references */
! 2100:
! 2101: summary->total += ctx->total;
! 2102: xmlTextWriterStartElement(writer, ISC_XMLCHAR "total");
! 2103: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2104: (isc_uint64_t)ctx->total);
! 2105: xmlTextWriterEndElement(writer); /* total */
! 2106:
! 2107: summary->inuse += ctx->inuse;
! 2108: xmlTextWriterStartElement(writer, ISC_XMLCHAR "inuse");
! 2109: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2110: (isc_uint64_t)ctx->inuse);
! 2111: xmlTextWriterEndElement(writer); /* inuse */
! 2112:
! 2113: xmlTextWriterStartElement(writer, ISC_XMLCHAR "maxinuse");
! 2114: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2115: (isc_uint64_t)ctx->maxinuse);
! 2116: xmlTextWriterEndElement(writer); /* maxinuse */
! 2117:
! 2118: xmlTextWriterStartElement(writer, ISC_XMLCHAR "blocksize");
! 2119: if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
! 2120: summary->blocksize += ctx->basic_table_count *
! 2121: NUM_BASIC_BLOCKS * ctx->mem_target;
! 2122: xmlTextWriterWriteFormatString(writer,
! 2123: "%" ISC_PRINT_QUADFORMAT "u",
! 2124: (isc_uint64_t)
! 2125: ctx->basic_table_count *
! 2126: NUM_BASIC_BLOCKS *
! 2127: ctx->mem_target);
! 2128: } else
! 2129: xmlTextWriterWriteFormatString(writer, "%s", "-");
! 2130: xmlTextWriterEndElement(writer); /* blocksize */
! 2131:
! 2132: xmlTextWriterStartElement(writer, ISC_XMLCHAR "pools");
! 2133: xmlTextWriterWriteFormatString(writer, "%u", ctx->poolcnt);
! 2134: xmlTextWriterEndElement(writer); /* pools */
! 2135: summary->contextsize += ctx->poolcnt * sizeof(isc_mempool_t);
! 2136:
! 2137: xmlTextWriterStartElement(writer, ISC_XMLCHAR "hiwater");
! 2138: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2139: (isc_uint64_t)ctx->hi_water);
! 2140: xmlTextWriterEndElement(writer); /* hiwater */
! 2141:
! 2142: xmlTextWriterStartElement(writer, ISC_XMLCHAR "lowater");
! 2143: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2144: (isc_uint64_t)ctx->lo_water);
! 2145: xmlTextWriterEndElement(writer); /* lowater */
! 2146:
! 2147: MCTXUNLOCK(ctx, &ctx->lock);
! 2148:
! 2149: xmlTextWriterEndElement(writer); /* context */
! 2150: }
! 2151:
! 2152: void
! 2153: isc_mem_renderxml(xmlTextWriterPtr writer) {
! 2154: isc_mem_t *ctx;
! 2155: summarystat_t summary;
! 2156: isc_uint64_t lost;
! 2157:
! 2158: memset(&summary, 0, sizeof(summary));
! 2159:
! 2160: xmlTextWriterStartElement(writer, ISC_XMLCHAR "contexts");
! 2161:
! 2162: RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
! 2163:
! 2164: LOCK(&lock);
! 2165: lost = totallost;
! 2166: for (ctx = ISC_LIST_HEAD(contexts);
! 2167: ctx != NULL;
! 2168: ctx = ISC_LIST_NEXT(ctx, link)) {
! 2169: renderctx(ctx, &summary, writer);
! 2170: }
! 2171: UNLOCK(&lock);
! 2172:
! 2173: xmlTextWriterEndElement(writer); /* contexts */
! 2174:
! 2175: xmlTextWriterStartElement(writer, ISC_XMLCHAR "summary");
! 2176:
! 2177: xmlTextWriterStartElement(writer, ISC_XMLCHAR "TotalUse");
! 2178: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2179: summary.total);
! 2180: xmlTextWriterEndElement(writer); /* TotalUse */
! 2181:
! 2182: xmlTextWriterStartElement(writer, ISC_XMLCHAR "InUse");
! 2183: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2184: summary.inuse);
! 2185: xmlTextWriterEndElement(writer); /* InUse */
! 2186:
! 2187: xmlTextWriterStartElement(writer, ISC_XMLCHAR "BlockSize");
! 2188: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2189: summary.blocksize);
! 2190: xmlTextWriterEndElement(writer); /* BlockSize */
! 2191:
! 2192: xmlTextWriterStartElement(writer, ISC_XMLCHAR "ContextSize");
! 2193: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2194: summary.contextsize);
! 2195: xmlTextWriterEndElement(writer); /* ContextSize */
! 2196:
! 2197: xmlTextWriterStartElement(writer, ISC_XMLCHAR "Lost");
! 2198: xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
! 2199: lost);
! 2200: xmlTextWriterEndElement(writer); /* Lost */
! 2201:
! 2202: xmlTextWriterEndElement(writer); /* summary */
! 2203: }
! 2204:
! 2205: #endif /* HAVE_LIBXML2 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mem.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc