2 * Copyright (C) 2004-2012 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1997-2001 Internet Software Consortium.
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.
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.
23 /*! \file isc/mem.h */
28 #include <isc/mutex.h>
29 #include <isc/platform.h>
30 #include <isc/types.h>
35 #define ISC_MEM_LOWATER 0
36 #define ISC_MEM_HIWATER 1
37 typedef void (*isc_mem_water_t)(void *, int);
39 typedef void * (*isc_memalloc_t)(void *, size_t);
40 typedef void (*isc_memfree_t)(void *, void *);
43 * Define ISC_MEM_DEBUG=1 to make all functions that free memory
44 * set the pointer being freed to NULL after being freed.
45 * This is the default; set ISC_MEM_DEBUG=0 to disable it.
48 #define ISC_MEM_DEBUG 1
52 * Define ISC_MEM_TRACKLINES=1 to turn on detailed tracing of memory
53 * allocation and freeing by file and line number.
55 #ifndef ISC_MEM_TRACKLINES
56 #define ISC_MEM_TRACKLINES 1
60 * Define ISC_MEM_CHECKOVERRUN=1 to turn on checks for using memory outside
61 * the requested space. This will increase the size of each allocation.
63 #ifndef ISC_MEM_CHECKOVERRUN
64 #define ISC_MEM_CHECKOVERRUN 1
68 * Define ISC_MEM_FILL=1 to fill each block of memory returned to the system
69 * with the byte string '0xbe'. This helps track down uninitialized pointers
70 * and the like. On freeing memory, the space is filled with '0xde' for
74 #define ISC_MEM_FILL 1
78 * Define ISC_MEMPOOL_NAMES=1 to make memory pools store a symbolic
79 * name so that the leaking pool can be more readily identified in
80 * case of a memory leak.
82 #ifndef ISC_MEMPOOL_NAMES
83 #define ISC_MEMPOOL_NAMES 1
86 LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_debugging;
88 #define ISC_MEM_DEBUGTRACE 0x00000001U
89 #define ISC_MEM_DEBUGRECORD 0x00000002U
90 #define ISC_MEM_DEBUGUSAGE 0x00000004U
91 #define ISC_MEM_DEBUGSIZE 0x00000008U
92 #define ISC_MEM_DEBUGCTX 0x00000010U
93 #define ISC_MEM_DEBUGALL 0x0000001FU
95 * The variable isc_mem_debugging holds a set of flags for
96 * turning certain memory debugging options on or off at
97 * runtime. It is initialized to the value ISC_MEM_DEGBUGGING,
98 * which is 0 by default but may be overridden at compile time.
99 * The following flags can be specified:
101 * \li #ISC_MEM_DEBUGTRACE
102 * Log each allocation and free to isc_lctx.
104 * \li #ISC_MEM_DEBUGRECORD
105 * Remember each allocation, and match them up on free.
106 * Crash if a free doesn't match an allocation.
108 * \li #ISC_MEM_DEBUGUSAGE
109 * If a hi_water mark is set, print the maximum inuse memory
110 * every time it is raised once it exceeds the hi_water mark.
112 * \li #ISC_MEM_DEBUGSIZE
113 * Check the size argument being passed to isc_mem_put() matches
114 * that passed to isc_mem_get().
116 * \li #ISC_MEM_DEBUGCTX
117 * Check the mctx argument being passed to isc_mem_put() matches
118 * that passed to isc_mem_get().
122 #if ISC_MEM_TRACKLINES
123 #define _ISC_MEM_FILELINE , __FILE__, __LINE__
124 #define _ISC_MEM_FLARG , const char *, unsigned int
126 #define _ISC_MEM_FILELINE
127 #define _ISC_MEM_FLARG
131 * Define ISC_MEM_USE_INTERNAL_MALLOC=1 to use the internal malloc()
132 * implementation in preference to the system one. The internal malloc()
133 * is very space-efficient, and quite fast on uniprocessor systems. It
134 * performs poorly on multiprocessor machines.
135 * JT: we can overcome the performance issue on multiprocessor machines
136 * by carefully separating memory contexts.
139 #ifndef ISC_MEM_USE_INTERNAL_MALLOC
140 #define ISC_MEM_USE_INTERNAL_MALLOC 1
144 * Flags for isc_mem_create2()calls.
146 #define ISC_MEMFLAG_NOLOCK 0x00000001 /* no lock is necessary */
147 #define ISC_MEMFLAG_INTERNAL 0x00000002 /* use internal malloc */
148 #if ISC_MEM_USE_INTERNAL_MALLOC
149 #define ISC_MEMFLAG_DEFAULT ISC_MEMFLAG_INTERNAL
151 #define ISC_MEMFLAG_DEFAULT 0
156 * We use either isc___mem (three underscores) or isc__mem (two) depending on
157 * whether it's for BIND9's internal purpose (with -DBIND9) or generic export
158 * library. This condition is generally handled in isc/namespace.h, but for
159 * Windows it doesn't work if it involves multiple times of macro expansion
160 * (such as isc_mem to isc__mem then to isc___mem). The following definitions
161 * are used to work around this portability issue. Right now, we don't support
162 * the export library for Windows, so we always use the three-underscore
166 #define ISCMEMFUNC(sfx) isc___mem_ ## sfx
167 #define ISCMEMPOOLFUNC(sfx) isc___mempool_ ## sfx
169 #define ISCMEMFUNC(sfx) isc__mem_ ## sfx
170 #define ISCMEMPOOLFUNC(sfx) isc__mempool_ ## sfx
173 #define isc_mem_get(c, s) ISCMEMFUNC(get)((c), (s) _ISC_MEM_FILELINE)
174 #define isc_mem_allocate(c, s) ISCMEMFUNC(allocate)((c), (s) _ISC_MEM_FILELINE)
175 #define isc_mem_reallocate(c, p, s) ISCMEMFUNC(reallocate)((c), (p), (s) _ISC_MEM_FILELINE)
176 #define isc_mem_strdup(c, p) ISCMEMFUNC(strdup)((c), (p) _ISC_MEM_FILELINE)
177 #define isc_mempool_get(c) ISCMEMPOOLFUNC(get)((c) _ISC_MEM_FILELINE)
180 * isc_mem_putanddetach() is a convenience function for use where you
181 * have a structure with an attached memory context.
194 * isc_mem_putanddetach(&ptr->mctx, ptr, sizeof(*ptr));
197 * is the equivalent of:
201 * isc_mem_attach(ptr->mctx, &mctx);
202 * isc_mem_detach(&ptr->mctx);
203 * isc_mem_put(mctx, ptr, sizeof(*ptr));
204 * isc_mem_detach(&mctx);
208 /*% memory and memory pool methods */
209 typedef struct isc_memmethods {
210 void (*attach)(isc_mem_t *source, isc_mem_t **targetp);
211 void (*detach)(isc_mem_t **mctxp);
212 void (*destroy)(isc_mem_t **mctxp);
213 void *(*memget)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
214 void (*memput)(isc_mem_t *mctx, void *ptr, size_t size _ISC_MEM_FLARG);
215 void (*memputanddetach)(isc_mem_t **mctxp, void *ptr,
216 size_t size _ISC_MEM_FLARG);
217 void *(*memallocate)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
218 void *(*memreallocate)(isc_mem_t *mctx, void *ptr,
219 size_t size _ISC_MEM_FLARG);
220 char *(*memstrdup)(isc_mem_t *mctx, const char *s _ISC_MEM_FLARG);
221 void (*memfree)(isc_mem_t *mctx, void *ptr _ISC_MEM_FLARG);
222 void (*setdestroycheck)(isc_mem_t *mctx, isc_boolean_t flag);
223 void (*setwater)(isc_mem_t *ctx, isc_mem_water_t water,
224 void *water_arg, size_t hiwater, size_t lowater);
225 void (*waterack)(isc_mem_t *ctx, int flag);
226 size_t (*inuse)(isc_mem_t *mctx);
227 isc_boolean_t (*isovermem)(isc_mem_t *mctx);
228 isc_result_t (*mpcreate)(isc_mem_t *mctx, size_t size,
229 isc_mempool_t **mpctxp);
232 typedef struct isc_mempoolmethods {
233 void (*destroy)(isc_mempool_t **mpctxp);
234 void *(*get)(isc_mempool_t *mpctx _ISC_MEM_FLARG);
235 void (*put)(isc_mempool_t *mpctx, void *mem _ISC_MEM_FLARG);
236 unsigned int (*getallocated)(isc_mempool_t *mpctx);
237 void (*setmaxalloc)(isc_mempool_t *mpctx, unsigned int limit);
238 void (*setfreemax)(isc_mempool_t *mpctx, unsigned int limit);
239 void (*setname)(isc_mempool_t *mpctx, const char *name);
240 void (*associatelock)(isc_mempool_t *mpctx, isc_mutex_t *lock);
241 void (*setfillcount)(isc_mempool_t *mpctx, unsigned int limit);
242 } isc_mempoolmethods_t;
245 * This structure is actually just the common prefix of a memory context
246 * implementation's version of an isc_mem_t.
248 * Direct use of this structure by clients is forbidden. mctx implementations
249 * may change the structure. 'magic' must be ISCAPI_MCTX_MAGIC for any of the
250 * isc_mem_ routines to work. mctx implementations must maintain all mctx
254 unsigned int impmagic;
256 isc_memmethods_t *methods;
259 #define ISCAPI_MCTX_MAGIC ISC_MAGIC('A','m','c','x')
260 #define ISCAPI_MCTX_VALID(m) ((m) != NULL && \
261 (m)->magic == ISCAPI_MCTX_MAGIC)
264 * This is the common prefix of a memory pool context. The same note as
265 * that for the mem structure applies.
268 unsigned int impmagic;
270 isc_mempoolmethods_t *methods;
273 #define ISCAPI_MPOOL_MAGIC ISC_MAGIC('A','m','p','l')
274 #define ISCAPI_MPOOL_VALID(mp) ((mp) != NULL && \
275 (mp)->magic == ISCAPI_MPOOL_MAGIC)
278 #define isc_mem_put(c, p, s) \
280 ISCMEMFUNC(put)((c), (p), (s) _ISC_MEM_FILELINE); \
283 #define isc_mem_putanddetach(c, p, s) \
285 ISCMEMFUNC(putanddetach)((c), (p), (s) _ISC_MEM_FILELINE); \
288 #define isc_mem_free(c, p) \
290 ISCMEMFUNC(free)((c), (p) _ISC_MEM_FILELINE); \
293 #define isc_mempool_put(c, p) \
295 ISCMEMPOOLFUNC(put)((c), (p) _ISC_MEM_FILELINE); \
299 #define isc_mem_put(c, p, s) ISCMEMFUNC(put)((c), (p), (s) _ISC_MEM_FILELINE)
300 #define isc_mem_putanddetach(c, p, s) \
301 ISCMEMFUNC(putanddetach)((c), (p), (s) _ISC_MEM_FILELINE)
302 #define isc_mem_free(c, p) ISCMEMFUNC(free)((c), (p) _ISC_MEM_FILELINE)
303 #define isc_mempool_put(c, p) ISCMEMPOOLFUNC(put)((c), (p) _ISC_MEM_FILELINE)
308 isc_mem_create(size_t max_size, size_t target_size,
312 isc_mem_create2(size_t max_size, size_t target_size,
313 isc_mem_t **mctxp, unsigned int flags);
316 isc_mem_createx(size_t max_size, size_t target_size,
317 isc_memalloc_t memalloc, isc_memfree_t memfree,
318 void *arg, isc_mem_t **mctxp);
321 isc_mem_createx2(size_t max_size, size_t target_size,
322 isc_memalloc_t memalloc, isc_memfree_t memfree,
323 void *arg, isc_mem_t **mctxp, unsigned int flags);
326 * \brief Create a memory context.
328 * 'max_size' and 'target_size' are tuning parameters. When
329 * ISC_MEMFLAG_INTERNAL is set, allocations smaller than 'max_size'
330 * will be satisfied by getting blocks of size 'target_size' from the
331 * system allocator and breaking them up into pieces; larger allocations
332 * will use the system allocator directly. If 'max_size' and/or
333 * 'target_size' are zero, default values will be * used. When
334 * ISC_MEMFLAG_INTERNAL is not set, 'target_size' is ignored.
336 * 'max_size' is also used to size the statistics arrays and the array
337 * used to record active memory when ISC_MEM_DEBUGRECORD is set. Setting
338 * 'max_size' too low can have detrimental effects on performance.
340 * A memory context created using isc_mem_createx() will obtain
341 * memory from the system by calling 'memalloc' and 'memfree',
342 * passing them the argument 'arg'. A memory context created
343 * using isc_mem_create() will use the standard library malloc()
346 * If ISC_MEMFLAG_NOLOCK is set in 'flags', the corresponding memory context
347 * will be accessed without locking. The user who creates the context must
348 * ensure there be no race. Since this can be a source of bug, it is generally
349 * inadvisable to use this flag unless the user is very sure about the race
350 * condition and the access to the object is highly performance sensitive.
353 * mctxp != NULL && *mctxp == NULL */
358 isc_mem_attach(isc_mem_t *, isc_mem_t **);
360 isc_mem_detach(isc_mem_t **);
362 * \brief Attach to / detach from a memory context.
364 * This is intended for applications that use multiple memory contexts
365 * in such a way that it is not obvious when the last allocations from
366 * a given context has been freed and destroying the context is safe.
368 * Most applications do not need to call these functions as they can
369 * simply create a single memory context at the beginning of main()
370 * and destroy it at the end of main(), thereby guaranteeing that it
371 * is not destroyed while there are outstanding allocations.
376 isc_mem_destroy(isc_mem_t **);
378 * Destroy a memory context.
382 isc_mem_ondestroy(isc_mem_t *ctx,
384 isc_event_t **event);
386 * Request to be notified with an event when a memory context has
387 * been successfully destroyed.
391 isc_mem_stats(isc_mem_t *mctx, FILE *out);
393 * Print memory usage statistics for 'mctx' on the stream 'out'.
397 isc_mem_setdestroycheck(isc_mem_t *mctx,
400 * If 'on' is ISC_TRUE, 'mctx' will check for memory leaks when
401 * destroyed and abort the program if any are present.
406 isc_mem_setquota(isc_mem_t *, size_t);
408 isc_mem_getquota(isc_mem_t *);
410 * Set/get the memory quota of 'mctx'. This is a hard limit
411 * on the amount of memory that may be allocated from mctx;
412 * if it is exceeded, allocations will fail.
417 isc_mem_inuse(isc_mem_t *mctx);
419 * Get an estimate of the number of memory in use in 'mctx', in bytes.
420 * This includes quantization overhead, but does not include memory
421 * allocated from the system but not yet used.
425 isc_mem_isovermem(isc_mem_t *mctx);
427 * Return true iff the memory context is in "over memory" state, i.e.,
428 * a hiwater mark has been set and the used amount of memory has exceeds
433 isc_mem_setwater(isc_mem_t *mctx, isc_mem_water_t water, void *water_arg,
434 size_t hiwater, size_t lowater);
436 * Set high and low water marks for this memory context.
438 * When the memory usage of 'mctx' exceeds 'hiwater',
439 * '(water)(water_arg, #ISC_MEM_HIWATER)' will be called. 'water' needs to
440 * call isc_mem_waterack() with #ISC_MEM_HIWATER to acknowledge the state
441 * change. 'water' may be called multiple times.
443 * When the usage drops below 'lowater', 'water' will again be called, this
444 * time with #ISC_MEM_LOWATER. 'water' need to calls isc_mem_waterack() with
445 * #ISC_MEM_LOWATER to acknowledge the change.
448 * water(void *arg, int mark) {
449 * struct foo *foo = arg;
451 * LOCK(&foo->marklock);
452 * if (foo->mark != mark) {
455 * isc_mem_waterack(foo->mctx, mark);
457 * UNLOCK(&foo->marklock);
460 * If 'water' is NULL then 'water_arg', 'hi_water' and 'lo_water' are
461 * ignored and the state is reset.
465 * 'water' is not NULL.
466 * hi_water >= lo_water
470 isc_mem_waterack(isc_mem_t *ctx, int mark);
472 * Called to acknowledge changes in signaled by calls to 'water'.
476 isc_mem_printactive(isc_mem_t *mctx, FILE *file);
478 * Print to 'file' all active memory in 'mctx'.
480 * Requires ISC_MEM_DEBUGRECORD to have been set.
484 isc_mem_printallactive(FILE *file);
486 * Print to 'file' all active memory in all contexts.
488 * Requires ISC_MEM_DEBUGRECORD to have been set.
492 isc_mem_checkdestroyed(FILE *file);
494 * Check that all memory contexts have been destroyed.
495 * Prints out those that have not been.
496 * Fatally fails if there are still active contexts.
500 isc_mem_references(isc_mem_t *ctx);
502 * Return the current reference count.
506 isc_mem_setname(isc_mem_t *ctx, const char *name, void *tag);
512 *\li Only the first 15 characters of 'name' will be copied.
514 *\li 'tag' is for debugging purposes only.
518 *\li 'ctx' is a valid ctx.
522 isc_mem_getname(isc_mem_t *ctx);
524 * Get the name of 'ctx', as previously set using isc_mem_setname().
527 *\li 'ctx' is a valid ctx.
530 *\li A non-NULL pointer to a null-terminated string.
531 * If the ctx has not been named, the string is
536 isc_mem_gettag(isc_mem_t *ctx);
538 * Get the tag value for 'task', as previously set using isc_mem_setname().
541 *\li 'ctx' is a valid ctx.
544 *\li This function is for debugging purposes only.
547 *\li 'ctx' is a valid task.
552 isc_mem_renderxml(xmlTextWriterPtr writer);
554 * Render all contexts' statistics and status in XML for writer.
556 #endif /* HAVE_LIBXML2 */
563 isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp);
565 * Create a memory pool.
568 *\li mctx is a valid memory context.
570 *\li mpctxp != NULL and *mpctxp == NULL
573 *\li maxalloc = UINT_MAX
578 *\li #ISC_R_NOMEMORY -- not enough memory to create pool
579 *\li #ISC_R_SUCCESS -- all is well.
583 isc_mempool_destroy(isc_mempool_t **mpctxp);
585 * Destroy a memory pool.
588 *\li mpctxp != NULL && *mpctxp is a valid pool.
589 *\li The pool has no un"put" allocations outstanding
593 isc_mempool_setname(isc_mempool_t *mpctx, const char *name);
595 * Associate a name with a memory pool. At most 15 characters may be used.
598 *\li mpctx is a valid pool.
603 isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock);
605 * Associate a lock with this memory pool.
607 * This lock is used when getting or putting items using this memory pool,
608 * and it is also used to set or get internal state via the isc_mempool_get*()
609 * and isc_mempool_set*() set of functions.
611 * Multiple pools can each share a single lock. For instance, if "manager"
612 * type object contained pools for various sizes of events, and each of
613 * these pools used a common lock. Note that this lock must NEVER be used
614 * by other than mempool routines once it is given to a pool, since that can
615 * easily cause double locking.
619 *\li mpctpx is a valid pool.
623 *\li No previous lock is assigned to this pool.
625 *\li The lock is initialized before calling this function via the normal
626 * means of doing that.
630 * The following functions get/set various parameters. Note that due to
631 * the unlocked nature of pools these are potentially random values unless
632 * the imposed externally provided locking protocols are followed.
634 * Also note that the quota limits will not always take immediate effect.
635 * For instance, setting "maxalloc" to a number smaller than the currently
636 * allocated count is permitted. New allocations will be refused until
637 * the count drops below this threshold.
639 * All functions require (in addition to other requirements):
640 * mpctx is a valid memory pool
644 isc_mempool_getfreemax(isc_mempool_t *mpctx);
646 * Returns the maximum allowed size of the free list.
650 isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit);
652 * Sets the maximum allowed size of the free list.
656 isc_mempool_getfreecount(isc_mempool_t *mpctx);
658 * Returns current size of the free list.
662 isc_mempool_getmaxalloc(isc_mempool_t *mpctx);
664 * Returns the maximum allowed number of allocations.
668 isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit);
670 * Sets the maximum allowed number of allocations.
672 * Additional requirements:
677 isc_mempool_getallocated(isc_mempool_t *mpctx);
679 * Returns the number of items allocated from this pool.
683 isc_mempool_getfillcount(isc_mempool_t *mpctx);
685 * Returns the number of items allocated as a block from the parent memory
686 * context when the free list is empty.
690 isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit);
692 * Sets the fillcount.
694 * Additional requirements:
700 * Pseudo-private functions for use via macros. Do not call directly.
703 ISCMEMFUNC(get)(isc_mem_t *, size_t _ISC_MEM_FLARG);
705 ISCMEMFUNC(putanddetach)(isc_mem_t **, void *, size_t _ISC_MEM_FLARG);
707 ISCMEMFUNC(put)(isc_mem_t *, void *, size_t _ISC_MEM_FLARG);
709 ISCMEMFUNC(allocate)(isc_mem_t *, size_t _ISC_MEM_FLARG);
711 ISCMEMFUNC(reallocate)(isc_mem_t *, void *, size_t _ISC_MEM_FLARG);
713 ISCMEMFUNC(free)(isc_mem_t *, void * _ISC_MEM_FLARG);
715 ISCMEMFUNC(strdup)(isc_mem_t *, const char *_ISC_MEM_FLARG);
717 ISCMEMPOOLFUNC(get)(isc_mempool_t * _ISC_MEM_FLARG);
719 ISCMEMPOOLFUNC(put)(isc_mempool_t *, void * _ISC_MEM_FLARG);
721 #ifdef USE_MEMIMPREGISTER
724 * See isc_mem_create2() above.
727 (*isc_memcreatefunc_t)(size_t init_max_size, size_t target_size,
728 isc_mem_t **ctxp, unsigned int flags);
731 isc_mem_register(isc_memcreatefunc_t createfunc);
733 * Register a new memory management implementation and add it to the list of
734 * supported implementations. This function must be called when a different
735 * memory management library is used than the one contained in the ISC library.
739 isc__mem_register(void);
741 * A short cut function that specifies the memory management module in the ISC
742 * library for isc_mem_register(). An application that uses the ISC library
743 * usually do not have to care about this function: it would call
744 * isc_lib_register(), which internally calls this function.
746 #endif /* USE_MEMIMPREGISTER */
750 #endif /* ISC_MEM_H */