?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BIND - Update BIND to 9.5.2
[dragonfly.git] / contrib / bind-9.5.2 / lib / isc / mem.c
blob5bcd56172762947e3e4e78c4f75ede6620a74527
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.137.16.8 2009/02/16 03:17:29 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 #ifdef HAVE_LIBXML2
2047
2048 typedef struct summarystat {
2049 isc_uint64_t total;
2050 isc_uint64_t inuse;
2051 isc_uint64_t blocksize;
2052 isc_uint64_t contextsize;
2053 } summarystat_t;
2054
2055 static void
2056 renderctx(isc_mem_t *ctx, summarystat_t *summary, xmlTextWriterPtr writer) {
2057 REQUIRE(VALID_CONTEXT(ctx));
2058
2059 xmlTextWriterStartElement(writer, ISC_XMLCHAR "context");
2060
2061 xmlTextWriterStartElement(writer, ISC_XMLCHAR "id");
2062 xmlTextWriterWriteFormatString(writer, "%p", ctx);
2063 xmlTextWriterEndElement(writer); /* id */
2064
2065 if (ctx->name[0] != 0) {
2066 xmlTextWriterStartElement(writer, ISC_XMLCHAR "name");
2067 xmlTextWriterWriteFormatString(writer, "%s", ctx->name);
2068 xmlTextWriterEndElement(writer); /* name */
2069 }
2070
2071 REQUIRE(VALID_CONTEXT(ctx));
2072 MCTXLOCK(ctx, &ctx->lock);
2073
2074 summary->contextsize += sizeof(*ctx) +
2075 (ctx->max_size + 1) * sizeof(struct stats) +
2076 ctx->max_size * sizeof(element *) +
2077 ctx->basic_table_count * sizeof(char *);
2078 #if ISC_MEM_TRACKLINES
2079 if (ctx->debuglist != NULL) {
2080 summary->contextsize +=
2081 (ctx->max_size + 1) * sizeof(debuglist_t) +
2082 ctx->debuglistcnt * sizeof(debuglink_t);
2083 }
2084 #endif
2085 xmlTextWriterStartElement(writer, ISC_XMLCHAR "references");
2086 xmlTextWriterWriteFormatString(writer, "%d", ctx->references);
2087 xmlTextWriterEndElement(writer); /* references */
2088
2089 summary->total += ctx->total;
2090 xmlTextWriterStartElement(writer, ISC_XMLCHAR "total");
2091 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2092 (isc_uint64_t)ctx->total);
2093 xmlTextWriterEndElement(writer); /* total */
2094
2095 summary->inuse += ctx->inuse;
2096 xmlTextWriterStartElement(writer, ISC_XMLCHAR "inuse");
2097 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2098 (isc_uint64_t)ctx->inuse);
2099 xmlTextWriterEndElement(writer); /* inuse */
2100
2101 xmlTextWriterStartElement(writer, ISC_XMLCHAR "maxinuse");
2102 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2103 (isc_uint64_t)ctx->maxinuse);
2104 xmlTextWriterEndElement(writer); /* maxinuse */
2105
2106 xmlTextWriterStartElement(writer, ISC_XMLCHAR "blocksize");
2107 if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
2108 summary->blocksize += ctx->basic_table_count *
2109 NUM_BASIC_BLOCKS * ctx->mem_target;
2110 xmlTextWriterWriteFormatString(writer,
2111 "%" ISC_PRINT_QUADFORMAT "u",
2112 (isc_uint64_t)
2113 ctx->basic_table_count *
2114 NUM_BASIC_BLOCKS *
2115 ctx->mem_target);
2116 } else
2117 xmlTextWriterWriteFormatString(writer, "%s", "-");
2118 xmlTextWriterEndElement(writer); /* blocksize */
2119
2120 xmlTextWriterStartElement(writer, ISC_XMLCHAR "pools");
2121 xmlTextWriterWriteFormatString(writer, "%u", ctx->poolcnt);
2122 xmlTextWriterEndElement(writer); /* pools */
2123 summary->contextsize += ctx->poolcnt * sizeof(isc_mempool_t);
2124
2125 xmlTextWriterStartElement(writer, ISC_XMLCHAR "hiwater");
2126 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2127 (isc_uint64_t)ctx->hi_water);
2128 xmlTextWriterEndElement(writer); /* hiwater */
2129
2130 xmlTextWriterStartElement(writer, ISC_XMLCHAR "lowater");
2131 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2132 (isc_uint64_t)ctx->lo_water);
2133 xmlTextWriterEndElement(writer); /* lowater */
2134
2135 MCTXUNLOCK(ctx, &ctx->lock);
2136
2137 xmlTextWriterEndElement(writer); /* context */
2138 }
2139
2140 void
2141 isc_mem_renderxml(xmlTextWriterPtr writer) {
2142 isc_mem_t *ctx;
2143 summarystat_t summary;
2144 isc_uint64_t lost;
2145
2146 memset(&summary, 0, sizeof(summary));
2147
2148 xmlTextWriterStartElement(writer, ISC_XMLCHAR "contexts");
2149
2150 RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
2151
2152 LOCK(&lock);
2153 lost = totallost;
2154 for (ctx = ISC_LIST_HEAD(contexts);
2155 ctx != NULL;
2156 ctx = ISC_LIST_NEXT(ctx, link)) {
2157 renderctx(ctx, &summary, writer);
2158 }
2159 UNLOCK(&lock);
2160
2161 xmlTextWriterEndElement(writer); /* contexts */
2162
2163 xmlTextWriterStartElement(writer, ISC_XMLCHAR "summary");
2164
2165 xmlTextWriterStartElement(writer, ISC_XMLCHAR "TotalUse");
2166 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2167 summary.total);
2168 xmlTextWriterEndElement(writer); /* TotalUse */
2169
2170 xmlTextWriterStartElement(writer, ISC_XMLCHAR "InUse");
2171 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2172 summary.inuse);
2173 xmlTextWriterEndElement(writer); /* InUse */
2174
2175 xmlTextWriterStartElement(writer, ISC_XMLCHAR "BlockSize");
2176 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2177 summary.blocksize);
2178 xmlTextWriterEndElement(writer); /* BlockSize */
2179
2180 xmlTextWriterStartElement(writer, ISC_XMLCHAR "ContextSize");
2181 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2182 summary.contextsize);
2183 xmlTextWriterEndElement(writer); /* ContextSize */
2184
2185 xmlTextWriterStartElement(writer, ISC_XMLCHAR "Lost");
2186 xmlTextWriterWriteFormatString(writer, "%" ISC_PRINT_QUADFORMAT "u",
2187 lost);
2188 xmlTextWriterEndElement(writer); /* Lost */
2189
2190 xmlTextWriterEndElement(writer); /* summary */
2191 }
2192
2193 #endif /* HAVE_LIBXML2 */
DragonFly BSD