"Fossies" - the Fresh Open Source Software Archive

Member "bind-9.16.7/lib/isc/include/isc/mem.h" (4 Sep 2020, 17077 Bytes) of package /linux/misc/dns/bind9/9.16.7/bind-9.16.7.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "mem.h" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
    3  *
    4  * This Source Code Form is subject to the terms of the Mozilla Public
    5  * License, v. 2.0. If a copy of the MPL was not distributed with this
    6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
    7  *
    8  * See the COPYRIGHT file distributed with this work for additional
    9  * information regarding copyright ownership.
   10  */
   11 
   12 #ifndef ISC_MEM_H
   13 #define ISC_MEM_H 1
   14 
   15 /*! \file isc/mem.h */
   16 
   17 #include <stdbool.h>
   18 #include <stdio.h>
   19 
   20 #include <isc/lang.h>
   21 #include <isc/mutex.h>
   22 #include <isc/platform.h>
   23 #include <isc/types.h>
   24 
   25 ISC_LANG_BEGINDECLS
   26 
   27 #define ISC_MEM_LOWATER 0
   28 #define ISC_MEM_HIWATER 1
   29 typedef void (*isc_mem_water_t)(void *, int);
   30 
   31 /*%
   32  * Define ISC_MEM_TRACKLINES=1 to turn on detailed tracing of memory
   33  * allocation and freeing by file and line number.
   34  */
   35 #ifndef ISC_MEM_TRACKLINES
   36 #define ISC_MEM_TRACKLINES 1
   37 #endif /* ifndef ISC_MEM_TRACKLINES */
   38 
   39 /*%
   40  * Define ISC_MEM_CHECKOVERRUN=1 to turn on checks for using memory outside
   41  * the requested space.  This will increase the size of each allocation.
   42  *
   43  * If we are performing a Coverity static analysis then ISC_MEM_CHECKOVERRUN
   44  * can hide bugs that would otherwise discovered so force to zero.
   45  */
   46 #ifdef __COVERITY__
   47 #undef ISC_MEM_CHECKOVERRUN
   48 #define ISC_MEM_CHECKOVERRUN 0
   49 #endif /* ifdef __COVERITY__ */
   50 #ifndef ISC_MEM_CHECKOVERRUN
   51 #define ISC_MEM_CHECKOVERRUN 1
   52 #endif /* ifndef ISC_MEM_CHECKOVERRUN */
   53 
   54 /*%
   55  * Define ISC_MEMPOOL_NAMES=1 to make memory pools store a symbolic
   56  * name so that the leaking pool can be more readily identified in
   57  * case of a memory leak.
   58  */
   59 #ifndef ISC_MEMPOOL_NAMES
   60 #define ISC_MEMPOOL_NAMES 1
   61 #endif /* ifndef ISC_MEMPOOL_NAMES */
   62 
   63 LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_debugging;
   64 LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_defaultflags;
   65 
   66 /*@{*/
   67 #define ISC_MEM_DEBUGTRACE  0x00000001U
   68 #define ISC_MEM_DEBUGRECORD 0x00000002U
   69 #define ISC_MEM_DEBUGUSAGE  0x00000004U
   70 #define ISC_MEM_DEBUGSIZE   0x00000008U
   71 #define ISC_MEM_DEBUGCTX    0x00000010U
   72 #define ISC_MEM_DEBUGALL    0x0000001FU
   73 /*!<
   74  * The variable isc_mem_debugging holds a set of flags for
   75  * turning certain memory debugging options on or off at
   76  * runtime.  It is initialized to the value ISC_MEM_DEGBUGGING,
   77  * which is 0 by default but may be overridden at compile time.
   78  * The following flags can be specified:
   79  *
   80  * \li #ISC_MEM_DEBUGTRACE
   81  *  Log each allocation and free to isc_lctx.
   82  *
   83  * \li #ISC_MEM_DEBUGRECORD
   84  *  Remember each allocation, and match them up on free.
   85  *  Crash if a free doesn't match an allocation.
   86  *
   87  * \li #ISC_MEM_DEBUGUSAGE
   88  *  If a hi_water mark is set, print the maximum inuse memory
   89  *  every time it is raised once it exceeds the hi_water mark.
   90  *
   91  * \li #ISC_MEM_DEBUGSIZE
   92  *  Check the size argument being passed to isc_mem_put() matches
   93  *  that passed to isc_mem_get().
   94  *
   95  * \li #ISC_MEM_DEBUGCTX
   96  *  Check the mctx argument being passed to isc_mem_put() matches
   97  *  that passed to isc_mem_get().
   98  */
   99 /*@}*/
  100 
  101 #if ISC_MEM_TRACKLINES
  102 #define _ISC_MEM_FILELINE , __FILE__, __LINE__
  103 #define _ISC_MEM_FLARG    , const char *, unsigned int
  104 #else /* if ISC_MEM_TRACKLINES */
  105 #define _ISC_MEM_FILELINE
  106 #define _ISC_MEM_FLARG
  107 #endif /* if ISC_MEM_TRACKLINES */
  108 
  109 /*!
  110  * Define ISC_MEM_USE_INTERNAL_MALLOC=1 to use the internal malloc()
  111  * implementation in preference to the system one.  The internal malloc()
  112  * is very space-efficient, and quite fast on uniprocessor systems.  It
  113  * performs poorly on multiprocessor machines.
  114  * JT: we can overcome the performance issue on multiprocessor machines
  115  * by carefully separating memory contexts.
  116  */
  117 
  118 #ifndef ISC_MEM_USE_INTERNAL_MALLOC
  119 #define ISC_MEM_USE_INTERNAL_MALLOC 1
  120 #endif /* ifndef ISC_MEM_USE_INTERNAL_MALLOC */
  121 
  122 /*
  123  * Flags for isc_mem_create() calls.
  124  */
  125 #define ISC_MEMFLAG_RESERVED 0x00000001 /* reserved, obsoleted, don't use */
  126 #define ISC_MEMFLAG_INTERNAL 0x00000002 /* use internal malloc */
  127 #define ISC_MEMFLAG_FILL \
  128     0x00000004 /* fill with pattern after alloc and frees */
  129 
  130 #if !ISC_MEM_USE_INTERNAL_MALLOC
  131 #define ISC_MEMFLAG_DEFAULT 0
  132 #else /* if !ISC_MEM_USE_INTERNAL_MALLOC */
  133 #define ISC_MEMFLAG_DEFAULT ISC_MEMFLAG_INTERNAL | ISC_MEMFLAG_FILL
  134 #endif /* if !ISC_MEM_USE_INTERNAL_MALLOC */
  135 
  136 /*%
  137  * isc_mem_putanddetach() is a convenience function for use where you
  138  * have a structure with an attached memory context.
  139  *
  140  * Given:
  141  *
  142  * \code
  143  * struct {
  144  *  ...
  145  *  isc_mem_t *mctx;
  146  *  ...
  147  * } *ptr;
  148  *
  149  * isc_mem_t *mctx;
  150  *
  151  * isc_mem_putanddetach(&ptr->mctx, ptr, sizeof(*ptr));
  152  * \endcode
  153  *
  154  * is the equivalent of:
  155  *
  156  * \code
  157  * mctx = NULL;
  158  * isc_mem_attach(ptr->mctx, &mctx);
  159  * isc_mem_detach(&ptr->mctx);
  160  * isc_mem_put(mctx, ptr, sizeof(*ptr));
  161  * isc_mem_detach(&mctx);
  162  * \endcode
  163  */
  164 
  165 /*% memory and memory pool methods */
  166 typedef struct isc_memmethods {
  167     void *(*memget)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
  168     void (*memput)(isc_mem_t *mctx, void *ptr, size_t size _ISC_MEM_FLARG);
  169     void (*memputanddetach)(isc_mem_t **mctxp, void *ptr,
  170                 size_t size _ISC_MEM_FLARG);
  171     void *(*memallocate)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
  172     void *(*memreallocate)(isc_mem_t *mctx, void *ptr,
  173                    size_t size _ISC_MEM_FLARG);
  174     char *(*memstrdup)(isc_mem_t *mctx, const char *s _ISC_MEM_FLARG);
  175     void (*memfree)(isc_mem_t *mctx, void *ptr _ISC_MEM_FLARG);
  176 } isc_memmethods_t;
  177 
  178 /*%
  179  * This structure is actually just the common prefix of a memory context
  180  * implementation's version of an isc_mem_t.
  181  * \brief
  182  * Direct use of this structure by clients is forbidden.  mctx implementations
  183  * may change the structure.  'magic' must be ISCAPI_MCTX_MAGIC for any of the
  184  * isc_mem_ routines to work.  mctx implementations must maintain all mctx
  185  * invariants.
  186  */
  187 struct isc_mem {
  188     unsigned int      impmagic;
  189     unsigned int      magic;
  190     isc_memmethods_t *methods;
  191 };
  192 
  193 #define ISCAPI_MCTX_MAGIC    ISC_MAGIC('A', 'm', 'c', 'x')
  194 #define ISCAPI_MCTX_VALID(m) ((m) != NULL && (m)->magic == ISCAPI_MCTX_MAGIC)
  195 
  196 /*%
  197  * This is the common prefix of a memory pool context.  The same note as
  198  * that for the mem structure applies.
  199  */
  200 struct isc_mempool {
  201     unsigned int impmagic;
  202     unsigned int magic;
  203 };
  204 
  205 #define ISCAPI_MPOOL_MAGIC ISC_MAGIC('A', 'm', 'p', 'l')
  206 #define ISCAPI_MPOOL_VALID(mp) \
  207     ((mp) != NULL && (mp)->magic == ISCAPI_MPOOL_MAGIC)
  208 
  209 /*%
  210  * These functions are actually implemented in isc__mem_<function>
  211  * (two underscores). The single-underscore macros are used to pass
  212  * __FILE__ and __LINE__, and in the case of the put functions, to
  213  * set the pointer being freed to NULL in the calling function.
  214  *
  215  * Many of these functions have a further isc___mem_<function>
  216  * (three underscores) implementation, which is called indirectly
  217  * via the isc_memmethods structure in the mctx so that dynamically
  218  * loaded modules can use them even if named is statically linked.
  219  */
  220 
  221 #define ISCMEMFUNC(sfx)     isc__mem_##sfx
  222 #define ISCMEMPOOLFUNC(sfx) isc__mempool_##sfx
  223 
  224 #define isc_mem_get(c, s)      ISCMEMFUNC(get)((c), (s)_ISC_MEM_FILELINE)
  225 #define isc_mem_allocate(c, s) ISCMEMFUNC(allocate)((c), (s)_ISC_MEM_FILELINE)
  226 #define isc_mem_reallocate(c, p, s) \
  227     ISCMEMFUNC(reallocate)((c), (p), (s)_ISC_MEM_FILELINE)
  228 #define isc_mem_strdup(c, p) ISCMEMFUNC(strdup)((c), (p)_ISC_MEM_FILELINE)
  229 #define isc_mempool_get(c)   ISCMEMPOOLFUNC(get)((c)_ISC_MEM_FILELINE)
  230 
  231 #define isc_mem_put(c, p, s)                                     \
  232     do {                                                     \
  233         ISCMEMFUNC(put)((c), (p), (s)_ISC_MEM_FILELINE); \
  234         (p) = NULL;                                      \
  235     } while (0)
  236 #define isc_mem_putanddetach(c, p, s)                                     \
  237     do {                                                              \
  238         ISCMEMFUNC(putanddetach)((c), (p), (s)_ISC_MEM_FILELINE); \
  239         (p) = NULL;                                               \
  240     } while (0)
  241 #define isc_mem_free(c, p)                                   \
  242     do {                                                 \
  243         ISCMEMFUNC(free)((c), (p)_ISC_MEM_FILELINE); \
  244         (p) = NULL;                                  \
  245     } while (0)
  246 #define isc_mempool_put(c, p)                                   \
  247     do {                                                    \
  248         ISCMEMPOOLFUNC(put)((c), (p)_ISC_MEM_FILELINE); \
  249         (p) = NULL;                                     \
  250     } while (0)
  251 
  252 /*@{*/
  253 void
  254 isc_mem_create(isc_mem_t **mctxp);
  255 
  256 /*!<
  257  * \brief Create a memory context.
  258  *
  259  * Requires:
  260  * mctxp != NULL && *mctxp == NULL */
  261 /*@}*/
  262 
  263 /*@{*/
  264 void
  265 isc_mem_attach(isc_mem_t *, isc_mem_t **);
  266 void
  267 isc_mem_detach(isc_mem_t **);
  268 /*!<
  269  * \brief Attach to / detach from a memory context.
  270  *
  271  * This is intended for applications that use multiple memory contexts
  272  * in such a way that it is not obvious when the last allocations from
  273  * a given context has been freed and destroying the context is safe.
  274  *
  275  * Most applications do not need to call these functions as they can
  276  * simply create a single memory context at the beginning of main()
  277  * and destroy it at the end of main(), thereby guaranteeing that it
  278  * is not destroyed while there are outstanding allocations.
  279  */
  280 /*@}*/
  281 
  282 void
  283 isc_mem_destroy(isc_mem_t **);
  284 /*%<
  285  * Destroy a memory context.
  286  */
  287 
  288 void
  289 isc_mem_stats(isc_mem_t *mctx, FILE *out);
  290 /*%<
  291  * Print memory usage statistics for 'mctx' on the stream 'out'.
  292  */
  293 
  294 void
  295 isc_mem_setdestroycheck(isc_mem_t *mctx, bool on);
  296 /*%<
  297  * If 'on' is true, 'mctx' will check for memory leaks when
  298  * destroyed and abort the program if any are present.
  299  */
  300 
  301 size_t
  302 isc_mem_inuse(isc_mem_t *mctx);
  303 /*%<
  304  * Get an estimate of the amount of memory in use in 'mctx', in bytes.
  305  * This includes quantization overhead, but does not include memory
  306  * allocated from the system but not yet used.
  307  */
  308 
  309 size_t
  310 isc_mem_maxinuse(isc_mem_t *mctx);
  311 /*%<
  312  * Get an estimate of the largest amount of memory that has been in
  313  * use in 'mctx' at any time.
  314  */
  315 
  316 size_t
  317 isc_mem_total(isc_mem_t *mctx);
  318 /*%<
  319  * Get the total amount of memory in 'mctx', in bytes, including memory
  320  * not yet used.
  321  */
  322 
  323 bool
  324 isc_mem_isovermem(isc_mem_t *mctx);
  325 /*%<
  326  * Return true iff the memory context is in "over memory" state, i.e.,
  327  * a hiwater mark has been set and the used amount of memory has exceeds
  328  * the mark.
  329  */
  330 
  331 void
  332 isc_mem_setwater(isc_mem_t *mctx, isc_mem_water_t water, void *water_arg,
  333          size_t hiwater, size_t lowater);
  334 /*%<
  335  * Set high and low water marks for this memory context.
  336  *
  337  * When the memory usage of 'mctx' exceeds 'hiwater',
  338  * '(water)(water_arg, #ISC_MEM_HIWATER)' will be called.  'water' needs to
  339  * call isc_mem_waterack() with #ISC_MEM_HIWATER to acknowledge the state
  340  * change.  'water' may be called multiple times.
  341  *
  342  * When the usage drops below 'lowater', 'water' will again be called, this
  343  * time with #ISC_MEM_LOWATER.  'water' need to calls isc_mem_waterack() with
  344  * #ISC_MEM_LOWATER to acknowledge the change.
  345  *
  346  *  static void
  347  *  water(void *arg, int mark) {
  348  *      struct foo *foo = arg;
  349  *
  350  *      LOCK(&foo->marklock);
  351  *      if (foo->mark != mark) {
  352  *          foo->mark = mark;
  353  *          ....
  354  *          isc_mem_waterack(foo->mctx, mark);
  355  *      }
  356  *      UNLOCK(&foo->marklock);
  357  *  }
  358  *
  359  * If 'water' is NULL then 'water_arg', 'hi_water' and 'lo_water' are
  360  * ignored and the state is reset.
  361  *
  362  * Requires:
  363  *
  364  *  'water' is not NULL.
  365  *  hi_water >= lo_water
  366  */
  367 
  368 void
  369 isc_mem_waterack(isc_mem_t *ctx, int mark);
  370 /*%<
  371  * Called to acknowledge changes in signaled by calls to 'water'.
  372  */
  373 
  374 void
  375 isc_mem_checkdestroyed(FILE *file);
  376 /*%<
  377  * Check that all memory contexts have been destroyed.
  378  * Prints out those that have not been.
  379  * Fatally fails if there are still active contexts.
  380  */
  381 
  382 unsigned int
  383 isc_mem_references(isc_mem_t *ctx);
  384 /*%<
  385  * Return the current reference count.
  386  */
  387 
  388 void
  389 isc_mem_setname(isc_mem_t *ctx, const char *name, void *tag);
  390 /*%<
  391  * Name 'ctx'.
  392  *
  393  * Notes:
  394  *
  395  *\li   Only the first 15 characters of 'name' will be copied.
  396  *
  397  *\li   'tag' is for debugging purposes only.
  398  *
  399  * Requires:
  400  *
  401  *\li   'ctx' is a valid ctx.
  402  */
  403 
  404 const char *
  405 isc_mem_getname(isc_mem_t *ctx);
  406 /*%<
  407  * Get the name of 'ctx', as previously set using isc_mem_setname().
  408  *
  409  * Requires:
  410  *\li   'ctx' is a valid ctx.
  411  *
  412  * Returns:
  413  *\li   A non-NULL pointer to a null-terminated string.
  414  *  If the ctx has not been named, the string is
  415  *  empty.
  416  */
  417 
  418 void *
  419 isc_mem_gettag(isc_mem_t *ctx);
  420 /*%<
  421  * Get the tag value for  'task', as previously set using isc_mem_setname().
  422  *
  423  * Requires:
  424  *\li   'ctx' is a valid ctx.
  425  *
  426  * Notes:
  427  *\li   This function is for debugging purposes only.
  428  *
  429  * Requires:
  430  *\li   'ctx' is a valid task.
  431  */
  432 
  433 #ifdef HAVE_LIBXML2
  434 int
  435 isc_mem_renderxml(void *writer0);
  436 /*%<
  437  * Render all contexts' statistics and status in XML for writer.
  438  */
  439 #endif /* HAVE_LIBXML2 */
  440 
  441 #ifdef HAVE_JSON_C
  442 isc_result_t
  443 isc_mem_renderjson(void *memobj0);
  444 /*%<
  445  * Render all contexts' statistics and status in JSON.
  446  */
  447 #endif /* HAVE_JSON_C */
  448 
  449 /*
  450  * Memory pools
  451  */
  452 
  453 void
  454 isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp);
  455 /*%<
  456  * Create a memory pool.
  457  *
  458  * Requires:
  459  *\li   mctx is a valid memory context.
  460  *\li   size > 0
  461  *\li   mpctxp != NULL and *mpctxp == NULL
  462  *
  463  * Defaults:
  464  *\li   maxalloc = UINT_MAX
  465  *\li   freemax = 1
  466  *\li   fillcount = 1
  467  *
  468  * Returns:
  469  *\li   #ISC_R_NOMEMORY     -- not enough memory to create pool
  470  *\li   #ISC_R_SUCCESS      -- all is well.
  471  */
  472 
  473 void
  474 isc_mempool_destroy(isc_mempool_t **mpctxp);
  475 /*%<
  476  * Destroy a memory pool.
  477  *
  478  * Requires:
  479  *\li   mpctxp != NULL && *mpctxp is a valid pool.
  480  *\li   The pool has no un"put" allocations outstanding
  481  */
  482 
  483 void
  484 isc_mempool_setname(isc_mempool_t *mpctx, const char *name);
  485 /*%<
  486  * Associate a name with a memory pool.  At most 15 characters may be used.
  487  *
  488  * Requires:
  489  *\li   mpctx is a valid pool.
  490  *\li   name != NULL;
  491  */
  492 
  493 void
  494 isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock);
  495 /*%<
  496  * Associate a lock with this memory pool.
  497  *
  498  * This lock is used when getting or putting items using this memory pool,
  499  * and it is also used to set or get internal state via the isc_mempool_get*()
  500  * and isc_mempool_set*() set of functions.
  501  *
  502  * Multiple pools can each share a single lock.  For instance, if "manager"
  503  * type object contained pools for various sizes of events, and each of
  504  * these pools used a common lock.  Note that this lock must NEVER be used
  505  * by other than mempool routines once it is given to a pool, since that can
  506  * easily cause double locking.
  507  *
  508  * Requires:
  509  *
  510  *\li   mpctpx is a valid pool.
  511  *
  512  *\li   lock != NULL.
  513  *
  514  *\li   No previous lock is assigned to this pool.
  515  *
  516  *\li   The lock is initialized before calling this function via the normal
  517  *  means of doing that.
  518  */
  519 
  520 /*
  521  * The following functions get/set various parameters.  Note that due to
  522  * the unlocked nature of pools these are potentially random values unless
  523  * the imposed externally provided locking protocols are followed.
  524  *
  525  * Also note that the quota limits will not always take immediate effect.
  526  * For instance, setting "maxalloc" to a number smaller than the currently
  527  * allocated count is permitted.  New allocations will be refused until
  528  * the count drops below this threshold.
  529  *
  530  * All functions require (in addition to other requirements):
  531  *  mpctx is a valid memory pool
  532  */
  533 
  534 unsigned int
  535 isc_mempool_getfreemax(isc_mempool_t *mpctx);
  536 /*%<
  537  * Returns the maximum allowed size of the free list.
  538  */
  539 
  540 void
  541 isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit);
  542 /*%<
  543  * Sets the maximum allowed size of the free list.
  544  */
  545 
  546 unsigned int
  547 isc_mempool_getfreecount(isc_mempool_t *mpctx);
  548 /*%<
  549  * Returns current size of the free list.
  550  */
  551 
  552 unsigned int
  553 isc_mempool_getmaxalloc(isc_mempool_t *mpctx);
  554 /*!<
  555  * Returns the maximum allowed number of allocations.
  556  */
  557 
  558 void
  559 isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit);
  560 /*%<
  561  * Sets the maximum allowed number of allocations.
  562  *
  563  * Additional requirements:
  564  *\li   limit > 0
  565  */
  566 
  567 unsigned int
  568 isc_mempool_getallocated(isc_mempool_t *mpctx);
  569 /*%<
  570  * Returns the number of items allocated from this pool.
  571  */
  572 
  573 unsigned int
  574 isc_mempool_getfillcount(isc_mempool_t *mpctx);
  575 /*%<
  576  * Returns the number of items allocated as a block from the parent memory
  577  * context when the free list is empty.
  578  */
  579 
  580 void
  581 isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit);
  582 /*%<
  583  * Sets the fillcount.
  584  *
  585  * Additional requirements:
  586  *\li   limit > 0
  587  */
  588 
  589 /*
  590  * Pseudo-private functions for use via macros.  Do not call directly.
  591  */
  592 void *ISCMEMFUNC(get)(isc_mem_t *, size_t _ISC_MEM_FLARG);
  593 void  ISCMEMFUNC(putanddetach)(isc_mem_t **, void *, size_t _ISC_MEM_FLARG);
  594 void  ISCMEMFUNC(put)(isc_mem_t *, void *, size_t _ISC_MEM_FLARG);
  595 void *ISCMEMFUNC(allocate)(isc_mem_t *, size_t _ISC_MEM_FLARG);
  596 void *ISCMEMFUNC(reallocate)(isc_mem_t *, void *, size_t _ISC_MEM_FLARG);
  597 void  ISCMEMFUNC(free)(isc_mem_t *, void *_ISC_MEM_FLARG);
  598 char *ISCMEMFUNC(strdup)(isc_mem_t *, const char *_ISC_MEM_FLARG);
  599 void *ISCMEMPOOLFUNC(get)(isc_mempool_t *_ISC_MEM_FLARG);
  600 void  ISCMEMPOOLFUNC(put)(isc_mempool_t *, void *_ISC_MEM_FLARG);
  601 
  602 ISC_LANG_ENDDECLS
  603 
  604 #endif /* ISC_MEM_H */