/contrib/bind9/lib/isc/mem_api.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 303 lines · 201 code · 82 blank · 20 comment · 21 complexity · 42e782f55035bacb7a2b157d03b607a7 MD5 · raw file

  1. /*
  2. * Copyright (C) 2009, 2010 Internet Systems Consortium, Inc. ("ISC")
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for any
  5. * purpose with or without fee is hereby granted, provided that the above
  6. * copyright notice and this permission notice appear in all copies.
  7. *
  8. * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  9. * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  10. * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  11. * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  12. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  13. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  14. * PERFORMANCE OF THIS SOFTWARE.
  15. */
  16. /* $Id: mem_api.c,v 1.8 2010/08/12 21:30:26 jinmei Exp $ */
  17. #include <config.h>
  18. #include <isc/magic.h>
  19. #include <isc/mem.h>
  20. #include <isc/once.h>
  21. #include <isc/util.h>
  22. #if ISC_MEM_TRACKLINES
  23. #define FLARG_PASS , file, line
  24. #define FLARG , const char *file, unsigned int line
  25. #else
  26. #define FLARG_PASS
  27. #define FLARG
  28. #endif
  29. static isc_mutex_t createlock;
  30. static isc_once_t once = ISC_ONCE_INIT;
  31. static isc_memcreatefunc_t mem_createfunc = NULL;
  32. static void
  33. initialize(void) {
  34. RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
  35. }
  36. isc_result_t
  37. isc_mem_register(isc_memcreatefunc_t createfunc) {
  38. isc_result_t result = ISC_R_SUCCESS;
  39. RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
  40. LOCK(&createlock);
  41. if (mem_createfunc == NULL)
  42. mem_createfunc = createfunc;
  43. else
  44. result = ISC_R_EXISTS;
  45. UNLOCK(&createlock);
  46. return (result);
  47. }
  48. isc_result_t
  49. isc_mem_create(size_t init_max_size, size_t target_size, isc_mem_t **mctxp) {
  50. isc_result_t result;
  51. LOCK(&createlock);
  52. REQUIRE(mem_createfunc != NULL);
  53. result = (*mem_createfunc)(init_max_size, target_size, mctxp,
  54. ISC_MEMFLAG_DEFAULT);
  55. UNLOCK(&createlock);
  56. return (result);
  57. }
  58. isc_result_t
  59. isc_mem_create2(size_t init_max_size, size_t target_size, isc_mem_t **mctxp,
  60. unsigned int flags)
  61. {
  62. isc_result_t result;
  63. LOCK(&createlock);
  64. REQUIRE(mem_createfunc != NULL);
  65. result = (*mem_createfunc)(init_max_size, target_size, mctxp, flags);
  66. UNLOCK(&createlock);
  67. return (result);
  68. }
  69. void
  70. isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
  71. REQUIRE(ISCAPI_MCTX_VALID(source));
  72. REQUIRE(targetp != NULL && *targetp == NULL);
  73. source->methods->attach(source, targetp);
  74. ENSURE(*targetp == source);
  75. }
  76. void
  77. isc_mem_detach(isc_mem_t **mctxp) {
  78. REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
  79. (*mctxp)->methods->detach(mctxp);
  80. ENSURE(*mctxp == NULL);
  81. }
  82. void
  83. isc_mem_destroy(isc_mem_t **mctxp) {
  84. REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
  85. (*mctxp)->methods->destroy(mctxp);
  86. ENSURE(*mctxp == NULL);
  87. }
  88. void *
  89. isc__mem_get(isc_mem_t *mctx, size_t size FLARG) {
  90. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  91. return (mctx->methods->memget(mctx, size FLARG_PASS));
  92. }
  93. void
  94. isc__mem_put(isc_mem_t *mctx, void *ptr, size_t size FLARG) {
  95. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  96. mctx->methods->memput(mctx, ptr, size FLARG_PASS);
  97. }
  98. void
  99. isc__mem_putanddetach(isc_mem_t **mctxp, void *ptr, size_t size FLARG) {
  100. REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
  101. (*mctxp)->methods->memputanddetach(mctxp, ptr, size FLARG_PASS);
  102. /*
  103. * XXX: We cannot always ensure *mctxp == NULL here
  104. * (see lib/isc/mem.c).
  105. */
  106. }
  107. void *
  108. isc__mem_allocate(isc_mem_t *mctx, size_t size FLARG) {
  109. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  110. return (mctx->methods->memallocate(mctx, size FLARG_PASS));
  111. }
  112. void *
  113. isc__mem_reallocate(isc_mem_t *mctx, void *ptr, size_t size FLARG) {
  114. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  115. return (mctx->methods->memreallocate(mctx, ptr, size FLARG_PASS));
  116. }
  117. char *
  118. isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) {
  119. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  120. return (mctx->methods->memstrdup(mctx, s FLARG_PASS));
  121. }
  122. void
  123. isc__mem_free(isc_mem_t *mctx, void *ptr FLARG) {
  124. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  125. mctx->methods->memfree(mctx, ptr FLARG_PASS);
  126. }
  127. void
  128. isc_mem_setdestroycheck(isc_mem_t *mctx, isc_boolean_t flag) {
  129. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  130. mctx->methods->setdestroycheck(mctx, flag);
  131. }
  132. void
  133. isc_mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
  134. size_t hiwater, size_t lowater)
  135. {
  136. REQUIRE(ISCAPI_MCTX_VALID(ctx));
  137. ctx->methods->setwater(ctx, water, water_arg, hiwater, lowater);
  138. }
  139. void
  140. isc_mem_waterack(isc_mem_t *ctx, int flag) {
  141. REQUIRE(ISCAPI_MCTX_VALID(ctx));
  142. ctx->methods->waterack(ctx, flag);
  143. }
  144. size_t
  145. isc_mem_inuse(isc_mem_t *mctx) {
  146. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  147. return (mctx->methods->inuse(mctx));
  148. }
  149. isc_boolean_t
  150. isc_mem_isovermem(isc_mem_t *mctx) {
  151. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  152. return (mctx->methods->isovermem(mctx));
  153. }
  154. void
  155. isc_mem_setname(isc_mem_t *mctx, const char *name, void *tag) {
  156. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  157. UNUSED(name);
  158. UNUSED(tag);
  159. return;
  160. }
  161. const char *
  162. isc_mem_getname(isc_mem_t *mctx) {
  163. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  164. return ("");
  165. }
  166. void *
  167. isc_mem_gettag(isc_mem_t *mctx) {
  168. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  169. return (NULL);
  170. }
  171. isc_result_t
  172. isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) {
  173. REQUIRE(ISCAPI_MCTX_VALID(mctx));
  174. return (mctx->methods->mpcreate(mctx, size, mpctxp));
  175. }
  176. void
  177. isc_mempool_destroy(isc_mempool_t **mpctxp) {
  178. REQUIRE(mpctxp != NULL && ISCAPI_MPOOL_VALID(*mpctxp));
  179. (*mpctxp)->methods->destroy(mpctxp);
  180. ENSURE(*mpctxp == NULL);
  181. }
  182. void *
  183. isc__mempool_get(isc_mempool_t *mpctx FLARG) {
  184. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  185. return (mpctx->methods->get(mpctx FLARG_PASS));
  186. }
  187. void
  188. isc__mempool_put(isc_mempool_t *mpctx, void *mem FLARG) {
  189. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  190. mpctx->methods->put(mpctx, mem FLARG_PASS);
  191. }
  192. unsigned int
  193. isc_mempool_getallocated(isc_mempool_t *mpctx) {
  194. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  195. return (mpctx->methods->getallocated(mpctx));
  196. }
  197. void
  198. isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit) {
  199. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  200. mpctx->methods->setmaxalloc(mpctx, limit);
  201. }
  202. void
  203. isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit) {
  204. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  205. mpctx->methods->setfreemax(mpctx, limit);
  206. }
  207. void
  208. isc_mempool_setname(isc_mempool_t *mpctx, const char *name) {
  209. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  210. mpctx->methods->setname(mpctx, name);
  211. }
  212. void
  213. isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock) {
  214. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  215. mpctx->methods->associatelock(mpctx, lock);
  216. }
  217. void
  218. isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit) {
  219. REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
  220. mpctx->methods->setfillcount(mpctx, limit);
  221. }