argc--;
argv++;
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS)
fatal("dns_lib_init failed: %d", result);
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
- isc__socketmgr_maxudp(named_g_socketmgr, maxudp);
+ isc_socketmgr_maxudp(named_g_socketmgr, maxudp);
result = isc_socketmgr_getmaxsockets(named_g_socketmgr, &socks);
if (result == ISC_R_SUCCESS) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
"less than 128 UDP sockets available after "
"applying 'reserved-sockets' and 'maxsockets'");
}
- isc__socketmgr_setreserved(named_g_socketmgr, reserved);
+ isc_socketmgr_setreserved(named_g_socketmgr, reserved);
#ifdef HAVE_GEOIP
/*
* access to named's global namespace, in which case we need
* to initialize libisc/libdns
*/
- if (dctx->refvar != &isc_bind9) {
- isc_lib_register();
- isc_log_setcontext(dctx->lctx);
- dns_log_setcontext(dctx->lctx);
- }
+ isc_log_setcontext(dctx->lctx);
+ dns_log_setcontext(dctx->lctx);
isc_hash_set_initializer(dctx->hashinit);
dctx->timermgr = tmgr;
dctx->hashinit = hashinit;
dctx->lctx = lctx;
- dctx->refvar = &isc_bind9;
isc_mem_attach(mctx, &dctx->mctx);
dctx->magic = DNS_DYNDBCTX_MAGIC;
void *ptr;
INSIST(dst__memory_pool != NULL);
- ptr = isc__mem_allocate(dst__memory_pool, size FLARG_PASS);
+ ptr = _isc_mem_allocate(dst__memory_pool, size FLARG_PASS);
return (ptr);
#else
INSIST(dst__memory_pool != NULL);
- return (isc__mem_allocate(dst__memory_pool, size FLARG_PASS));
+ return (_isc_mem_allocate(dst__memory_pool, size FLARG_PASS));
#endif
}
static void
mem_free(void *ptr FLARG) {
INSIST(dst__memory_pool != NULL);
- if (ptr != NULL)
- isc__mem_free(dst__memory_pool, ptr FLARG_PASS);
+ if (ptr != NULL) {
+ _isc_mem_free(dst__memory_pool, ptr FLARG_PASS);
+ }
}
static void *
void *rptr;
INSIST(dst__memory_pool != NULL);
- rptr = isc__mem_reallocate(dst__memory_pool, ptr, size FLARG_PASS);
+ rptr = _isc_mem_reallocate(dst__memory_pool, ptr, size FLARG_PASS);
return (rptr);
#else
INSIST(dst__memory_pool != NULL);
- return (isc__mem_reallocate(dst__memory_pool, ptr, size FLARG_PASS));
+ return (_isc_mem_reallocate(dst__memory_pool, ptr, size FLARG_PASS));
#endif
}
goto cleanup_name;
view->zonetable = NULL;
- if (isc_bind9) {
- result = dns_zt_create(mctx, rdclass, &view->zonetable);
- if (result != ISC_R_SUCCESS) {
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "dns_zt_create() failed: %s",
- isc_result_totext(result));
- result = ISC_R_UNEXPECTED;
- goto cleanup_mutex;
- }
+ result = dns_zt_create(mctx, rdclass, &view->zonetable);
+ if (result != ISC_R_SUCCESS) {
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "dns_zt_create() failed: %s",
+ isc_result_totext(result));
+ result = ISC_R_UNEXPECTED;
+ goto cleanup_mutex;
}
view->secroots_priv = NULL;
view->ntatable_priv = NULL;
if (result != ISC_R_SUCCESS)
goto cleanup_dynkeys;
- if (isc_bind9) {
- result = dns_order_create(view->mctx, &view->order);
- if (result != ISC_R_SUCCESS)
- goto cleanup_new_zone_lock;
+ result = dns_order_create(view->mctx, &view->order);
+ if (result != ISC_R_SUCCESS) {
+ goto cleanup_new_zone_lock;
}
result = dns_peerlist_new(view->mctx, &view->peers);
irs_dnsconf_dnskeylist_t *trustedkeys;
irs_dnsconf_dnskey_t *trustedkey;
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS)
return (result);
# Alphabetically
OBJS = @ISC_EXTRA_OBJS@ @ISC_PK11_O@ @ISC_PK11_RESULT_O@ \
aes.@O@ assertions.@O@ backtrace.@O@ base32.@O@ base64.@O@ \
- bind9.@O@ buffer.@O@ bufferlist.@O@ \
+ buffer.@O@ bufferlist.@O@ \
commandline.@O@ counter.@O@ crc64.@O@ error.@O@ entropy.@O@ \
event.@O@ hash.@O@ ht.@O@ heap.@O@ hex.@O@ hmacmd5.@O@ \
hmacsha.@O@ httpd.@O@ iterated_hash.@O@ \
# Alphabetically
SRCS = @ISC_EXTRA_SRCS@ @ISC_PK11_C@ @ISC_PK11_RESULT_C@ \
- aes.c assertions.c backtrace.c base32.c base64.c bind9.c \
+ aes.c assertions.c backtrace.c base32.c base64.c \
buffer.c bufferlist.c commandline.c counter.c crc64.c \
entropy.c error.c event.c hash.c ht.c heap.c hex.c hmacmd5.c \
hmacsha.c httpd.c iterated_hash.c \
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#include <config.h>
-
-#include <unistd.h>
-
-#include <isc/app.h>
-#include <isc/magic.h>
-#include <isc/mutex.h>
-#include <isc/once.h>
-#include <isc/util.h>
-
-static isc_mutex_t createlock;
-static isc_once_t once = ISC_ONCE_INIT;
-static isc_appctxcreatefunc_t appctx_createfunc = NULL;
-static isc_boolean_t is_running = ISC_FALSE;
-
-#define ISCAPI_APPMETHODS_VALID(m) ISC_MAGIC_VALID(m, ISCAPI_APPMETHODS_MAGIC)
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
-}
-
-isc_result_t
-isc_app_register(isc_appctxcreatefunc_t createfunc) {
- isc_result_t result = ISC_R_SUCCESS;
-
- RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
-
- LOCK(&createlock);
- if (appctx_createfunc == NULL)
- appctx_createfunc = createfunc;
- else
- result = ISC_R_EXISTS;
- UNLOCK(&createlock);
-
- return (result);
-}
-
-isc_result_t
-isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__appctx_create(mctx, ctxp));
-
- LOCK(&createlock);
-
- REQUIRE(appctx_createfunc != NULL);
- result = (*appctx_createfunc)(mctx, ctxp);
-
- UNLOCK(&createlock);
-
- return (result);
-}
-
-void
-isc_appctx_destroy(isc_appctx_t **ctxp) {
- REQUIRE(ctxp != NULL && ISCAPI_APPCTX_VALID(*ctxp));
-
- if (isc_bind9)
- isc__appctx_destroy(ctxp);
- else
- (*ctxp)->methods->ctxdestroy(ctxp);
-
- ENSURE(*ctxp == NULL);
-}
-
-isc_result_t
-isc_app_ctxstart(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- if (isc_bind9)
- return (isc__app_ctxstart(ctx));
-
- return (ctx->methods->ctxstart(ctx));
-}
-
-isc_result_t
-isc_app_ctxrun(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- if (isc_bind9)
- return (isc__app_ctxrun(ctx));
-
- return (ctx->methods->ctxrun(ctx));
-}
-
-isc_result_t
-isc_app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx,
- isc_task_t *task, isc_taskaction_t action,
- void *arg)
-{
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- if (isc_bind9)
- return (isc__app_ctxonrun(ctx, mctx, task, action, arg));
-
- return (ctx->methods->ctxonrun(ctx, mctx, task, action, arg));
-}
-
-isc_result_t
-isc_app_ctxsuspend(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- if (isc_bind9)
- return (isc__app_ctxsuspend(ctx));
-
- return (ctx->methods->ctxsuspend(ctx));
-}
-
-isc_result_t
-isc_app_ctxshutdown(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- if (isc_bind9)
- return (isc__app_ctxshutdown(ctx));
-
- return (ctx->methods->ctxshutdown(ctx));
-}
-
-void
-isc_app_ctxfinish(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- if (isc_bind9)
- isc__app_ctxfinish(ctx);
-
- ctx->methods->ctxfinish(ctx);
-}
-
-void
-isc_appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- REQUIRE(taskmgr != NULL);
-
- if (isc_bind9)
- isc__appctx_settaskmgr(ctx, taskmgr);
-
- ctx->methods->settaskmgr(ctx, taskmgr);
-}
-
-void
-isc_appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- REQUIRE(socketmgr != NULL);
-
- if (isc_bind9)
- isc__appctx_setsocketmgr(ctx, socketmgr);
-
- ctx->methods->setsocketmgr(ctx, socketmgr);
-}
-
-void
-isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- REQUIRE(timermgr != NULL);
-
- if (isc_bind9)
- isc__appctx_settimermgr(ctx, timermgr);
-
- ctx->methods->settimermgr(ctx, timermgr);
-}
-
-isc_result_t
-isc_app_start(void) {
- if (isc_bind9)
- return (isc__app_start());
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-isc_result_t
-isc_app_onrun(isc_mem_t *mctx, isc_task_t *task,
- isc_taskaction_t action, void *arg)
-{
- if (isc_bind9)
- return (isc__app_onrun(mctx, task, action, arg));
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-isc_result_t
-isc_app_run() {
- if (isc_bind9) {
- isc_result_t result;
-
- is_running = ISC_TRUE;
- result = isc__app_run();
- is_running = ISC_FALSE;
-
- return (result);
- }
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-isc_boolean_t
-isc_app_isrunning() {
- return (is_running);
-}
-
-isc_result_t
-isc_app_shutdown(void) {
- if (isc_bind9)
- return (isc__app_shutdown());
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-isc_result_t
-isc_app_reload(void) {
- if (isc_bind9)
- return (isc__app_reload());
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-void
-isc_app_finish(void) {
- if (!isc_bind9)
- return;
-
- isc__app_finish();
-}
-
-void
-isc_app_block(void) {
- if (!isc_bind9)
- return;
-
- isc__app_block();
-}
-
-void
-isc_app_unblock(void) {
- if (!isc_bind9)
- return;
-
- isc__app_unblock();
-}
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-/*! \file */
-
-#include <config.h>
-
-#include <isc/bind9.h>
-
-/*
- * This determines whether we are using the libisc/libdns libraries
- * in BIND9 or in some other application. It is initialized to ISC_TRUE
- * and remains unchanged for BIND9 and related tools; export library
- * clients will run isc_lib_register(), which sets it to ISC_FALSE,
- * overriding certain BIND9 behaviors.
- */
-LIBISC_EXTERNAL_DATA isc_boolean_t isc_bind9 = ISC_TRUE;
#define ISC_APPEVENT_SHUTDOWN (ISC_EVENTCLASS_APP + 1)
#define ISC_APPEVENT_LASTEVENT (ISC_EVENTCLASS_APP + 65535)
-/*%
- * app module methods. Only app driver implementations use this structure.
- * Other clients should use the top-level interfaces (i.e., isc_app_xxx
- * functions). magic must be ISCAPI_APPMETHODS_MAGIC.
- */
-typedef struct isc_appmethods {
- void (*ctxdestroy)(isc_appctx_t **ctxp);
- isc_result_t (*ctxstart)(isc_appctx_t *ctx);
- isc_result_t (*ctxrun)(isc_appctx_t *ctx);
- isc_result_t (*ctxsuspend)(isc_appctx_t *ctx);
- isc_result_t (*ctxshutdown)(isc_appctx_t *ctx);
- void (*ctxfinish)(isc_appctx_t *ctx);
- void (*settaskmgr)(isc_appctx_t *ctx,
- isc_taskmgr_t *timermgr);
- void (*setsocketmgr)(isc_appctx_t *ctx,
- isc_socketmgr_t *timermgr);
- void (*settimermgr)(isc_appctx_t *ctx,
- isc_timermgr_t *timermgr);
- isc_result_t (*ctxonrun)(isc_appctx_t *ctx, isc_mem_t *mctx,
- isc_task_t *task, isc_taskaction_t action,
- void *arg);
-} isc_appmethods_t;
-
/*%
* This structure is actually just the common prefix of an application context
* implementation's version of an isc_appctx_t.
* of the isc_app_ routines to work. app implementations must maintain
* all app context invariants.
*/
-struct isc_appctx {
- unsigned int impmagic;
- unsigned int magic;
- isc_appmethods_t *methods;
-};
+struct isc_appctx;
#define ISCAPI_APPCTX_MAGIC ISC_MAGIC('A','a','p','c')
#define ISCAPI_APPCTX_VALID(c) ((c) != NULL && \
- (c)->magic == ISCAPI_APPCTX_MAGIC)
+ isc_appctx_magic(c) == ISCAPI_APPCTX_MAGIC)
ISC_LANG_BEGINDECLS
+unsigned int
+isc_appctx_magic(isc_appctx_t *ctx);
+
isc_result_t
isc_app_ctxstart(isc_appctx_t *ctx);
*\li 'timermgr' is a valid timer manager.
*/
-/*%<
- * See isc_appctx_create() above.
- */
-typedef isc_result_t
-(*isc_appctxcreatefunc_t)(isc_mem_t *mctx, isc_appctx_t **ctxp);
-
-isc_result_t
-isc_app_register(isc_appctxcreatefunc_t createfunc);
-/*%<
- * Register a new application implementation and add it to the list of
- * supported implementations. This function must be called when a different
- * event library is used than the one contained in the ISC library.
- */
-
-isc_result_t
-isc__app_register(void);
-/*%<
- * A short cut function that specifies the application module in the ISC
- * library for isc_app_register(). An application that uses the ISC library
- * usually do not have to care about this function: it would call
- * isc_lib_register(), which internally calls this function.
- */
-
ISC_LANG_ENDDECLS
#endif /* ISC_APP_H */
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#ifndef ISC_BIND9_H
-#define ISC_BIND9_H 1
-
-#include <isc/boolean.h>
-#include <isc/platform.h>
-
-/*
- * This determines whether we are using the libisc/libdns libraries
- * in BIND9 or in some other application. For BIND9 (named and related
- * tools) it must be set to ISC_TRUE at runtime. Export library clients
- * will call isc_lib_register(), which will set it to ISC_FALSE.
- */
-LIBISC_EXTERNAL_DATA extern isc_boolean_t isc_bind9;
-
-#endif /* ISC_BIND9_H */
* has not already been initialized.
*/
-void
-isc_lib_register(void);
-/*!<
- * \brief Register the ISC library implementations for some base services
- * such as memory or event management and handling socket or timer events.
- * An external application that wants to use the ISC library must call this
- * function very early in main().
- */
-
ISC_LANG_ENDDECLS
#endif /* ISC_LIB_H */
#define ISC_MEMFLAG_DEFAULT ISC_MEMFLAG_INTERNAL|ISC_MEMFLAG_FILL
#endif
-
-/*%<
- * We use either isc___mem (three underscores) or isc__mem (two) depending on
- * whether it's for BIND9's internal purpose (with -DBIND9) or generic export
- * library.
- */
-#define ISCMEMFUNC(sfx) isc__mem_ ## sfx
-#define ISCMEMPOOLFUNC(sfx) isc__mempool_ ## sfx
-
-#define isc_mem_get(c, s) ISCMEMFUNC(get)((c), (s) _ISC_MEM_FILELINE)
-#define isc_mem_allocate(c, s) ISCMEMFUNC(allocate)((c), (s) _ISC_MEM_FILELINE)
-#define isc_mem_reallocate(c, p, s) ISCMEMFUNC(reallocate)((c), (p), (s) _ISC_MEM_FILELINE)
-#define isc_mem_strdup(c, p) ISCMEMFUNC(strdup)((c), (p) _ISC_MEM_FILELINE)
-#define isc_mempool_get(c) ISCMEMPOOLFUNC(get)((c) _ISC_MEM_FILELINE)
-
/*%
* isc_mem_putanddetach() is a convenience function for use where you
* have a structure with an attached memory context.
* \endcode
*/
-/*% memory and memory pool methods */
-typedef struct isc_memmethods {
- void (*attach)(isc_mem_t *source, isc_mem_t **targetp);
- void (*detach)(isc_mem_t **mctxp);
- void (*destroy)(isc_mem_t **mctxp);
- void *(*memget)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
- void (*memput)(isc_mem_t *mctx, void *ptr, size_t size _ISC_MEM_FLARG);
- void (*memputanddetach)(isc_mem_t **mctxp, void *ptr,
- size_t size _ISC_MEM_FLARG);
- void *(*memallocate)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
- void *(*memreallocate)(isc_mem_t *mctx, void *ptr,
- size_t size _ISC_MEM_FLARG);
- char *(*memstrdup)(isc_mem_t *mctx, const char *s _ISC_MEM_FLARG);
- void (*memfree)(isc_mem_t *mctx, void *ptr _ISC_MEM_FLARG);
- void (*setdestroycheck)(isc_mem_t *mctx, isc_boolean_t flag);
- void (*setwater)(isc_mem_t *ctx, isc_mem_water_t water,
- void *water_arg, size_t hiwater, size_t lowater);
- void (*waterack)(isc_mem_t *ctx, int flag);
- size_t (*inuse)(isc_mem_t *mctx);
- size_t (*maxinuse)(isc_mem_t *mctx);
- size_t (*total)(isc_mem_t *mctx);
- isc_boolean_t (*isovermem)(isc_mem_t *mctx);
- isc_result_t (*mpcreate)(isc_mem_t *mctx, size_t size,
- isc_mempool_t **mpctxp);
-} isc_memmethods_t;
-
-typedef struct isc_mempoolmethods {
- void (*destroy)(isc_mempool_t **mpctxp);
- void *(*get)(isc_mempool_t *mpctx _ISC_MEM_FLARG);
- void (*put)(isc_mempool_t *mpctx, void *mem _ISC_MEM_FLARG);
- unsigned int (*getallocated)(isc_mempool_t *mpctx);
- void (*setmaxalloc)(isc_mempool_t *mpctx, unsigned int limit);
- void (*setfreemax)(isc_mempool_t *mpctx, unsigned int limit);
- void (*setname)(isc_mempool_t *mpctx, const char *name);
- void (*associatelock)(isc_mempool_t *mpctx, isc_mutex_t *lock);
- void (*setfillcount)(isc_mempool_t *mpctx, unsigned int limit);
-} isc_mempoolmethods_t;
-
/*%
* This structure is actually just the common prefix of a memory context
* implementation's version of an isc_mem_t.
* isc_mem_ routines to work. mctx implementations must maintain all mctx
* invariants.
*/
-struct isc_mem {
- unsigned int impmagic;
- unsigned int magic;
- isc_memmethods_t *methods;
-};
+struct isc_mem;
#define ISCAPI_MCTX_MAGIC ISC_MAGIC('A','m','c','x')
#define ISCAPI_MCTX_VALID(m) ((m) != NULL && \
* This is the common prefix of a memory pool context. The same note as
* that for the mem structure applies.
*/
-struct isc_mempool {
- unsigned int impmagic;
- unsigned int magic;
- isc_mempoolmethods_t *methods;
-};
+struct isc_mempool;
#define ISCAPI_MPOOL_MAGIC ISC_MAGIC('A','m','p','l')
#define ISCAPI_MPOOL_VALID(mp) ((mp) != NULL && \
(mp)->magic == ISCAPI_MPOOL_MAGIC)
-#define isc_mem_put(c, p, s) \
- do { \
- ISCMEMFUNC(put)((c), (p), (s) _ISC_MEM_FILELINE); \
- (p) = NULL; \
- } while (0)
-#define isc_mem_putanddetach(c, p, s) \
- do { \
- ISCMEMFUNC(putanddetach)((c), (p), (s) _ISC_MEM_FILELINE); \
- (p) = NULL; \
- } while (0)
-#define isc_mem_free(c, p) \
- do { \
- ISCMEMFUNC(free)((c), (p) _ISC_MEM_FILELINE); \
- (p) = NULL; \
- } while (0)
-#define isc_mempool_put(c, p) \
- do { \
- ISCMEMPOOLFUNC(put)((c), (p) _ISC_MEM_FILELINE); \
- (p) = NULL; \
- } while (0)
-
/*@{*/
isc_result_t
isc_mem_create(size_t max_size, size_t target_size,
/*
* Pseudo-private functions for use via macros. Do not call directly.
*/
+#define isc_mem_get(...) _isc_mem_get(__VA_ARGS__ _ISC_MEM_FILELINE)
void *
-ISCMEMFUNC(get)(isc_mem_t *, size_t _ISC_MEM_FLARG);
+_isc_mem_get(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
+#define isc_mem_putanddetach(...) _isc_mem_putanddetach(__VA_ARGS__ _ISC_MEM_FILELINE)
void
-ISCMEMFUNC(putanddetach)(isc_mem_t **, void *, size_t _ISC_MEM_FLARG);
+_isc_mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size _ISC_MEM_FLARG);
+#define isc_mem_put(...) _isc_mem_put(__VA_ARGS__ _ISC_MEM_FILELINE)
void
-ISCMEMFUNC(put)(isc_mem_t *, void *, size_t _ISC_MEM_FLARG);
+_isc_mem_put(isc_mem_t *mctx, void *ptr, size_t size _ISC_MEM_FLARG);
+#define isc_mem_allocate(...) _isc_mem_allocate(__VA_ARGS__ _ISC_MEM_FILELINE)
void *
-ISCMEMFUNC(allocate)(isc_mem_t *, size_t _ISC_MEM_FLARG);
+_isc_mem_allocate(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
+#define isc_mem_reallocate(...) _isc_mem_reallocate(__VA_ARGS__ _ISC_MEM_FILELINE)
void *
-ISCMEMFUNC(reallocate)(isc_mem_t *, void *, size_t _ISC_MEM_FLARG);
+_isc_mem_reallocate(isc_mem_t *mctx, void *ptr, size_t size _ISC_MEM_FLARG);
+#define isc_mem_free(...) _isc_mem_free(__VA_ARGS__ _ISC_MEM_FILELINE)
void
-ISCMEMFUNC(free)(isc_mem_t *, void * _ISC_MEM_FLARG);
+_isc_mem_free(isc_mem_t *mctx, void *ptr _ISC_MEM_FLARG);
+#define isc_mem_strdup(...) _isc_mem_strdup(__VA_ARGS__ _ISC_MEM_FILELINE)
char *
-ISCMEMFUNC(strdup)(isc_mem_t *, const char *_ISC_MEM_FLARG);
+_isc_mem_strdup(isc_mem_t *mctx, const char *s _ISC_MEM_FLARG);
+#define isc_mempool_get(...) _isc_mempool_get(__VA_ARGS__ _ISC_MEM_FILELINE)
void *
-ISCMEMPOOLFUNC(get)(isc_mempool_t * _ISC_MEM_FLARG);
+_isc_mempool_get(isc_mempool_t *mpctx _ISC_MEM_FLARG);
+#define isc_mempool_put(...) _isc_mempool_put(__VA_ARGS__ _ISC_MEM_FILELINE)
void
-ISCMEMPOOLFUNC(put)(isc_mempool_t *, void * _ISC_MEM_FLARG);
-
-/*%<
- * See isc_mem_create2() above.
- */
-typedef isc_result_t
-(*isc_memcreatefunc_t)(size_t init_max_size, size_t target_size,
- isc_mem_t **ctxp, unsigned int flags);
-
-isc_result_t
-isc_mem_register(isc_memcreatefunc_t createfunc);
-/*%<
- * Register a new memory management implementation and add it to the list of
- * supported implementations. This function must be called when a different
- * memory management library is used than the one contained in the ISC library.
- */
-
-isc_result_t
-isc__mem_register(void);
-/*%<
- * A short cut function that specifies the memory management module in the ISC
- * library for isc_mem_register(). An application that uses the ISC library
- * usually do not have to care about this function: it would call
- * isc_lib_register(), which internally calls this function.
- */
+_isc_mempool_put(isc_mempool_t *mpctx, void *mem _ISC_MEM_FLARG);
void
-isc__mem_printactive(isc_mem_t *mctx, FILE *file);
+isc_mem_printactive(isc_mem_t *mctx, FILE *file);
/*%<
* For internal use by the isc module and its unit tests, these functions
* print lists of active memory blocks for a single memory context or for
#include <isc/types.h>
#include <isc/xml.h>
-#ifdef WIN32
-
-/* from the old namespace.h */
-
-#define isc_socket_create isc__socket_create
-#define isc_socket_dup isc__socket_dup
-#define isc_socket_attach isc__socket_attach
-#define isc_socket_detach isc__socket_detach
-#define isc_socketmgr_create isc__socketmgr_create
-#define isc_socketmgr_create2 isc__socketmgr_create2
-#define isc_socketmgr_destroy isc__socketmgr_destroy
-#define isc_socket_open isc__socket_open
-#define isc_socket_close isc__socket_close
-#define isc_socket_recvv isc__socket_recvv
-#define isc_socket_recv isc__socket_recv
-#define isc_socket_recv2 isc__socket_recv2
-#define isc_socket_send isc__socket_send
-#define isc_socket_sendto isc__socket_sendto
-#define isc_socket_sendv isc__socket_sendv
-#define isc_socket_sendtov isc__socket_sendtov
-#define isc_socket_sendtov2 isc__socket_sendtov2
-#define isc_socket_sendto2 isc__socket_sendto2
-#define isc_socket_cleanunix isc__socket_cleanunix
-#define isc_socket_permunix isc__socket_permunix
-#define isc_socket_bind isc__socket_bind
-#define isc_socket_filter isc__socket_filter
-#define isc_socket_listen isc__socket_listen
-#define isc_socket_accept isc__socket_accept
-#define isc_socket_connect isc__socket_connect
-#define isc_socket_getfd isc__socket_getfd
-#define isc_socket_getname isc__socket_getname
-#define isc_socket_gettag isc__socket_gettag
-#define isc_socket_getpeername isc__socket_getpeername
-#define isc_socket_getsockname isc__socket_getsockname
-#define isc_socket_cancel isc__socket_cancel
-#define isc_socket_gettype isc__socket_gettype
-#define isc_socket_isbound isc__socket_isbound
-#define isc_socket_ipv6only isc__socket_ipv6only
-#define isc_socket_setname isc__socket_setname
-#define isc_socketmgr_getmaxsockets isc__socketmgr_getmaxsockets
-#define isc_socketmgr_setstats isc__socketmgr_setstats
-#define isc_socketmgr_setreserved isc__socketmgr_setreserved
-#define isc__socketmgr_maxudp isc___socketmgr_maxudp
-#define isc_socket_fdwatchcreate isc__socket_fdwatchcreate
-#define isc_socket_fdwatchpoke isc__socket_fdwatchpoke
-#define isc_socket_dscp isc__socket_dscp
-
-#endif
-
ISC_LANG_BEGINDECLS
/***
#define ISC_SOCKFDWATCH_WRITE 0x00000002 /*%< watch for writable */
/*@}*/
-/*% Socket and socket manager methods */
-typedef struct isc_socketmgrmethods {
- void (*destroy)(isc_socketmgr_t **managerp);
- isc_result_t (*socketcreate)(isc_socketmgr_t *manager, int pf,
- isc_sockettype_t type,
- isc_socket_t **socketp);
- isc_result_t (*fdwatchcreate)(isc_socketmgr_t *manager, int fd,
- int flags,
- isc_sockfdwatch_t callback,
- void *cbarg, isc_task_t *task,
- isc_socket_t **socketp);
-} isc_socketmgrmethods_t;
-
-typedef struct isc_socketmethods {
- void (*attach)(isc_socket_t *socket,
- isc_socket_t **socketp);
- void (*detach)(isc_socket_t **socketp);
- isc_result_t (*bind)(isc_socket_t *sock,
- const isc_sockaddr_t *sockaddr,
- unsigned int options);
- isc_result_t (*sendto)(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task, isc_taskaction_t action,
- void *arg,
- const isc_sockaddr_t *address,
- struct in6_pktinfo *pktinfo);
- isc_result_t (*sendto2)(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task,
- const isc_sockaddr_t *address,
- struct in6_pktinfo *pktinfo,
- isc_socketevent_t *event,
- unsigned int flags);
- isc_result_t (*connect)(isc_socket_t *sock,
- const isc_sockaddr_t *addr,
- isc_task_t *task, isc_taskaction_t action,
- void *arg);
- isc_result_t (*recv)(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_taskaction_t action, void *arg);
- isc_result_t (*recv2)(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_socketevent_t *event, unsigned int flags);
- void (*cancel)(isc_socket_t *sock, isc_task_t *task,
- unsigned int how);
- isc_result_t (*getsockname)(isc_socket_t *sock,
- isc_sockaddr_t *addressp);
- isc_sockettype_t (*gettype)(isc_socket_t *sock);
- void (*ipv6only)(isc_socket_t *sock, isc_boolean_t yes);
- isc_result_t (*fdwatchpoke)(isc_socket_t *sock, int flags);
- isc_result_t (*dup)(isc_socket_t *socket,
- isc_socket_t **socketp);
- int (*getfd)(isc_socket_t *socket);
- void (*dscp)(isc_socket_t *socket, isc_dscp_t dscp);
-} isc_socketmethods_t;
-
-/*%
- * This structure is actually just the common prefix of a socket manager
- * object implementation's version of an isc_socketmgr_t.
- * \brief
- * Direct use of this structure by clients is forbidden. socket implementations
- * may change the structure. 'magic' must be ISCAPI_SOCKETMGR_MAGIC for any
- * of the isc_socket_ routines to work. socket implementations must maintain
- * all socket invariants.
- * In effect, this definition is used only for non-BIND9 version ("export")
- * of the library, and the export version does not work for win32. So, to avoid
- * the definition conflict with win32/socket.c, we enable this definition only
- * for non-Win32 (i.e. Unix) platforms.
- */
-#ifndef WIN32
-struct isc_socketmgr {
- unsigned int impmagic;
- unsigned int magic;
- isc_socketmgrmethods_t *methods;
-};
-#endif
+struct isc_socketmgr;
#define ISCAPI_SOCKETMGR_MAGIC ISC_MAGIC('A','s','m','g')
#define ISCAPI_SOCKETMGR_VALID(m) ((m) != NULL && \
- (m)->magic == ISCAPI_SOCKETMGR_MAGIC)
+ isc_socketmgr_magic(m) == ISCAPI_SOCKETMGR_MAGIC)
-/*%
- * This is the common prefix of a socket object. The same note as
- * that for the socketmgr structure applies.
- */
-#ifndef WIN32
-struct isc_socket {
- unsigned int impmagic;
- unsigned int magic;
- isc_socketmethods_t *methods;
-};
-#endif
+unsigned int
+isc_socketmgr_magic(isc_socketmgr_t *manager);
+
+struct isc_socket;
#define ISCAPI_SOCKET_MAGIC ISC_MAGIC('A','s','c','t')
#define ISCAPI_SOCKET_VALID(s) ((s) != NULL && \
- (s)->magic == ISCAPI_SOCKET_MAGIC)
+ isc_socket_magic(s) == ISCAPI_SOCKET_MAGIC)
+
+unsigned int
+isc_socket_magic(isc_socket_t *sock);
/***
*** Socket and Socket Manager Functions
*/
void
-isc__socketmgr_setreserved(isc_socketmgr_t *mgr, isc_uint32_t);
+isc_socketmgr_setreserved(isc_socketmgr_t *mgr, isc_uint32_t);
/*%<
* Temporary. For use by named only.
*/
void
-isc__socketmgr_maxudp(isc_socketmgr_t *mgr, int maxudp);
+isc_socketmgr_maxudp(isc_socketmgr_t *mgr, int maxudp);
/*%<
* Test interface. Drop UDP packet > 'maxudp'.
*/
*/
#endif /* HAVE_JSON */
-/*%<
- * See isc_socketmgr_create() above.
- */
-typedef isc_result_t
-(*isc_socketmgrcreatefunc_t)(isc_mem_t *mctx, isc_socketmgr_t **managerp);
-
-isc_result_t
-isc_socket_register(isc_socketmgrcreatefunc_t createfunc);
-/*%<
- * Register a new socket I/O implementation and add it to the list of
- * supported implementations. This function must be called when a different
- * event library is used than the one contained in the ISC library.
- */
-
-isc_result_t
-isc__socket_register(void);
-/*%<
- * A short cut function that specifies the socket I/O module in the ISC
- * library for isc_socket_register(). An application that uses the ISC library
- * usually do not have to care about this function: it would call
- * isc_lib_register(), which internally calls this function.
- */
-
ISC_LANG_ENDDECLS
#endif /* ISC_SOCKET_H */
* of the isc_task_ routines to work. task implementations must maintain
* all task invariants.
*/
-struct isc_taskmgr {
- unsigned int impmagic;
- unsigned int magic;
- isc_taskmgrmethods_t *methods;
-};
+struct isc_taskmgr;
#define ISCAPI_TASKMGR_MAGIC ISC_MAGIC('A','t','m','g')
#define ISCAPI_TASKMGR_VALID(m) ((m) != NULL && \
- (m)->magic == ISCAPI_TASKMGR_MAGIC)
+ isc_taskmgr_magic(m) == ISCAPI_TASKMGR_MAGIC)
+
+unsigned int
+isc_taskmgr_magic(isc_taskmgr_t *manager);
/*%
* This is the common prefix of a task object. The same note as
* that for the taskmgr structure applies.
*/
-struct isc_task {
- unsigned int impmagic;
- unsigned int magic;
- isc_taskmethods_t *methods;
-};
+struct isc_task;
#define ISCAPI_TASK_MAGIC ISC_MAGIC('A','t','s','t')
#define ISCAPI_TASK_VALID(s) ((s) != NULL && \
- (s)->magic == ISCAPI_TASK_MAGIC)
+ isc_task_magic(s) == ISCAPI_TASK_MAGIC)
+
+unsigned int
+isc_task_magic(isc_task_t *task);
isc_result_t
isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
* event library is used than the one contained in the ISC library.
*/
-isc_result_t
-isc__task_register(void);
-/*%<
- * A short cut function that specifies the task management module in the ISC
- * library for isc_task_register(). An application that uses the ISC library
- * usually do not have to care about this function: it would call
- * isc_lib_register(), which internally calls this function.
- */
-
/*%<
* These functions allow unit tests to manipulate the processing
* of the task queue. They are not intended as part of the public API.
*/
#if defined(ISC_PLATFORM_USETHREADS)
void
-isc__taskmgr_pause(isc_taskmgr_t *taskmgr);
+isc_taskmgr_pause(isc_taskmgr_t *taskmgr);
void
-isc__taskmgr_resume(isc_taskmgr_t *taskmgr);
+isc_taskmgr_resume(isc_taskmgr_t *taskmgr);
#else
isc_boolean_t
-isc__taskmgr_ready(isc_taskmgr_t *taskmgr);
+isc_taskmgr_ready(isc_taskmgr_t *taskmgr);
isc_result_t
-isc__taskmgr_dispatch(isc_taskmgr_t *taskmgr);
+isc_taskmgr_dispatch(isc_taskmgr_t *taskmgr);
#endif /* !ISC_PLATFORM_USETHREADS */
ISC_LANG_ENDDECLS
* of the isc_timer_ routines to work. timer implementations must maintain
* all timer invariants.
*/
-struct isc_timermgr {
- unsigned int impmagic;
- unsigned int magic;
- isc_timermgrmethods_t *methods;
-};
-
+struct isc_timermgr;
#define ISCAPI_TIMERMGR_MAGIC ISC_MAGIC('A','t','m','g')
#define ISCAPI_TIMERMGR_VALID(m) ((m) != NULL && \
(m)->magic == ISCAPI_TIMERMGR_MAGIC)
* This is the common prefix of a timer object. The same note as
* that for the timermgr structure applies.
*/
-struct isc_timer {
- unsigned int impmagic;
- unsigned int magic;
- isc_timermethods_t *methods;
-};
+struct isc_timer;
#define ISCAPI_TIMER_MAGIC ISC_MAGIC('A','t','m','r')
#define ISCAPI_TIMER_VALID(s) ((s) != NULL && \
void isc_timermgr_poke(isc_timermgr_t *m);
-/*%<
- * See isc_timermgr_create() above.
- */
-typedef isc_result_t
-(*isc_timermgrcreatefunc_t)(isc_mem_t *mctx, isc_timermgr_t **managerp);
-
-isc_result_t
-isc__timer_register(void);
-/*%<
- * Register a new timer management implementation and add it to the list of
- * supported implementations. This function must be called when a different
- * event library is used than the one contained in the ISC library.
- */
-
-isc_result_t
-isc_timer_register(isc_timermgrcreatefunc_t createfunc);
-/*%<
- * A short cut function that specifies the timer management module in the ISC
- * library for isc_timer_register(). An application that uses the ISC library
- * usually do not have to care about this function: it would call
- * isc_lib_register(), which internally calls this function.
- */
-
ISC_LANG_ENDDECLS
#endif /* ISC_TIMER_H */
#ifndef ISC_TYPES_H
#define ISC_TYPES_H 1
-#include <isc/bind9.h>
-
/*! \file isc/types.h
* \brief
* OS-specific types, from the OS-specific include directories.
abort();
}
}
-
-static isc_once_t register_once = ISC_ONCE_INIT;
-
-static void
-do_register(void) {
- isc_bind9 = ISC_FALSE;
-
- RUNTIME_CHECK(isc__mem_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__app_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__task_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__socket_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__timer_register() == ISC_R_SUCCESS);
-}
-
-void
-isc_lib_register(void) {
- RUNTIME_CHECK(isc_once_do(®ister_once, do_register)
- == ISC_R_SUCCESS);
-}
#include <limits.h>
-#include <isc/bind9.h>
#include <isc/json.h>
#include <isc/magic.h>
#include <isc/hash.h>
/*
* Types.
*/
-typedef struct isc__mem isc__mem_t;
-typedef struct isc__mempool isc__mempool_t;
#if ISC_MEM_TRACKLINES
typedef struct debuglink debuglink_t;
*/
union {
size_t size;
- isc__mem_t *ctx;
+ isc_mem_t *ctx;
char bytes[ALIGNMENT_SIZE];
} u;
} size_info;
/* List of all active memory contexts. */
-static ISC_LIST(isc__mem_t) contexts;
+static ISC_LIST(isc_mem_t) contexts;
static isc_once_t once = ISC_ONCE_INIT;
static isc_mutex_t contextslock;
-static isc_mutex_t createlock;
/*%
* Total size of lost memory due to a bug of external library.
*/
static isc_uint64_t totallost;
-struct isc__mem {
- isc_mem_t common;
+struct isc_mem {
+ unsigned int impmagic;
+ unsigned int magic;
unsigned int flags;
isc_mutex_t lock;
isc_memalloc_t memalloc;
isc_boolean_t is_overmem;
isc_mem_water_t water;
void * water_arg;
- ISC_LIST(isc__mempool_t) pools;
+ ISC_LIST(isc_mempool_t) pools;
unsigned int poolcnt;
/* ISC_MEMFLAG_INTERNAL */
#endif
unsigned int memalloc_failures;
- ISC_LINK(isc__mem_t) link;
+ ISC_LINK(isc_mem_t) link;
};
#define MEMPOOL_MAGIC ISC_MAGIC('M', 'E', 'M', 'p')
#define VALID_MEMPOOL(c) ISC_MAGIC_VALID(c, MEMPOOL_MAGIC)
-struct isc__mempool {
+struct isc_mempool {
+ unsigned int impmagic;
+ unsigned int magic;
/* always unlocked */
- isc_mempool_t common; /*%< common header of mempool's */
isc_mutex_t *lock; /*%< optional lock */
- isc__mem_t *mctx; /*%< our memory context */
+ isc_mem_t *mctx; /*%< our memory context */
/*%< locked via the memory context's lock */
- ISC_LINK(isc__mempool_t) link; /*%< next pool in this mem context */
+ ISC_LINK(isc_mempool_t) link; /*%< next pool in this mem context */
/*%< optionally locked from here down */
element *items; /*%< low water item list */
size_t size; /*%< size of each item on this pool */
} while(0)
static void
-print_active(isc__mem_t *ctx, FILE *out);
+print_active(isc_mem_t *ctx, FILE *out);
#endif /* ISC_MEM_TRACKLINES */
-/*%
- * The following are intended for internal use (indicated by "isc__"
- * prefix) but are not declared as static, allowing direct access
- * from unit tests, etc.
- */
-
-isc_result_t
-isc__mem_create2(size_t init_max_size, size_t target_size,
- isc_mem_t **ctxp, unsigned int flags);
-void
-isc__mem_attach(isc_mem_t *source, isc_mem_t **targetp);
-void
-isc__mem_detach(isc_mem_t **ctxp);
-void
-isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG);
-void
-isc__mem_destroy(isc_mem_t **ctxp);
-void *
-isc___mem_get(isc_mem_t *ctx, size_t size FLARG);
-void
-isc___mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG);
-void
-isc__mem_stats(isc_mem_t *ctx, FILE *out);
-void *
-isc___mem_allocate(isc_mem_t *ctx, size_t size FLARG);
-void *
-isc___mem_reallocate(isc_mem_t *ctx, void *ptr, size_t size FLARG);
-void
-isc___mem_free(isc_mem_t *ctx, void *ptr FLARG);
-char *
-isc___mem_strdup(isc_mem_t *mctx, const char *s FLARG);
-void
-isc__mem_setdestroycheck(isc_mem_t *ctx, isc_boolean_t flag);
-void
-isc__mem_setquota(isc_mem_t *ctx, size_t quota);
-size_t
-isc__mem_getquota(isc_mem_t *ctx);
-size_t
-isc__mem_inuse(isc_mem_t *ctx);
-size_t
-isc__mem_maxinuse(isc_mem_t *ctx);
-size_t
-isc__mem_total(isc_mem_t *ctx);
-isc_boolean_t
-isc__mem_isovermem(isc_mem_t *ctx);
-void
-isc__mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
- size_t hiwater, size_t lowater);
-void
-isc__mem_waterack(isc_mem_t *ctx0, int flag);
-void
-isc__mem_setname(isc_mem_t *ctx, const char *name, void *tag);
-const char *
-isc__mem_getname(isc_mem_t *ctx);
-void *
-isc__mem_gettag(isc_mem_t *ctx);
-isc_result_t
-isc__mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp);
-void
-isc__mempool_setname(isc_mempool_t *mpctx, const char *name);
-void
-isc__mempool_destroy(isc_mempool_t **mpctxp);
-void
-isc__mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock);
-void *
-isc___mempool_get(isc_mempool_t *mpctx FLARG);
-void
-isc___mempool_put(isc_mempool_t *mpctx, void *mem FLARG);
-void
-isc__mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit);
-unsigned int
-isc__mempool_getfreemax(isc_mempool_t *mpctx);
-unsigned int
-isc__mempool_getfreecount(isc_mempool_t *mpctx);
-void
-isc__mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit);
-unsigned int
-isc__mempool_getmaxalloc(isc_mempool_t *mpctx);
-unsigned int
-isc__mempool_getallocated(isc_mempool_t *mpctx);
-void
-isc__mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit);
-unsigned int
-isc__mempool_getfillcount(isc_mempool_t *mpctx);
-void
-isc__mem_printactive(isc_mem_t *ctx0, FILE *file);
-unsigned int
-isc__mem_references(isc_mem_t *ctx0);
-
-static struct isc__memmethods {
- isc_memmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *createx, *create, *create2, *stats,
- *setquota, *getquota, *setname, *getname, *gettag;
-} memmethods = {
- {
- isc__mem_attach,
- isc__mem_detach,
- isc__mem_destroy,
- isc___mem_get,
- isc___mem_put,
- isc___mem_putanddetach,
- isc___mem_allocate,
- isc___mem_reallocate,
- isc___mem_strdup,
- isc___mem_free,
- isc__mem_setdestroycheck,
- isc__mem_setwater,
- isc__mem_waterack,
- isc__mem_inuse,
- isc__mem_maxinuse,
- isc__mem_total,
- isc__mem_isovermem,
- isc__mempool_create
- },
- (void *)isc_mem_createx,
- (void *)isc_mem_create,
- (void *)isc_mem_create2,
- (void *)isc_mem_stats,
- (void *)isc_mem_setquota,
- (void *)isc_mem_getquota,
- (void *)isc_mem_setname,
- (void *)isc_mem_getname,
- (void *)isc_mem_gettag
-};
-
-static struct isc__mempoolmethods {
- isc_mempoolmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *getfreemax, *getfreecount, *getmaxalloc, *getfillcount;
-} mempoolmethods = {
- {
- isc__mempool_destroy,
- isc___mempool_get,
- isc___mempool_put,
- isc__mempool_getallocated,
- isc__mempool_setmaxalloc,
- isc__mempool_setfreemax,
- isc__mempool_setname,
- isc__mempool_associatelock,
- isc__mempool_setfillcount
- },
- (void *)isc_mempool_getfreemax,
- (void *)isc_mempool_getfreecount,
- (void *)isc_mempool_getmaxalloc,
- (void *)isc_mempool_getfillcount
-};
-
#if ISC_MEM_TRACKLINES
/*!
* mctx must be locked.
*/
static void
-add_trace_entry(isc__mem_t *mctx, const void *ptr, size_t size FLARG) {
+add_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size FLARG) {
debuglink_t *dl;
isc_uint32_t hash;
isc_uint32_t idx;
}
static void
-delete_trace_entry(isc__mem_t *mctx, const void *ptr, size_t size,
+delete_trace_entry(isc_mem_t *mctx, const void *ptr, size_t size,
const char *file, unsigned int line)
{
debuglink_t *dl;
}
static inline isc_boolean_t
-more_basic_blocks(isc__mem_t *ctx) {
+more_basic_blocks(isc_mem_t *ctx) {
void *tmp;
unsigned char *curr, *next;
unsigned char *first, *last;
}
static inline isc_boolean_t
-more_frags(isc__mem_t *ctx, size_t new_size) {
+more_frags(isc_mem_t *ctx, size_t new_size) {
int i, frags;
size_t total_size;
void *tmp;
}
static inline void *
-mem_getunlocked(isc__mem_t *ctx, size_t size) {
+mem_getunlocked(isc_mem_t *ctx, size_t size) {
size_t new_size = quantize(size);
void *ret;
/* coverity[+free : arg-1] */
static inline void
-mem_putunlocked(isc__mem_t *ctx, void *mem, size_t size) {
+mem_putunlocked(isc_mem_t *ctx, void *mem, size_t size) {
size_t new_size = quantize(size);
if (new_size >= ctx->max_size) {
* Perform a malloc, doing memory filling and overrun detection as necessary.
*/
static inline void *
-mem_get(isc__mem_t *ctx, size_t size) {
+mem_get(isc_mem_t *ctx, size_t size) {
char *ret;
#if ISC_MEM_CHECKOVERRUN
*/
/* coverity[+free : arg-1] */
static inline void
-mem_put(isc__mem_t *ctx, void *mem, size_t size) {
+mem_put(isc_mem_t *ctx, void *mem, size_t size) {
#if ISC_MEM_CHECKOVERRUN
INSIST(((unsigned char *)mem)[size] == 0xbe);
size += 1;
* Update internal counters after a memory get.
*/
static inline void
-mem_getstats(isc__mem_t *ctx, size_t size) {
+mem_getstats(isc_mem_t *ctx, size_t size) {
ctx->total += size;
ctx->inuse += size;
* Update internal counters after a memory put.
*/
static inline void
-mem_putstats(isc__mem_t *ctx, void *ptr, size_t size) {
+mem_putstats(isc_mem_t *ctx, void *ptr, size_t size) {
UNUSED(ptr);
INSIST(ctx->inuse >= size);
static void
initialize_action(void) {
- RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_mutex_init(&contextslock) == ISC_R_SUCCESS);
ISC_LIST_INIT(contexts);
totallost = 0;
isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
isc_mem_t **ctxp, unsigned int flags)
{
- isc__mem_t *ctx;
+ isc_mem_t *ctx;
isc_result_t result;
REQUIRE(ctxp != NULL && *ctxp == NULL);
ctx->is_overmem = ISC_FALSE;
ctx->water = NULL;
ctx->water_arg = NULL;
- ctx->common.impmagic = MEM_MAGIC;
- ctx->common.magic = ISCAPI_MCTX_MAGIC;
- ctx->common.methods = (isc_memmethods_t *)&memmethods;
+ ctx->impmagic = MEM_MAGIC;
+ ctx->magic = ISCAPI_MCTX_MAGIC;
ctx->memalloc = memalloc;
ctx->memfree = memfree;
ctx->arg = arg;
}
static void
-destroy(isc__mem_t *ctx) {
+destroy(isc_mem_t *ctx) {
unsigned int i;
+ RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
+
LOCK(&contextslock);
ISC_LIST_UNLINK(contexts, ctx, link);
totallost += ctx->inuse;
UNLOCK(&contextslock);
- ctx->common.impmagic = 0;
- ctx->common.magic = 0;
+ ctx->impmagic = 0;
+ ctx->magic = 0;
INSIST(ISC_LIST_EMPTY(ctx->pools));
}
void
-isc__mem_attach(isc_mem_t *source0, isc_mem_t **targetp) {
- isc__mem_t *source = (isc__mem_t *)source0;
-
+isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
REQUIRE(VALID_CONTEXT(source));
REQUIRE(targetp != NULL && *targetp == NULL);
}
void
-isc__mem_detach(isc_mem_t **ctxp) {
- isc__mem_t *ctx;
+isc_mem_detach(isc_mem_t **ctxp) {
+ isc_mem_t *ctx;
isc_boolean_t want_destroy = ISC_FALSE;
REQUIRE(ctxp != NULL);
- ctx = (isc__mem_t *)*ctxp;
+ ctx = (isc_mem_t *)*ctxp;
REQUIRE(VALID_CONTEXT(ctx));
MCTXLOCK(ctx, &ctx->lock);
*/
void
-isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG) {
- isc__mem_t *ctx;
+_isc_mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG) {
+ isc_mem_t *ctx;
isc_boolean_t want_destroy = ISC_FALSE;
size_info *si;
size_t oldsize;
REQUIRE(ctxp != NULL);
- ctx = (isc__mem_t *)*ctxp;
+ ctx = (isc_mem_t *)*ctxp;
REQUIRE(VALID_CONTEXT(ctx));
REQUIRE(ptr != NULL);
oldsize -= ALIGNMENT_SIZE;
INSIST(oldsize == size);
}
- isc__mem_free((isc_mem_t *)ctx, ptr FLARG_PASS);
+ _isc_mem_free((isc_mem_t *)ctx, ptr FLARG_PASS);
MCTXLOCK(ctx, &ctx->lock);
ctx->references--;
}
void
-isc__mem_destroy(isc_mem_t **ctxp) {
- isc__mem_t *ctx;
+isc_mem_destroy(isc_mem_t **ctxp) {
+ isc_mem_t *ctx;
/*
* This routine provides legacy support for callers who use mctxs
*/
REQUIRE(ctxp != NULL);
- ctx = (isc__mem_t *)*ctxp;
+ ctx = (isc_mem_t *)*ctxp;
REQUIRE(VALID_CONTEXT(ctx));
MCTXLOCK(ctx, &ctx->lock);
}
void *
-isc___mem_get(isc_mem_t *ctx0, size_t size FLARG) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+_isc_mem_get(isc_mem_t *ctx, size_t size FLARG) {
void *ptr;
isc_boolean_t call_water = ISC_FALSE;
if (ISC_UNLIKELY((isc_mem_debugging &
(ISC_MEM_DEBUGSIZE|ISC_MEM_DEBUGCTX)) != 0))
- return (isc__mem_allocate(ctx0, size FLARG_PASS));
+ return (_isc_mem_allocate(ctx, size FLARG_PASS));
if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
MCTXLOCK(ctx, &ctx->lock);
}
void
-isc___mem_put(isc_mem_t *ctx0, void *ptr, size_t size FLARG) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+_isc_mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG) {
isc_boolean_t call_water = ISC_FALSE;
size_info *si;
size_t oldsize;
oldsize -= ALIGNMENT_SIZE;
INSIST(oldsize == size);
}
- isc__mem_free((isc_mem_t *)ctx, ptr FLARG_PASS);
+ _isc_mem_free((isc_mem_t *)ctx, ptr FLARG_PASS);
return;
}
}
void
-isc__mem_waterack(isc_mem_t *ctx0, int flag) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
-
+isc_mem_waterack(isc_mem_t *ctx, int flag) {
REQUIRE(VALID_CONTEXT(ctx));
MCTXLOCK(ctx, &ctx->lock);
#if ISC_MEM_TRACKLINES
static void
-print_active(isc__mem_t *mctx, FILE *out) {
+print_active(isc_mem_t *mctx, FILE *out) {
if (mctx->debuglist != NULL) {
debuglink_t *dl;
unsigned int i;
* Print the stats[] on the stream "out" with suitable formatting.
*/
void
-isc_mem_stats(isc_mem_t *ctx0, FILE *out) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+isc_mem_stats(isc_mem_t *ctx, FILE *out) {
size_t i;
const struct stats *s;
- const isc__mempool_t *pool;
+ const isc_mempool_t *pool;
REQUIRE(VALID_CONTEXT(ctx));
MCTXLOCK(ctx, &ctx->lock);
*/
static void *
-mem_allocateunlocked(isc_mem_t *ctx0, size_t size) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+mem_allocateunlocked(isc_mem_t *ctx, size_t size) {
size_info *si;
size += ALIGNMENT_SIZE;
}
void *
-isc___mem_allocate(isc_mem_t *ctx0, size_t size FLARG) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+_isc_mem_allocate(isc_mem_t *ctx, size_t size FLARG) {
size_info *si;
isc_boolean_t call_water = ISC_FALSE;
}
void *
-isc___mem_reallocate(isc_mem_t *ctx0, void *ptr, size_t size FLARG) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+_isc_mem_reallocate(isc_mem_t *ctx, void *ptr, size_t size FLARG) {
void *new_ptr = NULL;
size_t oldsize, copysize;
* NULL if allocation fails or doesn't happen.
*/
if (size > 0U) {
- new_ptr = isc__mem_allocate(ctx0, size FLARG_PASS);
+ new_ptr = _isc_mem_allocate(ctx, size FLARG_PASS);
if (new_ptr != NULL && ptr != NULL) {
oldsize = (((size_info *)ptr)[-1]).u.size;
INSIST(oldsize >= ALIGNMENT_SIZE);
}
copysize = (oldsize > size) ? size : oldsize;
memmove(new_ptr, ptr, copysize);
- isc__mem_free(ctx0, ptr FLARG_PASS);
+ _isc_mem_free(ctx, ptr FLARG_PASS);
}
- } else if (ptr != NULL)
- isc__mem_free(ctx0, ptr FLARG_PASS);
+ } else if (ptr != NULL) {
+ _isc_mem_free(ctx, ptr FLARG_PASS);
+ }
return (new_ptr);
}
void
-isc___mem_free(isc_mem_t *ctx0, void *ptr FLARG) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+_isc_mem_free(isc_mem_t *ctx, void *ptr FLARG) {
size_info *si;
size_t size;
isc_boolean_t call_water= ISC_FALSE;
*/
char *
-isc___mem_strdup(isc_mem_t *mctx0, const char *s FLARG) {
- isc__mem_t *mctx = (isc__mem_t *)mctx0;
+_isc_mem_strdup(isc_mem_t *mctx, const char *s FLARG) {
size_t len;
char *ns;
len = strlen(s) + 1;
- ns = isc__mem_allocate((isc_mem_t *)mctx, len FLARG_PASS);
+ ns = _isc_mem_allocate((isc_mem_t *)mctx, len FLARG_PASS);
if (ns != NULL)
strlcpy(ns, s, len);
}
void
-isc__mem_setdestroycheck(isc_mem_t *ctx0, isc_boolean_t flag) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
-
+isc_mem_setdestroycheck(isc_mem_t *ctx, isc_boolean_t flag) {
REQUIRE(VALID_CONTEXT(ctx));
MCTXLOCK(ctx, &ctx->lock);
*/
void
-isc_mem_setquota(isc_mem_t *ctx0, size_t quota) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
-
+isc_mem_setquota(isc_mem_t *ctx, size_t quota) {
REQUIRE(VALID_CONTEXT(ctx));
MCTXLOCK(ctx, &ctx->lock);
size_t
isc_mem_getquota(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
size_t quota;
REQUIRE(VALID_CONTEXT(ctx));
}
size_t
-isc__mem_inuse(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+isc_mem_inuse(isc_mem_t *ctx0) {
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
size_t inuse;
REQUIRE(VALID_CONTEXT(ctx));
}
size_t
-isc__mem_maxinuse(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+isc_mem_maxinuse(isc_mem_t *ctx0) {
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
size_t maxinuse;
REQUIRE(VALID_CONTEXT(ctx));
}
size_t
-isc__mem_total(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+isc_mem_total(isc_mem_t *ctx0) {
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
size_t total;
REQUIRE(VALID_CONTEXT(ctx));
}
void
-isc__mem_setwater(isc_mem_t *ctx0, isc_mem_water_t water, void *water_arg,
+isc_mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
size_t hiwater, size_t lowater)
{
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
isc_boolean_t callwater = ISC_FALSE;
isc_mem_water_t oldwater;
void *oldwater_arg;
}
isc_boolean_t
-isc__mem_isovermem(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+isc_mem_isovermem(isc_mem_t *ctx0) {
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
}
void
-isc_mem_setname(isc_mem_t *ctx0, const char *name, void *tag) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
-
+isc_mem_setname(isc_mem_t *ctx, const char *name, void *tag) {
REQUIRE(VALID_CONTEXT(ctx));
LOCK(&ctx->lock);
const char *
isc_mem_getname(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
void *
isc_mem_gettag(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
*/
isc_result_t
-isc__mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) {
- isc__mem_t *mctx = (isc__mem_t *)mctx0;
- isc__mempool_t *mpctx;
+isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) {
+ isc_mempool_t *mpctx;
REQUIRE(VALID_CONTEXT(mctx));
REQUIRE(size > 0U);
* Allocate space for this pool, initialize values, and if all works
* well, attach to the memory context.
*/
- mpctx = isc_mem_get((isc_mem_t *)mctx, sizeof(isc__mempool_t));
+ mpctx = isc_mem_get((isc_mem_t *)mctx, sizeof(isc_mempool_t));
if (mpctx == NULL)
return (ISC_R_NOMEMORY);
- mpctx->common.methods = (isc_mempoolmethods_t *)&mempoolmethods;
- mpctx->common.impmagic = MEMPOOL_MAGIC;
- mpctx->common.magic = ISCAPI_MPOOL_MAGIC;
+ mpctx->impmagic = MEMPOOL_MAGIC;
+ mpctx->magic = ISCAPI_MPOOL_MAGIC;
mpctx->lock = NULL;
mpctx->mctx = mctx;
mpctx->size = size;
}
void
-isc__mempool_setname(isc_mempool_t *mpctx0, const char *name) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
-
+isc_mempool_setname(isc_mempool_t *mpctx, const char *name) {
REQUIRE(name != NULL);
REQUIRE(VALID_MEMPOOL(mpctx));
}
void
-isc__mempool_destroy(isc_mempool_t **mpctxp) {
- isc__mempool_t *mpctx;
- isc__mem_t *mctx;
+isc_mempool_destroy(isc_mempool_t **mpctxp) {
+ isc_mempool_t *mpctx;
+ isc_mem_t *mctx;
isc_mutex_t *lock;
element *item;
REQUIRE(mpctxp != NULL);
- mpctx = (isc__mempool_t *)*mpctxp;
+ mpctx = (isc_mempool_t *)*mpctxp;
REQUIRE(VALID_MEMPOOL(mpctx));
#if ISC_MEMPOOL_NAMES
if (mpctx->allocated > 0)
UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc__mempool_destroy(): mempool %s "
+ "isc_mempool_destroy(): mempool %s "
"leaked memory",
mpctx->name);
#endif
mctx->poolcnt--;
MCTXUNLOCK(mctx, &mctx->lock);
- mpctx->common.impmagic = 0;
- mpctx->common.magic = 0;
+ mpctx->impmagic = 0;
+ mpctx->magic = 0;
- isc_mem_put((isc_mem_t *)mpctx->mctx, mpctx, sizeof(isc__mempool_t));
+ isc_mem_put((isc_mem_t *)mpctx->mctx, mpctx, sizeof(isc_mempool_t));
if (lock != NULL)
UNLOCK(lock);
}
void
-isc__mempool_associatelock(isc_mempool_t *mpctx0, isc_mutex_t *lock) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
-
+isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock) {
REQUIRE(VALID_MEMPOOL(mpctx));
REQUIRE(mpctx->lock == NULL);
REQUIRE(lock != NULL);
}
void *
-isc___mempool_get(isc_mempool_t *mpctx0 FLARG) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
+_isc_mempool_get(isc_mempool_t *mpctx0 FLARG) {
+ isc_mempool_t *mpctx = (isc_mempool_t *)mpctx0;
element *item;
- isc__mem_t *mctx;
+ isc_mem_t *mctx;
unsigned int i;
REQUIRE(VALID_MEMPOOL(mpctx));
/* coverity[+free : arg-1] */
void
-isc___mempool_put(isc_mempool_t *mpctx0, void *mem FLARG) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
- isc__mem_t *mctx;
+_isc_mempool_put(isc_mempool_t *mpctx, void *mem FLARG) {
+ isc_mem_t *mctx;
element *item;
REQUIRE(VALID_MEMPOOL(mpctx));
*/
void
-isc__mempool_setfreemax(isc_mempool_t *mpctx0, unsigned int limit) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
-
+isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit) {
REQUIRE(VALID_MEMPOOL(mpctx));
if (mpctx->lock != NULL)
unsigned int
isc_mempool_getfreemax(isc_mempool_t *mpctx0) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
+ isc_mempool_t *mpctx = (isc_mempool_t *)mpctx0;
unsigned int freemax;
REQUIRE(VALID_MEMPOOL(mpctx));
unsigned int
isc_mempool_getfreecount(isc_mempool_t *mpctx0) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
+ isc_mempool_t *mpctx = (isc_mempool_t *)mpctx0;
unsigned int freecount;
REQUIRE(VALID_MEMPOOL(mpctx));
}
void
-isc__mempool_setmaxalloc(isc_mempool_t *mpctx0, unsigned int limit) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
-
+isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit) {
REQUIRE(limit > 0);
REQUIRE(VALID_MEMPOOL(mpctx));
unsigned int
isc_mempool_getmaxalloc(isc_mempool_t *mpctx0) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
+ isc_mempool_t *mpctx = (isc_mempool_t *)mpctx0;
unsigned int maxalloc;
REQUIRE(VALID_MEMPOOL(mpctx));
}
unsigned int
-isc__mempool_getallocated(isc_mempool_t *mpctx0) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
+isc_mempool_getallocated(isc_mempool_t *mpctx0) {
+ isc_mempool_t *mpctx = (isc_mempool_t *)mpctx0;
unsigned int allocated;
REQUIRE(VALID_MEMPOOL(mpctx));
}
void
-isc__mempool_setfillcount(isc_mempool_t *mpctx0, unsigned int limit) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
-
+isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit) {
REQUIRE(limit > 0);
REQUIRE(VALID_MEMPOOL(mpctx));
unsigned int
isc_mempool_getfillcount(isc_mempool_t *mpctx0) {
- isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
+ isc_mempool_t *mpctx = (isc_mempool_t *)mpctx0;
unsigned int fillcount;
return (fillcount);
}
-isc_result_t
-isc__mem_register(void) {
- return (isc_mem_register(isc_mem_create2));
-}
-
void
-isc__mem_printactive(isc_mem_t *ctx0, FILE *file) {
+isc_mem_printactive(isc_mem_t *ctx, FILE *file) {
#if ISC_MEM_TRACKLINES
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
-
REQUIRE(VALID_CONTEXT(ctx));
REQUIRE(file != NULL);
print_active(ctx, file);
#else
- UNUSED(ctx0);
+ UNUSED(ctx);
UNUSED(file);
#endif
}
+#if ISC_MEM_TRACKLINES
/*
* Requires contextslock to be held by caller.
*/
static void
print_contexts(FILE *file) {
- isc__mem_t *ctx;
+ isc_mem_t *ctx;
for (ctx = ISC_LIST_HEAD(contexts);
ctx != NULL;
}
fflush(file);
}
+#endif
void
isc_mem_printallactive(FILE *file) {
unsigned int
isc_mem_references(isc_mem_t *ctx0) {
- isc__mem_t *ctx = (isc__mem_t *)ctx0;
+ isc_mem_t *ctx = (isc_mem_t *)ctx0;
unsigned int references;
REQUIRE(VALID_CONTEXT(ctx));
#ifdef HAVE_LIBXML2
#define TRY0(a) do { xmlrc = (a); if (xmlrc < 0) goto error; } while(0)
static int
-xml_renderctx(isc__mem_t *ctx, summarystat_t *summary,
+xml_renderctx(isc_mem_t *ctx, summarystat_t *summary,
xmlTextWriterPtr writer)
{
int xmlrc;
int
isc_mem_renderxml(xmlTextWriterPtr writer) {
- isc__mem_t *ctx;
+ isc_mem_t *ctx;
summarystat_t summary;
isc_uint64_t lost;
int xmlrc;
} while(0)
static isc_result_t
-json_renderctx(isc__mem_t *ctx, summarystat_t *summary, json_object *array) {
+json_renderctx(isc_mem_t *ctx, summarystat_t *summary, json_object *array) {
isc_result_t result = ISC_R_FAILURE;
json_object *ctxobj, *obj;
char buf[1024];
isc_result_t
isc_mem_renderjson(json_object *memobj) {
isc_result_t result = ISC_R_SUCCESS;
- isc__mem_t *ctx;
+ isc_mem_t *ctx;
summarystat_t summary;
isc_uint64_t lost;
json_object *ctxarray, *obj;
}
#endif /* HAVE_JSON */
-static isc_memcreatefunc_t mem_createfunc = NULL;
-
-isc_result_t
-isc_mem_register(isc_memcreatefunc_t createfunc) {
- isc_result_t result = ISC_R_SUCCESS;
-
- RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
-
- LOCK(&createlock);
- if (mem_createfunc == NULL)
- mem_createfunc = createfunc;
- else
- result = ISC_R_EXISTS;
- UNLOCK(&createlock);
-
- return (result);
-}
-
-
-isc_result_t
-isc__mem_create2(size_t init_max_size, size_t target_size, isc_mem_t **mctxp,
- unsigned int flags)
-{
- isc_result_t result;
-
- LOCK(&createlock);
-
- REQUIRE(mem_createfunc != NULL);
- result = (*mem_createfunc)(init_max_size, target_size, mctxp, flags);
-
- UNLOCK(&createlock);
-
- return (result);
-}
-
isc_result_t
isc_mem_create(size_t init_max_size, size_t target_size, isc_mem_t **mctxp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc_mem_createx2(init_max_size, target_size,
- default_memalloc, default_memfree,
- NULL, mctxp, isc_mem_defaultflags));
- LOCK(&createlock);
-
- REQUIRE(mem_createfunc != NULL);
- result = (*mem_createfunc)(init_max_size, target_size, mctxp,
- isc_mem_defaultflags);
-
- UNLOCK(&createlock);
-
- return (result);
+ return (isc_mem_createx2(init_max_size, target_size,
+ default_memalloc, default_memfree,
+ NULL, mctxp, isc_mem_defaultflags));
}
isc_result_t
isc_mem_create2(size_t init_max_size, size_t target_size, isc_mem_t **mctxp,
unsigned int flags)
{
- if (isc_bind9)
- return (isc_mem_createx2(init_max_size, target_size,
- default_memalloc, default_memfree,
- NULL, mctxp, flags));
-
return (isc_mem_createx2(init_max_size, target_size,
default_memalloc, default_memfree,
NULL, mctxp, flags));
}
-
-void
-isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
- REQUIRE(ISCAPI_MCTX_VALID(source));
- REQUIRE(targetp != NULL && *targetp == NULL);
-
- if (isc_bind9)
- isc__mem_attach(source, targetp);
- else
- source->methods->attach(source, targetp);
-
- ENSURE(*targetp == source);
-}
-
-void
-isc_mem_detach(isc_mem_t **mctxp) {
- REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
-
- if (isc_bind9)
- isc__mem_detach(mctxp);
- else
- (*mctxp)->methods->detach(mctxp);
-
- ENSURE(*mctxp == NULL);
-}
-
-void
-isc_mem_destroy(isc_mem_t **mctxp) {
- REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
-
- if (isc_bind9)
- isc__mem_destroy(mctxp);
- else
- (*mctxp)->methods->destroy(mctxp);
-
- ENSURE(*mctxp == NULL);
-}
-
-void
-isc_mem_setdestroycheck(isc_mem_t *mctx, isc_boolean_t flag) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- mctx->methods->setdestroycheck(mctx, flag);
-}
-
-void
-isc_mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
- size_t hiwater, size_t lowater)
-{
- REQUIRE(ISCAPI_MCTX_VALID(ctx));
-
- if (isc_bind9)
- isc__mem_setwater(ctx, water, water_arg, hiwater, lowater);
- else
- ctx->methods->setwater(ctx, water, water_arg, hiwater, lowater);
-}
-
-void
-isc_mem_waterack(isc_mem_t *ctx, int flag) {
- REQUIRE(ISCAPI_MCTX_VALID(ctx));
-
- if (isc_bind9)
- isc__mem_waterack(ctx, flag);
- else
- ctx->methods->waterack(ctx, flag);
-}
-
-size_t
-isc_mem_inuse(isc_mem_t *mctx) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc__mem_inuse(mctx));
-
- return (mctx->methods->inuse(mctx));
-}
-
-size_t
-isc_mem_maxinuse(isc_mem_t *mctx) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc__mem_maxinuse(mctx));
-
- return (mctx->methods->maxinuse(mctx));
-}
-
-size_t
-isc_mem_total(isc_mem_t *mctx) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc__mem_total(mctx));
-
- return (mctx->methods->total(mctx));
-}
-
-isc_boolean_t
-isc_mem_isovermem(isc_mem_t *mctx) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc__mem_isovermem(mctx));
-
- return (mctx->methods->isovermem(mctx));
-}
-
-
-isc_result_t
-isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- return (mctx->methods->mpcreate(mctx, size, mpctxp));
-}
-
-void
-isc_mempool_destroy(isc_mempool_t **mpctxp) {
- REQUIRE(mpctxp != NULL && ISCAPI_MPOOL_VALID(*mpctxp));
-
- if (isc_bind9)
- isc__mempool_destroy(mpctxp);
- else
- (*mpctxp)->methods->destroy(mpctxp);
-
- ENSURE(*mpctxp == NULL);
-}
-
-unsigned int
-isc_mempool_getallocated(isc_mempool_t *mpctx) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- return (isc__mempool_getallocated(mpctx));
-
- return (mpctx->methods->getallocated(mpctx));
-}
-
-void
-isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- isc__mempool_setmaxalloc(mpctx, limit);
- else
- mpctx->methods->setmaxalloc(mpctx, limit);
-}
-
-void
-isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- isc__mempool_setfreemax(mpctx, limit);
- else
- mpctx->methods->setfreemax(mpctx, limit);
-}
-
-void
-isc_mempool_setname(isc_mempool_t *mpctx, const char *name) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- isc__mempool_setname(mpctx, name);
- else
- mpctx->methods->setname(mpctx, name);
-}
-
-void
-isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- isc__mempool_associatelock(mpctx, lock);
- else
- mpctx->methods->associatelock(mpctx, lock);
-}
-
-void
-isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- isc__mempool_setfillcount(mpctx, limit);
- else
- mpctx->methods->setfillcount(mpctx, limit);
-}
-
-void *
-isc__mem_get(isc_mem_t *mctx, size_t size FLARG) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc___mem_get(mctx, size FLARG_PASS));
-
- return (mctx->methods->memget(mctx, size FLARG_PASS));
-
-}
-
-void
-isc__mem_put(isc_mem_t *mctx, void *ptr, size_t size FLARG) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- isc___mem_put(mctx, ptr, size FLARG_PASS);
- else
- mctx->methods->memput(mctx, ptr, size FLARG_PASS);
-}
-
-void
-isc__mem_putanddetach(isc_mem_t **mctxp, void *ptr, size_t size FLARG) {
- REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
-
- if (isc_bind9)
- isc___mem_putanddetach(mctxp, ptr, size FLARG_PASS);
- else
- (*mctxp)->methods->memputanddetach(mctxp, ptr, size FLARG_PASS);
-
- /*
- * XXX: We cannot always ensure *mctxp == NULL here
- * (see lib/isc/mem.c).
- */
-}
-
-void *
-isc__mem_allocate(isc_mem_t *mctx, size_t size FLARG) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc___mem_allocate(mctx, size FLARG_PASS));
-
- return (mctx->methods->memallocate(mctx, size FLARG_PASS));
-}
-
-void *
-isc__mem_reallocate(isc_mem_t *mctx, void *ptr, size_t size FLARG) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc___mem_reallocate(mctx, ptr, size FLARG_PASS));
-
- return (mctx->methods->memreallocate(mctx, ptr, size FLARG_PASS));
-}
-
-char *
-isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- return (isc___mem_strdup(mctx, s FLARG_PASS));
-
- return (mctx->methods->memstrdup(mctx, s FLARG_PASS));
-}
-
-void
-isc__mem_free(isc_mem_t *mctx, void *ptr FLARG) {
- REQUIRE(ISCAPI_MCTX_VALID(mctx));
-
- if (isc_bind9)
- isc___mem_free(mctx, ptr FLARG_PASS);
- else
- mctx->methods->memfree(mctx, ptr FLARG_PASS);
-}
-
-void *
-isc__mempool_get(isc_mempool_t *mpctx FLARG) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- return (isc___mempool_get(mpctx FLARG_PASS));
-
- return (mpctx->methods->get(mpctx FLARG_PASS));
-}
-
-void
-isc__mempool_put(isc_mempool_t *mpctx, void *mem FLARG) {
- REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
-
- if (isc_bind9)
- isc___mempool_put(mpctx, mem FLARG_PASS);
- else
- mpctx->methods->put(mpctx, mem FLARG_PASS);
-}
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#include <config.h>
-
-#include <isc/app.h>
-#include <isc/magic.h>
-#include <isc/mutex.h>
-#include <isc/once.h>
-#include <isc/socket.h>
-#include <isc/util.h>
-
-static isc_mutex_t createlock;
-static isc_once_t once = ISC_ONCE_INIT;
-static isc_socketmgrcreatefunc_t socketmgr_createfunc = NULL;
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
-}
-
-isc_result_t
-isc_socket_register(isc_socketmgrcreatefunc_t createfunc) {
- isc_result_t result = ISC_R_SUCCESS;
-
- RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
-
- LOCK(&createlock);
- if (socketmgr_createfunc == NULL)
- socketmgr_createfunc = createfunc;
- else
- result = ISC_R_EXISTS;
- UNLOCK(&createlock);
-
- return (result);
-}
-
-isc_result_t
-isc_socketmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
- isc_socketmgr_t **managerp)
-{
- isc_result_t result;
-
- LOCK(&createlock);
-
- REQUIRE(socketmgr_createfunc != NULL);
- result = (*socketmgr_createfunc)(mctx, managerp);
-
- UNLOCK(&createlock);
-
- if (result == ISC_R_SUCCESS)
- isc_appctx_setsocketmgr(actx, *managerp);
-
- return (result);
-}
-
-isc_result_t
-isc_socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__socketmgr_create(mctx, managerp));
-
- LOCK(&createlock);
-
- REQUIRE(socketmgr_createfunc != NULL);
- result = (*socketmgr_createfunc)(mctx, managerp);
-
- UNLOCK(&createlock);
-
- return (result);
-}
-
-void
-isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
- REQUIRE(managerp != NULL && ISCAPI_SOCKETMGR_VALID(*managerp));
-
- if (isc_bind9)
- isc__socketmgr_destroy(managerp);
- else
- (*managerp)->methods->destroy(managerp);
-
- ENSURE(*managerp == NULL);
-}
-
-isc_result_t
-isc_socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
- isc_socket_t **socketp)
-{
- REQUIRE(ISCAPI_SOCKETMGR_VALID(manager));
-
- if (isc_bind9)
- return (isc__socket_create(manager, pf, type, socketp));
-
- return (manager->methods->socketcreate(manager, pf, type, socketp));
-}
-
-void
-isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
- REQUIRE(socketp != NULL && *socketp == NULL);
-
- if (isc_bind9)
- isc__socket_attach(sock, socketp);
- else
- sock->methods->attach(sock, socketp);
-
- ENSURE(*socketp == sock);
-}
-
-void
-isc_socket_detach(isc_socket_t **socketp) {
- REQUIRE(socketp != NULL && ISCAPI_SOCKET_VALID(*socketp));
-
- if (isc_bind9)
- isc__socket_detach(socketp);
- else
- (*socketp)->methods->detach(socketp);
-
- ENSURE(*socketp == NULL);
-}
-
-isc_result_t
-isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
- unsigned int options)
-{
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_bind(sock, sockaddr, options));
-
- return (sock->methods->bind(sock, sockaddr, options));
-}
-
-isc_result_t
-isc_socket_sendto(isc_socket_t *sock, isc_region_t *region, isc_task_t *task,
- isc_taskaction_t action, void *arg,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
-{
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_sendto(sock, region, task,
- action, arg, address, pktinfo));
-
- return (sock->methods->sendto(sock, region, task, action, arg, address,
- pktinfo));
-}
-
-isc_result_t
-isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
- isc_task_t *task, isc_taskaction_t action, void *arg)
-{
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_connect(sock, addr, task, action, arg));
-
- return (sock->methods->connect(sock, addr, task, action, arg));
-}
-
-isc_result_t
-isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
- isc_task_t *task, isc_taskaction_t action, void *arg)
-{
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_recv(sock, region, minimum,
- task, action, arg));
-
- return (sock->methods->recv(sock, region, minimum, task, action, arg));
-}
-
-void
-isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- isc__socket_cancel(sock, task, how);
- else
- sock->methods->cancel(sock, task, how);
-}
-
-isc_result_t
-isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_getsockname(sock, addressp));
-
- return (sock->methods->getsockname(sock, addressp));
-}
-
-void
-isc_socket_ipv6only(isc_socket_t *sock, isc_boolean_t yes) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- isc__socket_ipv6only(sock, yes);
- else
- sock->methods->ipv6only(sock, yes);
-}
-
-void
-isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- sock->methods->dscp(sock, dscp);
-}
-
-isc_sockettype_t
-isc_socket_gettype(isc_socket_t *sock) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_gettype(sock));
-
- return (sock->methods->gettype(sock));
-}
-
-void
-isc_socket_setname(isc_socket_t *sock, const char *name, void *tag) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- UNUSED(sock); /* in case REQUIRE() is empty */
- UNUSED(name);
- UNUSED(tag);
-}
-
-isc_result_t
-isc_socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
- isc_sockfdwatch_t callback, void *cbarg,
- isc_task_t *task, isc_socket_t **socketp)
-{
- REQUIRE(ISCAPI_SOCKETMGR_VALID(manager));
-
- if (isc_bind9)
- return (isc__socket_fdwatchcreate(manager, fd, flags,
- callback, cbarg,
- task, socketp));
-
- return (manager->methods->fdwatchcreate(manager, fd, flags,
- callback, cbarg, task,
- socketp));
-}
-
-isc_result_t
-isc_socket_fdwatchpoke(isc_socket_t *sock, int flags)
-{
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_fdwatchpoke(sock, flags));
-
- return (sock->methods->fdwatchpoke(sock, flags));
-}
-
-isc_result_t
-isc_socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
- REQUIRE(socketp != NULL && *socketp == NULL);
-
- if (isc_bind9)
- return (isc__socket_dup(sock, socketp));
-
- return (sock->methods->dup(sock, socketp));
-}
-
-int
-isc_socket_getfd(isc_socket_t *sock) {
- REQUIRE(ISCAPI_SOCKET_VALID(sock));
-
- if (isc_bind9)
- return (isc__socket_getfd(sock));
-
- return (sock->methods->getfd(sock));
-}
-
-isc_result_t
-isc_socket_open(isc_socket_t *sock) {
- return (isc__socket_open(sock));
-}
-
-isc_result_t
-isc_socket_close(isc_socket_t *sock) {
- return (isc__socket_close(sock));
-}
-
-isc_result_t
-isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
- unsigned int maxsocks)
-{
- return (isc__socketmgr_create2(mctx, managerp, maxsocks));
-}
-
-isc_result_t
-isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
- unsigned int minimum, isc_task_t *task,
- isc_taskaction_t action, void *arg)
-{
- return (isc__socket_recvv(sock, buflist, minimum, task, action, arg));
-}
-
-isc_result_t
-isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_socketevent_t *event, unsigned int flags)
-{
- return (isc__socket_recv2(sock, region, minimum, task, event, flags));
-}
-
-isc_result_t
-isc_socket_send(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task, isc_taskaction_t action, void *arg)
-{
- return (isc__socket_send(sock, region, task, action, arg));
-}
-
-isc_result_t
-isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
- isc_task_t *task, isc_taskaction_t action, void *arg)
-{
- return (isc__socket_sendv(sock, buflist, task, action, arg));
-}
-
-isc_result_t
-isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
-{
- return (isc__socket_sendtov(sock, buflist, task, action, arg,
- address, pktinfo));
-}
-
-isc_result_t
-isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
- unsigned int flags)
-{
- return (isc__socket_sendtov2(sock, buflist, task, action, arg,
- address, pktinfo, flags));
-}
-
-isc_result_t
-isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
- isc_socketevent_t *event, unsigned int flags)
-{
- return (isc__socket_sendto2(sock, region, task, address, pktinfo,
- event, flags));
-}
-
-void
-isc_socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active) {
- isc__socket_cleanunix(sockaddr, active);
-}
-
-isc_result_t
-isc_socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group)
-{
- return (isc__socket_permunix(sockaddr, perm, owner, group));
-}
-
-isc_result_t
-isc_socket_filter(isc_socket_t *sock, const char *filter) {
- return (isc__socket_filter(sock, filter));
-}
-
-isc_result_t
-isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
- return (isc__socket_listen(sock, backlog));
-}
-
-isc_result_t
-isc_socket_accept(isc_socket_t *sock, isc_task_t *task,
- isc_taskaction_t action, void *arg)
-{
- return (isc__socket_accept(sock, task, action, arg));
-}
-
-isc_result_t
-isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
- return (isc__socket_getpeername(sock, addressp));
-}
#define TASK_MAGIC ISC_MAGIC('T', 'A', 'S', 'K')
#define VALID_TASK(t) ISC_MAGIC_VALID(t, TASK_MAGIC)
-typedef struct isc__task isc__task_t;
-typedef struct isc__taskmgr isc__taskmgr_t;
-
-struct isc__task {
+struct isc_task {
+ unsigned int impmagic;
+ unsigned int magic;
/* Not locked. */
- isc_task_t common;
- isc__taskmgr_t * manager;
+ isc_taskmgr_t * manager;
isc_mutex_t lock;
/* Locked by task lock. */
task_state_t state;
char name[16];
void * tag;
/* Locked by task manager lock. */
- LINK(isc__task_t) link;
- LINK(isc__task_t) ready_link;
- LINK(isc__task_t) ready_priority_link;
+ LINK(isc_task_t) link;
+ LINK(isc_task_t) ready_link;
+ LINK(isc_task_t) ready_priority_link;
};
#define TASK_F_SHUTTINGDOWN 0x01
#define TASK_MANAGER_MAGIC ISC_MAGIC('T', 'S', 'K', 'M')
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TASK_MANAGER_MAGIC)
-typedef ISC_LIST(isc__task_t) isc__tasklist_t;
-
-struct isc__taskmgr {
+struct isc_taskmgr {
+ unsigned int impmagic;
+ unsigned int magic;
/* Not locked. */
- isc_taskmgr_t common;
isc_mem_t * mctx;
isc_mutex_t lock;
#ifdef ISC_PLATFORM_USETHREADS
#endif /* ISC_PLATFORM_USETHREADS */
/* Locked by task manager lock. */
unsigned int default_quantum;
- LIST(isc__task_t) tasks;
- isc__tasklist_t ready_tasks;
- isc__tasklist_t ready_priority_tasks;
+ LIST(isc_task_t) tasks;
+ isc_tasklist_t ready_tasks;
+ isc_tasklist_t ready_priority_tasks;
isc_taskmgrmode_t mode;
#ifdef ISC_PLATFORM_USETHREADS
isc_condition_t work_available;
* will try to acquire it.
*/
isc_mutex_t excl_lock;
- isc__task_t *excl;
+ isc_task_t *excl;
#ifdef USE_SHARED_MANAGER
unsigned int refs;
#endif /* ISC_PLATFORM_USETHREADS */
#define FINISHED(m) ((m)->exiting && EMPTY((m)->tasks))
#ifdef USE_SHARED_MANAGER
-static isc__taskmgr_t *taskmgr = NULL;
+static isc_taskmgr_t *taskmgr = NULL;
#endif /* USE_SHARED_MANAGER */
-/*%
- * The following are intended for internal use (indicated by "isc__"
- * prefix) but are not declared as static, allowing direct access from
- * unit tests etc.
- */
-
-isc_result_t
-isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
- isc_task_t **taskp);
-void
-isc__task_attach(isc_task_t *source0, isc_task_t **targetp);
-void
-isc__task_detach(isc_task_t **taskp);
-void
-isc__task_send(isc_task_t *task0, isc_event_t **eventp);
-void
-isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp);
-unsigned int
-isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
- isc_eventtype_t last, void *tag);
-unsigned int
-isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
- void *tag);
isc_boolean_t
-isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
-unsigned int
-isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
- isc_eventtype_t last, void *tag,
- isc_eventlist_t *events);
-unsigned int
-isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
- void *tag, isc_eventlist_t *events);
-isc_result_t
-isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
- void *arg);
+isc_task_purgeevent(isc_task_t *task, isc_event_t *event);
void
-isc__task_shutdown(isc_task_t *task0);
-void
-isc__task_destroy(isc_task_t **taskp);
-void
-isc__task_setname(isc_task_t *task0, const char *name, void *tag);
-const char *
-isc__task_getname(isc_task_t *task0);
-void *
-isc__task_gettag(isc_task_t *task0);
-void
-isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t);
-void
-isc__task_getcurrenttimex(isc_task_t *task0, isc_time_t *t);
-isc_result_t
-isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
- unsigned int default_quantum, isc_taskmgr_t **managerp);
-void
-isc__taskmgr_destroy(isc_taskmgr_t **managerp);
-void
-isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
-isc_result_t
-isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
+isc_taskmgr_setexcltask(isc_taskmgr_t *mgr, isc_task_t *task);
isc_result_t
-isc__task_beginexclusive(isc_task_t *task);
-void
-isc__task_endexclusive(isc_task_t *task0);
-void
-isc__task_setprivilege(isc_task_t *task0, isc_boolean_t priv);
-isc_boolean_t
-isc__task_privilege(isc_task_t *task0);
-void
-isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode);
-isc_taskmgrmode_t
-isc__taskmgr_mode(isc_taskmgr_t *manager0);
+isc_taskmgr_excltask(isc_taskmgr_t *mgr, isc_task_t **taskp);
static inline isc_boolean_t
-empty_readyq(isc__taskmgr_t *manager);
+empty_readyq(isc_taskmgr_t *manager);
-static inline isc__task_t *
-pop_readyq(isc__taskmgr_t *manager);
+static inline isc_task_t *
+pop_readyq(isc_taskmgr_t *manager);
static inline void
-push_readyq(isc__taskmgr_t *manager, isc__task_t *task);
-
-static struct isc__taskmethods {
- isc_taskmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *purgeevent, *unsendrange, *getname, *gettag,
- *getcurrenttime, *getcurrenttimex;
-} taskmethods = {
- {
- isc__task_attach,
- isc__task_detach,
- isc__task_destroy,
- isc__task_send,
- isc__task_sendanddetach,
- isc__task_unsend,
- isc__task_onshutdown,
- isc__task_shutdown,
- isc__task_setname,
- isc__task_purge,
- isc__task_purgerange,
- isc__task_beginexclusive,
- isc__task_endexclusive,
- isc__task_setprivilege,
- isc__task_privilege
- },
- (void *)isc_task_purgeevent,
- (void *)isc__task_unsendrange,
- (void *)isc__task_getname,
- (void *)isc__task_gettag,
- (void *)isc__task_getcurrenttime,
- (void *)isc__task_getcurrenttimex
-};
-
-static isc_taskmgrmethods_t taskmgrmethods = {
- isc__taskmgr_destroy,
- isc__taskmgr_setmode,
- isc__taskmgr_mode,
- isc__task_create,
- isc_taskmgr_setexcltask,
- isc_taskmgr_excltask
-};
+push_readyq(isc_taskmgr_t *manager, isc_task_t *task);
/***
*** Tasks.
***/
static void
-task_finished(isc__task_t *task) {
- isc__taskmgr_t *manager = task->manager;
+task_finished(isc_task_t *task) {
+ isc_taskmgr_t *manager = task->manager;
REQUIRE(EMPTY(task->events));
REQUIRE(task->nevents == 0);
UNLOCK(&manager->lock);
DESTROYLOCK(&task->lock);
- task->common.impmagic = 0;
- task->common.magic = 0;
+ task->impmagic = 0;
+ task->magic = 0;
isc_mem_put(manager->mctx, task, sizeof(*task));
}
+unsigned int
+isc_task_magic(isc_task_t *task) {
+ return (task->magic);
+}
+
isc_result_t
-isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
+isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
isc_task_t **taskp)
{
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
- isc__task_t *task;
+ isc_task_t *task;
isc_boolean_t exiting;
isc_result_t result;
return (ISC_R_SHUTTINGDOWN);
}
- task->common.methods = (isc_taskmethods_t *)&taskmethods;
- task->common.magic = ISCAPI_TASK_MAGIC;
- task->common.impmagic = TASK_MAGIC;
+ task->magic = ISCAPI_TASK_MAGIC;
+ task->impmagic = TASK_MAGIC;
*taskp = (isc_task_t *)task;
return (ISC_R_SUCCESS);
}
void
-isc__task_attach(isc_task_t *source0, isc_task_t **targetp) {
- isc__task_t *source = (isc__task_t *)source0;
-
+isc_task_attach(isc_task_t *source, isc_task_t **targetp) {
/*
* Attach *targetp to source.
*/
}
static inline isc_boolean_t
-task_shutdown(isc__task_t *task) {
+task_shutdown(isc_task_t *task) {
isc_boolean_t was_idle = ISC_FALSE;
isc_event_t *event, *prev;
* Caller must NOT hold manager lock.
*/
static inline void
-task_ready(isc__task_t *task) {
- isc__taskmgr_t *manager = task->manager;
+task_ready(isc_task_t *task) {
+ isc_taskmgr_t *manager = task->manager;
#ifdef USE_WORKER_THREADS
- isc_boolean_t has_privilege = isc__task_privilege((isc_task_t *) task);
+ isc_boolean_t has_privilege = isc_task_privilege((isc_task_t *) task);
#endif /* USE_WORKER_THREADS */
REQUIRE(VALID_MANAGER(manager));
}
static inline isc_boolean_t
-task_detach(isc__task_t *task) {
+task_detach(isc_task_t *task) {
/*
* Caller must be holding the task lock.
}
void
-isc__task_detach(isc_task_t **taskp) {
- isc__task_t *task;
+isc_task_detach(isc_task_t **taskp) {
+ isc_task_t *task;
isc_boolean_t was_idle;
/*
*/
REQUIRE(taskp != NULL);
- task = (isc__task_t *)*taskp;
+ task = (isc_task_t *)*taskp;
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_detach");
}
static inline isc_boolean_t
-task_send(isc__task_t *task, isc_event_t **eventp) {
+task_send(isc_task_t *task, isc_event_t **eventp) {
isc_boolean_t was_idle = ISC_FALSE;
isc_event_t *event;
}
void
-isc__task_send(isc_task_t *task0, isc_event_t **eventp) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_send(isc_task_t *task, isc_event_t **eventp) {
isc_boolean_t was_idle;
/*
}
void
-isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
+isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
isc_boolean_t idle1, idle2;
- isc__task_t *task;
+ isc_task_t *task;
/*
* Send '*event' to '*taskp' and then detach '*taskp' from its
*/
REQUIRE(taskp != NULL);
- task = (isc__task_t *)*taskp;
+ task = (isc_task_t *)*taskp;
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_sendanddetach");
#define PURGE_OK(event) (((event)->ev_attributes & ISC_EVENTATTR_NOPURGE) == 0)
static unsigned int
-dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first,
+dequeue_events(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag,
isc_eventlist_t *events, isc_boolean_t purging)
{
}
unsigned int
-isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
+isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag)
{
- isc__task_t *task = (isc__task_t *)task0;
unsigned int count;
isc_eventlist_t events;
isc_event_t *event, *next_event;
}
unsigned int
-isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
+isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag)
{
/*
XTRACE("isc_task_purge");
- return (isc__task_purgerange(task, sender, type, type, tag));
+ return (isc_task_purgerange(task, sender, type, type, tag));
}
isc_boolean_t
-isc_task_purgeevent(isc_task_t *task0, isc_event_t *event) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_purgeevent(isc_task_t *task, isc_event_t *event) {
isc_event_t *curr_event, *next_event;
/*
}
unsigned int
-isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
+isc_task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag,
isc_eventlist_t *events)
{
XTRACE("isc_task_unsendrange");
- return (dequeue_events((isc__task_t *)task, sender, first,
+ return (dequeue_events((isc_task_t *)task, sender, first,
last, tag, events, ISC_FALSE));
}
unsigned int
-isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
+isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag, isc_eventlist_t *events)
{
/*
XTRACE("isc_task_unsend");
- return (dequeue_events((isc__task_t *)task, sender, type,
+ return (dequeue_events((isc_task_t *)task, sender, type,
type, tag, events, ISC_FALSE));
}
isc_result_t
-isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
+isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action,
void *arg)
{
- isc__task_t *task = (isc__task_t *)task0;
isc_boolean_t disallowed = ISC_FALSE;
isc_result_t result = ISC_R_SUCCESS;
isc_event_t *event;
}
void
-isc__task_shutdown(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_shutdown(isc_task_t *task0) {
+ isc_task_t *task = (isc_task_t *)task0;
isc_boolean_t was_idle;
/*
was_idle = task_shutdown(task);
UNLOCK(&task->lock);
- if (was_idle)
+ if (was_idle) {
task_ready(task);
+ }
}
void
-isc__task_destroy(isc_task_t **taskp) {
+isc_task_destroy(isc_task_t **taskp) {
/*
* Destroy '*taskp'.
}
void
-isc__task_setname(isc_task_t *task0, const char *name, void *tag) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_setname(isc_task_t *task, const char *name, void *tag) {
/*
* Name 'task'.
*/
}
const char *
-isc__task_getname(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_getname(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
return (task->name);
}
void *
-isc__task_gettag(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_gettag(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
return (task->tag);
}
void
-isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) {
REQUIRE(VALID_TASK(task));
REQUIRE(t != NULL);
}
void
-isc__task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
- isc__task_t *task = (isc__task_t *)task0;
-
+isc_task_getcurrenttimex(isc_task_t *task, isc_time_t *t) {
REQUIRE(VALID_TASK(task));
REQUIRE(t != NULL);
* Caller must hold the task manager lock.
*/
static inline isc_boolean_t
-empty_readyq(isc__taskmgr_t *manager) {
- isc__tasklist_t queue;
+empty_readyq(isc_taskmgr_t *manager) {
+ isc_tasklist_t queue;
if (manager->mode == isc_taskmgrmode_normal)
queue = manager->ready_tasks;
*
* Caller must hold the task manager lock.
*/
-static inline isc__task_t *
-pop_readyq(isc__taskmgr_t *manager) {
- isc__task_t *task;
+static inline isc_task_t *
+pop_readyq(isc_taskmgr_t *manager) {
+ isc_task_t *task;
if (manager->mode == isc_taskmgrmode_normal)
task = HEAD(manager->ready_tasks);
* Caller must hold the task manager lock.
*/
static inline void
-push_readyq(isc__taskmgr_t *manager, isc__task_t *task) {
+push_readyq(isc_taskmgr_t *manager, isc_task_t *task) {
ENQUEUE(manager->ready_tasks, task, ready_link);
if ((task->flags & TASK_F_PRIVILEGED) != 0)
ENQUEUE(manager->ready_priority_tasks, task,
}
static void
-dispatch(isc__taskmgr_t *manager) {
- isc__task_t *task;
+dispatch(isc_taskmgr_t *manager) {
+ isc_task_t *task;
#ifndef USE_WORKER_THREADS
unsigned int total_dispatch_count = 0;
- isc__tasklist_t new_ready_tasks;
- isc__tasklist_t new_priority_tasks;
+ isc_tasklist_t new_ready_tasks;
+ isc_tasklist_t new_priority_tasks;
unsigned int tasks_ready = 0;
#endif /* USE_WORKER_THREADS */
WINAPI
#endif
run(void *uap) {
- isc__taskmgr_t *manager = uap;
+ isc_taskmgr_t *manager = uap;
XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_STARTING, "starting"));
#endif /* USE_WORKER_THREADS */
static void
-manager_free(isc__taskmgr_t *manager) {
+manager_free(isc_taskmgr_t *manager) {
isc_mem_t *mctx;
#ifdef USE_WORKER_THREADS
#endif /* USE_WORKER_THREADS */
DESTROYLOCK(&manager->lock);
DESTROYLOCK(&manager->excl_lock);
- manager->common.impmagic = 0;
- manager->common.magic = 0;
+ manager->impmagic = 0;
+ manager->magic = 0;
mctx = manager->mctx;
isc_mem_put(mctx, manager, sizeof(*manager));
isc_mem_detach(&mctx);
#endif /* USE_SHARED_MANAGER */
}
+
+unsigned int
+isc_taskmgr_magic(isc_taskmgr_t *manager) {
+ return (manager->magic);
+}
+
isc_result_t
-isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
- unsigned int default_quantum, isc_taskmgr_t **managerp)
+isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
+ unsigned int default_quantum, isc_taskmgr_t **managerp)
{
isc_result_t result;
unsigned int i, started = 0;
- isc__taskmgr_t *manager;
+ isc_taskmgr_t *manager;
/*
* Create a new task manager.
manager = isc_mem_get(mctx, sizeof(*manager));
if (manager == NULL)
return (ISC_R_NOMEMORY);
- manager->common.methods = &taskmgrmethods;
- manager->common.impmagic = TASK_MANAGER_MAGIC;
- manager->common.magic = ISCAPI_TASKMGR_MAGIC;
+ manager->impmagic = TASK_MANAGER_MAGIC;
+ manager->magic = ISCAPI_TASKMGR_MAGIC;
manager->mode = isc_taskmgrmode_normal;
manager->mctx = NULL;
result = isc_mutex_init(&manager->lock);
}
void
-isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
- isc__taskmgr_t *manager;
- isc__task_t *task;
+isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
+ isc_taskmgr_t *manager;
+ isc_task_t *task;
unsigned int i;
/*
*/
REQUIRE(managerp != NULL);
- manager = (isc__taskmgr_t *)*managerp;
+ manager = (isc_taskmgr_t *)*managerp;
REQUIRE(VALID_MANAGER(manager));
#ifndef USE_WORKER_THREADS
* Detach the exclusive task before acquiring the manager lock
*/
LOCK(&manager->excl_lock);
- if (manager->excl != NULL)
- isc__task_detach((isc_task_t **) &manager->excl);
+ if (manager->excl != NULL) {
+ isc_task_detach((isc_task_t **) &manager->excl);
+ }
UNLOCK(&manager->excl_lock);
/*
* Dispatch the shutdown events.
*/
UNLOCK(&manager->lock);
- while (isc__taskmgr_ready((isc_taskmgr_t *)manager))
- (void)isc__taskmgr_dispatch((isc_taskmgr_t *)manager);
+ while (isc_taskmgr_ready((isc_taskmgr_t *)manager))
+ (void)isc_taskmgr_dispatch((isc_taskmgr_t *)manager);
if (!ISC_LIST_EMPTY(manager->tasks)) {
- isc__task_t *t;
+ isc_task_t *t;
isc_mem_printallactive(stderr);
for (t = ISC_LIST_HEAD(manager->tasks);
t != NULL;
}
void
-isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
-
+isc_taskmgr_setmode(isc_taskmgr_t *manager, isc_taskmgrmode_t mode) {
LOCK(&manager->lock);
manager->mode = mode;
UNLOCK(&manager->lock);
}
isc_taskmgrmode_t
-isc__taskmgr_mode(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+isc_taskmgr_mode(isc_taskmgr_t *manager) {
isc_taskmgrmode_t mode;
LOCK(&manager->lock);
mode = manager->mode;
#ifndef USE_WORKER_THREADS
isc_boolean_t
-isc__taskmgr_ready(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+isc_taskmgr_ready(isc_taskmgr_t *manager) {
isc_boolean_t is_ready;
#ifdef USE_SHARED_MANAGER
}
isc_result_t
-isc__taskmgr_dispatch(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
-
+isc_taskmgr_dispatch(isc_taskmgr_t *manager) {
#ifdef USE_SHARED_MANAGER
if (manager == NULL)
manager = taskmgr;
#else
void
-isc__taskmgr_pause(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
+isc_taskmgr_pause(isc_taskmgr_t *manager) {
manager->pause_requested = ISC_TRUE;
LOCK(&manager->lock);
while (manager->tasks_running > 0) {
}
void
-isc__taskmgr_resume(isc_taskmgr_t *manager0) {
- isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
-
+isc_taskmgr_resume(isc_taskmgr_t *manager) {
LOCK(&manager->lock);
if (manager->pause_requested) {
manager->pause_requested = ISC_FALSE;
#endif /* USE_WORKER_THREADS */
void
-isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0) {
- isc__taskmgr_t *mgr = (isc__taskmgr_t *) mgr0;
- isc__task_t *task = (isc__task_t *) task0;
-
+isc_taskmgr_setexcltask(isc_taskmgr_t *mgr, isc_task_t *task) {
REQUIRE(VALID_MANAGER(mgr));
REQUIRE(VALID_TASK(task));
LOCK(&mgr->excl_lock);
- if (mgr->excl != NULL)
- isc__task_detach((isc_task_t **) &mgr->excl);
- isc__task_attach(task0, (isc_task_t **) &mgr->excl);
+ if (mgr->excl != NULL) {
+ isc_task_detach((isc_task_t **) &mgr->excl);
+ }
+ isc_task_attach(task, (isc_task_t **) &mgr->excl);
UNLOCK(&mgr->excl_lock);
}
isc_result_t
-isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
- isc__taskmgr_t *mgr = (isc__taskmgr_t *) mgr0;
+isc_taskmgr_excltask(isc_taskmgr_t *mgr, isc_task_t **taskp) {
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(VALID_MANAGER(mgr));
LOCK(&mgr->excl_lock);
if (mgr->excl != NULL)
- isc__task_attach((isc_task_t *) mgr->excl, taskp);
+ isc_task_attach((isc_task_t *) mgr->excl, taskp);
else
result = ISC_R_NOTFOUND;
UNLOCK(&mgr->excl_lock);
}
isc_result_t
-isc__task_beginexclusive(isc_task_t *task0) {
+isc_task_beginexclusive(isc_task_t *task) {
#ifdef USE_WORKER_THREADS
- isc__task_t *task = (isc__task_t *)task0;
- isc__taskmgr_t *manager = task->manager;
+ isc_taskmgr_t *manager = task->manager;
REQUIRE(task->state == task_state_running);
/*
}
void
-isc__task_endexclusive(isc_task_t *task0) {
+isc_task_endexclusive(isc_task_t *task) {
#ifdef USE_WORKER_THREADS
- isc__task_t *task = (isc__task_t *)task0;
- isc__taskmgr_t *manager = task->manager;
+ isc_taskmgr_t *manager = task->manager;
REQUIRE(task->state == task_state_running);
LOCK(&manager->lock);
BROADCAST(&manager->work_available);
UNLOCK(&manager->lock);
#else
- UNUSED(task0);
+ UNUSED(task);
#endif
}
void
-isc__task_setprivilege(isc_task_t *task0, isc_boolean_t priv) {
- isc__task_t *task = (isc__task_t *)task0;
- isc__taskmgr_t *manager = task->manager;
+isc_task_setprivilege(isc_task_t *task, isc_boolean_t priv) {
+ isc_taskmgr_t *manager = task->manager;
isc_boolean_t oldpriv;
LOCK(&task->lock);
oldpriv = ISC_TF((task->flags & TASK_F_PRIVILEGED) != 0);
- if (priv)
+ if (priv) {
task->flags |= TASK_F_PRIVILEGED;
- else
+ } else {
task->flags &= ~TASK_F_PRIVILEGED;
+ }
UNLOCK(&task->lock);
- if (priv == oldpriv)
+ if (priv == oldpriv) {
return;
+ }
LOCK(&manager->lock);
- if (priv && ISC_LINK_LINKED(task, ready_link))
+ if (priv && ISC_LINK_LINKED(task, ready_link)) {
ENQUEUE(manager->ready_priority_tasks, task,
ready_priority_link);
- else if (!priv && ISC_LINK_LINKED(task, ready_priority_link))
+ } else if (!priv && ISC_LINK_LINKED(task, ready_priority_link)) {
DEQUEUE(manager->ready_priority_tasks, task,
ready_priority_link);
+ }
UNLOCK(&manager->lock);
}
isc_boolean_t
-isc__task_privilege(isc_task_t *task0) {
- isc__task_t *task = (isc__task_t *)task0;
+isc_task_privilege(isc_task_t *task) {
isc_boolean_t priv;
LOCK(&task->lock);
return (priv);
}
-isc_result_t
-isc__task_register(void) {
- return (isc_task_register(isc__taskmgr_create));
-}
-
isc_boolean_t
isc_task_exiting(isc_task_t *t) {
- isc__task_t *task = (isc__task_t *)t;
+ isc_task_t *task = (isc_task_t *)t;
REQUIRE(VALID_TASK(task));
return (TASK_SHUTTINGDOWN(task));
#ifdef HAVE_LIBXML2
#define TRY0(a) do { xmlrc = (a); if (xmlrc < 0) goto error; } while(0)
int
-isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) {
- isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
- isc__task_t *task = NULL;
+isc_taskmgr_renderxml(isc_taskmgr_t *mgr, xmlTextWriterPtr writer) {
+ isc_task_t *task = NULL;
int xmlrc;
LOCK(&mgr->lock);
} while(0)
isc_result_t
-isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
+isc_taskmgr_renderjson(isc_taskmgr_t *mgr, json_object *tasks) {
isc_result_t result = ISC_R_SUCCESS;
- isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
- isc__task_t *task = NULL;
+ isc_task_t *task = NULL;
json_object *obj = NULL, *array = NULL, *taskobj = NULL;
LOCK(&mgr->lock);
}
#endif
-
-static isc_mutex_t createlock;
-static isc_once_t once = ISC_ONCE_INIT;
-static isc_taskmgrcreatefunc_t taskmgr_createfunc = NULL;
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
-}
-
-isc_result_t
-isc_task_register(isc_taskmgrcreatefunc_t createfunc) {
- isc_result_t result = ISC_R_SUCCESS;
-
- RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
-
- LOCK(&createlock);
- if (taskmgr_createfunc == NULL)
- taskmgr_createfunc = createfunc;
- else
- result = ISC_R_EXISTS;
- UNLOCK(&createlock);
-
- return (result);
-}
-
isc_result_t
isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
unsigned int workers, unsigned int default_quantum,
{
isc_result_t result;
- LOCK(&createlock);
+ result = isc_taskmgr_create(mctx, workers, default_quantum,
+ managerp);
- REQUIRE(taskmgr_createfunc != NULL);
- result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
- managerp);
-
- UNLOCK(&createlock);
-
- if (result == ISC_R_SUCCESS)
+ if (result == ISC_R_SUCCESS) {
isc_appctx_settaskmgr(actx, *managerp);
-
- return (result);
-}
-
-isc_result_t
-isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
- unsigned int default_quantum, isc_taskmgr_t **managerp)
-{
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__taskmgr_create(mctx, workers,
- default_quantum, managerp));
- LOCK(&createlock);
-
- REQUIRE(taskmgr_createfunc != NULL);
- result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
- managerp);
-
- UNLOCK(&createlock);
-
- return (result);
-}
-
-void
-isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
- REQUIRE(managerp != NULL && ISCAPI_TASKMGR_VALID(*managerp));
-
- if (isc_bind9)
- isc__taskmgr_destroy(managerp);
- else
- (*managerp)->methods->destroy(managerp);
-
- ENSURE(*managerp == NULL);
-}
-
-void
-isc_taskmgr_setmode(isc_taskmgr_t *manager, isc_taskmgrmode_t mode) {
- REQUIRE(ISCAPI_TASKMGR_VALID(manager));
-
- if (isc_bind9)
- isc__taskmgr_setmode(manager, mode);
- else
- manager->methods->setmode(manager, mode);
-}
-
-isc_taskmgrmode_t
-isc_taskmgr_mode(isc_taskmgr_t *manager) {
- REQUIRE(ISCAPI_TASKMGR_VALID(manager));
-
- if (isc_bind9)
- return (isc__taskmgr_mode(manager));
-
- return (manager->methods->mode(manager));
-}
-
-isc_result_t
-isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
- isc_task_t **taskp)
-{
- REQUIRE(ISCAPI_TASKMGR_VALID(manager));
- REQUIRE(taskp != NULL && *taskp == NULL);
-
- if (isc_bind9)
- return (isc__task_create(manager, quantum, taskp));
-
- return (manager->methods->taskcreate(manager, quantum, taskp));
-}
-
-void
-isc_task_attach(isc_task_t *source, isc_task_t **targetp) {
- REQUIRE(ISCAPI_TASK_VALID(source));
- REQUIRE(targetp != NULL && *targetp == NULL);
-
- if (isc_bind9)
- isc__task_attach(source, targetp);
- else
- source->methods->attach(source, targetp);
-
- ENSURE(*targetp == source);
-}
-
-void
-isc_task_detach(isc_task_t **taskp) {
- REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
-
- if (isc_bind9)
- isc__task_detach(taskp);
- else
- (*taskp)->methods->detach(taskp);
-
- ENSURE(*taskp == NULL);
-}
-
-void
-isc_task_send(isc_task_t *task, isc_event_t **eventp) {
- REQUIRE(ISCAPI_TASK_VALID(task));
- REQUIRE(eventp != NULL && *eventp != NULL);
-
- if (isc_bind9)
- isc__task_send(task, eventp);
- else {
- task->methods->send(task, eventp);
- ENSURE(*eventp == NULL);
- }
-}
-
-void
-isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
- REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
- REQUIRE(eventp != NULL && *eventp != NULL);
-
- if (isc_bind9)
- isc__task_sendanddetach(taskp, eventp);
- else {
- (*taskp)->methods->sendanddetach(taskp, eventp);
- ENSURE(*eventp == NULL);
}
- ENSURE(*taskp == NULL);
-}
-
-unsigned int
-isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
- void *tag, isc_eventlist_t *events)
-{
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- return (isc__task_unsend(task, sender, type, tag, events));
-
- return (task->methods->unsend(task, sender, type, tag, events));
-}
-
-isc_result_t
-isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg)
-{
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- return (isc__task_onshutdown(task, action, arg));
-
- return (task->methods->onshutdown(task, action, arg));
-}
-
-void
-isc_task_shutdown(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- isc__task_shutdown(task);
- else
- task->methods->shutdown(task);
-}
-
-void
-isc_task_destroy(isc_task_t **taskp) {
- if (!isc_bind9)
- return;
-
- isc__task_destroy(taskp);
-}
-
-void
-isc_task_setname(isc_task_t *task, const char *name, void *tag) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- isc__task_setname(task, name, tag);
- else
- task->methods->setname(task, name, tag);
-}
-
-unsigned int
-isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type, void *tag)
-{
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- return (isc__task_purge(task, sender, type, tag));
-
- return (task->methods->purgeevents(task, sender, type, tag));
-}
-
-isc_result_t
-isc_task_beginexclusive(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- return (isc__task_beginexclusive(task));
-
- return (task->methods->beginexclusive(task));
-}
-
-void
-isc_task_endexclusive(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- isc__task_endexclusive(task);
- else
- task->methods->endexclusive(task);
-}
-
-void
-isc_task_setprivilege(isc_task_t *task, isc_boolean_t priv) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- isc__task_setprivilege(task, priv);
- else
- task->methods->setprivilege(task, priv);
-}
-
-isc_boolean_t
-isc_task_privilege(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- return (isc__task_privilege(task));
-
- return (task->methods->privilege(task));
-}
-
-void
-isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) {
- if (!isc_bind9)
- return;
-
- isc__task_getcurrenttime(task, t);
-}
-
-void
-isc_task_getcurrenttimex(isc_task_t *task, isc_time_t *t) {
- if (!isc_bind9)
- return;
-
- isc__task_getcurrenttimex(task, t);
-}
-
-/*%
- * This is necessary for libisc's internal timer implementation. Other
- * implementation might skip implementing this.
- */
-unsigned int
-isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
- isc_eventtype_t last, void *tag)
-{
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- if (isc_bind9)
- return (isc__task_purgerange(task, sender, first, last, tag));
-
- return (task->methods->purgerange(task, sender, first, last, tag));
+ return (result);
}
isc_mem_debugging = 0;
ptr = isc_mem_get(mctx2, 2048);
ATF_CHECK(ptr != NULL);
- isc__mem_printactive(mctx2, f);
+ isc_mem_printactive(mctx2, f);
isc_mem_put(mctx2, ptr, 2048);
isc_mem_destroy(&mctx2);
isc_stdio_close(f);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
ptr = isc_mem_get(mctx2, 2048);
ATF_CHECK(ptr != NULL);
- isc__mem_printactive(mctx2, f);
+ isc_mem_printactive(mctx2, f);
isc_mem_put(mctx2, ptr, 2048);
isc_mem_destroy(&mctx2);
isc_stdio_close(f);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
ptr = isc_mem_get(mctx2, 2048);
ATF_CHECK(ptr != NULL);
- isc__mem_printactive(mctx2, f);
+ isc_mem_printactive(mctx2, f);
isc_mem_put(mctx2, ptr, 2048);
isc_mem_destroy(&mctx2);
isc_stdio_close(f);
while ((a == 0 || b == 0) && i++ < 5000) {
#ifndef ISC_PLATFORM_USETHREADS
- while (isc__taskmgr_ready(taskmgr))
- isc__taskmgr_dispatch(taskmgr);
+ while (isc_taskmgr_ready(taskmgr))
+ isc_taskmgr_dispatch(taskmgr);
#endif
isc_test_nap(1000);
}
* Pause the task manager so we can fill up the work queue
* without things happening while we do it.
*/
- isc__taskmgr_pause(taskmgr);
+ isc_taskmgr_pause(taskmgr);
#endif
result = isc_task_create(taskmgr, 0, &task1);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged);
#ifdef ISC_PLATFORM_USETHREADS
- isc__taskmgr_resume(taskmgr);
+ isc_taskmgr_resume(taskmgr);
#endif
/* We're waiting for *all* variables to be set */
while ((a == 0 || b == 0 || c == 0 || d == 0 || e == 0) && i++ < 5000) {
#ifndef ISC_PLATFORM_USETHREADS
- while (isc__taskmgr_ready(taskmgr))
- isc__taskmgr_dispatch(taskmgr);
+ while (isc_taskmgr_ready(taskmgr))
+ isc_taskmgr_dispatch(taskmgr);
#endif
isc_test_nap(1000);
}
* Pause the task manager so we can fill up the work queue
* without things happening while we do it.
*/
- isc__taskmgr_pause(taskmgr);
+ isc_taskmgr_pause(taskmgr);
#endif
result = isc_task_create(taskmgr, 0, &task1);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged);
#ifdef ISC_PLATFORM_USETHREADS
- isc__taskmgr_resume(taskmgr);
+ isc_taskmgr_resume(taskmgr);
#endif
/* We're waiting for all variables to be set. */
while ((a == -1 || b == -1 || c == -1 || d == -1 || e == -1) &&
i++ < 5000) {
#ifndef ISC_PLATFORM_USETHREADS
- while (isc__taskmgr_ready(taskmgr))
- isc__taskmgr_dispatch(taskmgr);
+ while (isc_taskmgr_ready(taskmgr))
+ isc_taskmgr_dispatch(taskmgr);
#endif
isc_test_nap(1000);
}
#include <openssl/err.h>
#endif
-/* See task.c about the following definition: */
-#ifdef ISC_PLATFORM_USETHREADS
-#define USE_TIMER_THREAD
-#else
-#define USE_SHARED_MANAGER
-#endif /* ISC_PLATFORM_USETHREADS */
-
-#ifndef USE_TIMER_THREAD
+#ifndef ISC_PLATFORM_USETHREADS
#include "timer_p.h"
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
#ifdef ISC_TIMER_TRACE
#define XTRACE(s) fprintf(stderr, "%s\n", (s))
#define TIMER_MAGIC ISC_MAGIC('T', 'I', 'M', 'R')
#define VALID_TIMER(t) ISC_MAGIC_VALID(t, TIMER_MAGIC)
-typedef struct isc__timer isc__timer_t;
-typedef struct isc__timermgr isc__timermgr_t;
+typedef struct isc_timer isc_timer_t;
+typedef struct isc_timermgr isc_timermgr_t;
-struct isc__timer {
+struct isc_timer {
+ unsigned int impmagic;
+ unsigned int magic;
/*! Not locked. */
- isc_timer_t common;
- isc__timermgr_t * manager;
+ isc_timermgr_t * manager;
isc_mutex_t lock;
/*! Locked by timer lock. */
unsigned int references;
void * arg;
unsigned int index;
isc_time_t due;
- LINK(isc__timer_t) link;
+ LINK(isc_timer_t) link;
};
#define TIMER_MANAGER_MAGIC ISC_MAGIC('T', 'I', 'M', 'M')
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TIMER_MANAGER_MAGIC)
-struct isc__timermgr {
+struct isc_timermgr {
+ unsigned int impmagic;
+ unsigned int magic;
/* Not locked. */
- isc_timermgr_t common;
isc_mem_t * mctx;
isc_mutex_t lock;
/* Locked by manager lock. */
isc_boolean_t done;
- LIST(isc__timer_t) timers;
+ LIST(isc_timer_t) timers;
unsigned int nscheduled;
isc_time_t due;
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
isc_condition_t wakeup;
isc_thread_t thread;
-#endif /* USE_TIMER_THREAD */
-#ifdef USE_SHARED_MANAGER
+#else
unsigned int refs;
-#endif /* USE_SHARED_MANAGER */
+#endif /* !ISC_PLATFORM_USETHREADS */
isc_heap_t * heap;
};
-/*%
- * The following are intended for internal use (indicated by "isc__"
- * prefix) but are not declared as static, allowing direct access from
- * unit tests etc.
- */
-
-isc_result_t
-isc__timer_create(isc_timermgr_t *manager, isc_timertype_t type,
- const isc_time_t *expires, const isc_interval_t *interval,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_timer_t **timerp);
-isc_result_t
-isc__timer_reset(isc_timer_t *timer, isc_timertype_t type,
- const isc_time_t *expires, const isc_interval_t *interval,
- isc_boolean_t purge);
isc_timertype_t
isc_timer_gettype(isc_timer_t *timer);
-isc_result_t
-isc__timer_touch(isc_timer_t *timer);
-void
-isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp);
-void
-isc__timer_detach(isc_timer_t **timerp);
-isc_result_t
-isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp);
-void
-isc_timermgr_poke(isc_timermgr_t *manager0);
-void
-isc__timermgr_destroy(isc_timermgr_t **managerp);
-
-static struct isc__timermethods {
- isc_timermethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *gettype;
-} timermethods = {
- {
- isc__timer_attach,
- isc__timer_detach,
- isc__timer_reset,
- isc__timer_touch
- },
- (void *)isc_timer_gettype
-};
-
-static struct isc__timermgrmethods {
- isc_timermgrmethods_t methods;
- void *poke; /* see above */
-} timermgrmethods = {
- {
- isc__timermgr_destroy,
- isc__timer_create
- },
- (void *)isc_timermgr_poke
-};
-#ifdef USE_SHARED_MANAGER
+#ifndef ISC_PLATFORM_USETHREADS
/*!
* If the manager is supposed to be shared, there can be only one.
*/
-static isc__timermgr_t *timermgr = NULL;
-#endif /* USE_SHARED_MANAGER */
+static isc_timermgr_t *timermgr = NULL;
+#endif /* ISC_PLATFORM_USETHREADS */
static inline isc_result_t
-schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
+schedule(isc_timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
isc_result_t result;
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
isc_time_t due;
int cmp;
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
isc_boolean_t timedwait;
#endif
REQUIRE(timer->type != isc_timertype_inactive);
-#ifndef USE_TIMER_THREAD
+#ifndef ISC_PLATFORM_USETHREADS
UNUSED(signal_ok);
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
manager = timer->manager;
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
/*!
* If the manager was timed wait, we may need to signal the
* manager to force a wakeup.
* the current "next" timer. We do this either by waking up the
* run thread, or explicitly setting the value in the manager.
*/
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
/*
* This is a temporary (probably) hack to fix a bug on tru64 5.1
"signal (schedule)"));
SIGNAL(&manager->wakeup);
}
-#else /* USE_TIMER_THREAD */
+#else /* ISC_PLATFORM_USETHREADS */
if (timer->index == 1 &&
isc_time_compare(&timer->due, &manager->due) < 0)
manager->due = timer->due;
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
return (ISC_R_SUCCESS);
}
static inline void
-deschedule(isc__timer_t *timer) {
-#ifdef USE_TIMER_THREAD
+deschedule(isc_timer_t *timer) {
+#ifdef ISC_PLATFORM_USETHREADS
isc_boolean_t need_wakeup = ISC_FALSE;
#endif
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
/*
* The caller must ensure locking.
manager = timer->manager;
if (timer->index > 0) {
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
if (timer->index == 1)
need_wakeup = ISC_TRUE;
#endif
timer->index = 0;
INSIST(manager->nscheduled > 0);
manager->nscheduled--;
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
if (need_wakeup) {
XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
ISC_MSG_SIGNALDESCHED,
"signal (deschedule)"));
SIGNAL(&manager->wakeup);
}
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
}
}
static void
-destroy(isc__timer_t *timer) {
- isc__timermgr_t *manager = timer->manager;
+destroy(isc_timer_t *timer) {
+ isc_timermgr_t *manager = timer->manager;
/*
* The caller must ensure it is safe to destroy the timer.
isc_task_detach(&timer->task);
DESTROYLOCK(&timer->lock);
- timer->common.impmagic = 0;
- timer->common.magic = 0;
+ timer->impmagic = 0;
+ timer->magic = 0;
isc_mem_put(manager->mctx, timer, sizeof(*timer));
}
isc_result_t
-isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
+isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_timer_t **timerp)
{
- isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
- isc__timer_t *timer;
+ isc_timer_t *timer;
isc_result_t result;
isc_time_t now;
return (result);
}
ISC_LINK_INIT(timer, link);
- timer->common.impmagic = TIMER_MAGIC;
- timer->common.magic = ISCAPI_TIMER_MAGIC;
- timer->common.methods = (isc_timermethods_t *)&timermethods;
+ timer->impmagic = TIMER_MAGIC;
+ timer->magic = ISCAPI_TIMER_MAGIC;
LOCK(&manager->lock);
UNLOCK(&manager->lock);
if (result != ISC_R_SUCCESS) {
- timer->common.impmagic = 0;
- timer->common.magic = 0;
+ timer->impmagic = 0;
+ timer->magic = 0;
DESTROYLOCK(&timer->lock);
isc_task_detach(&timer->task);
isc_mem_put(manager->mctx, timer, sizeof(*timer));
}
isc_result_t
-isc__timer_reset(isc_timer_t *timer0, isc_timertype_t type,
+isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_boolean_t purge)
{
- isc__timer_t *timer = (isc__timer_t *)timer0;
isc_time_t now;
- isc__timermgr_t *manager;
+ isc_timermgr_t *manager;
isc_result_t result;
/*
}
isc_timertype_t
-isc_timer_gettype(isc_timer_t *timer0) {
- isc__timer_t *timer = (isc__timer_t *)timer0;
+isc_timer_gettype(isc_timer_t *timer) {
isc_timertype_t t;
REQUIRE(VALID_TIMER(timer));
}
isc_result_t
-isc__timer_touch(isc_timer_t *timer0) {
- isc__timer_t *timer = (isc__timer_t *)timer0;
+isc_timer_touch(isc_timer_t *timer) {
isc_result_t result;
isc_time_t now;
}
void
-isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
- isc__timer_t *timer = (isc__timer_t *)timer0;
-
+isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
/*
* Attach *timerp to timer.
*/
}
void
-isc__timer_detach(isc_timer_t **timerp) {
- isc__timer_t *timer;
+isc_timer_detach(isc_timer_t **timerp) {
+ isc_timer_t *timer;
isc_boolean_t free_timer = ISC_FALSE;
/*
*/
REQUIRE(timerp != NULL);
- timer = (isc__timer_t *)*timerp;
+ timer = (isc_timer_t *)*timerp;
REQUIRE(VALID_TIMER(timer));
LOCK(&timer->lock);
}
static void
-dispatch(isc__timermgr_t *manager, isc_time_t *now) {
+dispatch(isc_timermgr_t *manager, isc_time_t *now) {
isc_boolean_t done = ISC_FALSE, post_event, need_schedule;
isc_timerevent_t *event;
isc_eventtype_t type = 0;
- isc__timer_t *timer;
+ isc_timer_t *timer;
isc_result_t result;
isc_boolean_t idle;
}
}
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
static isc_threadresult_t
#ifdef _WIN32 /* XXXDCL */
WINAPI
#endif
run(void *uap) {
- isc__timermgr_t *manager = uap;
+ isc_timermgr_t *manager = uap;
isc_time_t now;
isc_result_t result;
return ((isc_threadresult_t)0);
}
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
static isc_boolean_t
sooner(void *v1, void *v2) {
- isc__timer_t *t1, *t2;
+ isc_timer_t *t1, *t2;
t1 = v1;
t2 = v2;
static void
set_index(void *what, unsigned int index) {
- isc__timer_t *timer;
+ isc_timer_t *timer;
timer = what;
REQUIRE(VALID_TIMER(timer));
}
isc_result_t
-isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
- isc__timermgr_t *manager;
+isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
+ isc_timermgr_t *manager;
isc_result_t result;
/*
REQUIRE(managerp != NULL && *managerp == NULL);
-#ifdef USE_SHARED_MANAGER
+#ifndef ISC_PLATFORM_USETHREADS
if (timermgr != NULL) {
timermgr->refs++;
*managerp = (isc_timermgr_t *)timermgr;
return (ISC_R_SUCCESS);
}
-#endif /* USE_SHARED_MANAGER */
+#endif /* ISC_PLATFORM_USETHREADS */
manager = isc_mem_get(mctx, sizeof(*manager));
if (manager == NULL)
return (ISC_R_NOMEMORY);
- manager->common.impmagic = TIMER_MANAGER_MAGIC;
- manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
- manager->common.methods = (isc_timermgrmethods_t *)&timermgrmethods;
+ manager->impmagic = TIMER_MANAGER_MAGIC;
+ manager->magic = ISCAPI_TIMERMGR_MAGIC;
manager->mctx = NULL;
manager->done = ISC_FALSE;
INIT_LIST(manager->timers);
return (result);
}
isc_mem_attach(mctx, &manager->mctx);
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
if (isc_condition_init(&manager->wakeup) != ISC_R_SUCCESS) {
isc_mem_detach(&manager->mctx);
DESTROYLOCK(&manager->lock);
}
isc_thread_setname(manager->thread, "isc-timer");
#endif
-#ifdef USE_SHARED_MANAGER
+#ifndef ISC_PLATFORM_USETHREADS
manager->refs = 1;
timermgr = manager;
-#endif /* USE_SHARED_MANAGER */
+#endif /* ISC_PLATFORM_USETHREADS */
*managerp = (isc_timermgr_t *)manager;
}
void
-isc_timermgr_poke(isc_timermgr_t *manager0) {
-#ifdef USE_TIMER_THREAD
- isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
-
+isc_timermgr_poke(isc_timermgr_t *manager) {
+#ifdef ISC_PLATFORM_USETHREADS
REQUIRE(VALID_MANAGER(manager));
SIGNAL(&manager->wakeup);
#else
- UNUSED(manager0);
+ UNUSED(manager);
#endif
}
void
-isc__timermgr_destroy(isc_timermgr_t **managerp) {
- isc__timermgr_t *manager;
+isc_timermgr_destroy(isc_timermgr_t **managerp) {
+ isc_timermgr_t *manager;
isc_mem_t *mctx;
/*
*/
REQUIRE(managerp != NULL);
- manager = (isc__timermgr_t *)*managerp;
+ manager = (isc_timermgr_t *)*managerp;
REQUIRE(VALID_MANAGER(manager));
LOCK(&manager->lock);
-#ifdef USE_SHARED_MANAGER
+#ifndef ISC_PLATFORM_USETHREADS
manager->refs--;
if (manager->refs > 0) {
UNLOCK(&manager->lock);
return;
}
timermgr = NULL;
-#endif /* USE_SHARED_MANAGER */
-
-#ifndef USE_TIMER_THREAD
- isc__timermgr_dispatch((isc_timermgr_t *)manager);
+ isc_timermgr_dispatch((isc_timermgr_t *)manager);
#endif
REQUIRE(EMPTY(manager->timers));
manager->done = ISC_TRUE;
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
ISC_MSG_SIGNALDESTROY, "signal (destroy)"));
SIGNAL(&manager->wakeup);
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
UNLOCK(&manager->lock);
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
/*
* Wait for thread to exit.
*/
"isc_thread_join() %s",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_FAILED, "failed"));
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
/*
* Clean up.
*/
-#ifdef USE_TIMER_THREAD
+#ifdef ISC_PLATFORM_USETHREADS
(void)isc_condition_destroy(&manager->wakeup);
-#endif /* USE_TIMER_THREAD */
+#endif /* ISC_PLATFORM_USETHREADS */
DESTROYLOCK(&manager->lock);
isc_heap_destroy(&manager->heap);
- manager->common.impmagic = 0;
- manager->common.magic = 0;
+ manager->impmagic = 0;
+ manager->magic = 0;
mctx = manager->mctx;
isc_mem_put(mctx, manager, sizeof(*manager));
isc_mem_detach(&mctx);
*managerp = NULL;
-#ifdef USE_SHARED_MANAGER
+#ifndef ISC_PLATFORM_USETHREADS
timermgr = NULL;
#endif
}
-#ifndef USE_TIMER_THREAD
+#ifndef ISC_PLATFORM_USETHREADS
isc_result_t
-isc__timermgr_nextevent(isc_timermgr_t *manager0, isc_time_t *when) {
- isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
-
-#ifdef USE_SHARED_MANAGER
- if (manager == NULL)
+isc_timermgr_nextevent(isc_timermgr_t *manager, isc_time_t *when) {
+ if (manager == NULL) {
manager = timermgr;
-#endif
- if (manager == NULL || manager->nscheduled == 0)
+ }
+ if (manager == NULL || manager->nscheduled == 0) {
return (ISC_R_NOTFOUND);
+ }
*when = manager->due;
return (ISC_R_SUCCESS);
}
void
-isc__timermgr_dispatch(isc_timermgr_t *manager0) {
- isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
+isc_timermgr_dispatch(isc_timermgr_t *manager) {
isc_time_t now;
-#ifdef USE_SHARED_MANAGER
- if (manager == NULL)
+ if (manager == NULL) {
manager = timermgr;
-#endif
- if (manager == NULL)
+ }
+ if (manager == NULL) {
return;
+ }
TIME_NOW(&now);
dispatch(manager, &now);
}
-#endif /* USE_TIMER_THREAD */
-
-isc_result_t
-isc__timer_register(void) {
- return (isc_timer_register(isc__timermgr_create));
-}
-
-static isc_mutex_t createlock;
-static isc_once_t once = ISC_ONCE_INIT;
-static isc_timermgrcreatefunc_t timermgr_createfunc = NULL;
-
-static void
-initialize(void) {
- RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
-}
-
-isc_result_t
-isc_timer_register(isc_timermgrcreatefunc_t createfunc) {
- isc_result_t result = ISC_R_SUCCESS;
-
- RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
-
- LOCK(&createlock);
- if (timermgr_createfunc == NULL)
- timermgr_createfunc = createfunc;
- else
- result = ISC_R_EXISTS;
- UNLOCK(&createlock);
-
- return (result);
-}
+#endif /* ISC_PLATFORM_USETHREADS */
isc_result_t
isc_timermgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
{
isc_result_t result;
- LOCK(&createlock);
-
- REQUIRE(timermgr_createfunc != NULL);
- result = (*timermgr_createfunc)(mctx, managerp);
-
- UNLOCK(&createlock);
-
- if (result == ISC_R_SUCCESS)
+ result = isc_timermgr_create(mctx, managerp);
+ if (result == ISC_R_SUCCESS) {
isc_appctx_settimermgr(actx, *managerp);
+ }
return (result);
}
-
-isc_result_t
-isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__timermgr_create(mctx, managerp));
-
- LOCK(&createlock);
-
- REQUIRE(timermgr_createfunc != NULL);
- result = (*timermgr_createfunc)(mctx, managerp);
-
- UNLOCK(&createlock);
-
- return (result);
-}
-
-void
-isc_timermgr_destroy(isc_timermgr_t **managerp) {
- REQUIRE(*managerp != NULL && ISCAPI_TIMERMGR_VALID(*managerp));
-
- if (isc_bind9)
- isc__timermgr_destroy(managerp);
- else
- (*managerp)->methods->destroy(managerp);
-
- ENSURE(*managerp == NULL);
-}
-
-isc_result_t
-isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
- const isc_time_t *expires, const isc_interval_t *interval,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_timer_t **timerp)
-{
- REQUIRE(ISCAPI_TIMERMGR_VALID(manager));
-
- if (isc_bind9)
- return (isc__timer_create(manager, type, expires, interval,
- task, action, arg, timerp));
-
- return (manager->methods->timercreate(manager, type, expires,
- interval, task, action, arg,
- timerp));
-}
-
-void
-isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
- REQUIRE(ISCAPI_TIMER_VALID(timer));
- REQUIRE(timerp != NULL && *timerp == NULL);
-
- if (isc_bind9)
- isc__timer_attach(timer, timerp);
- else
- timer->methods->attach(timer, timerp);
-
- ENSURE(*timerp == timer);
-}
-
-void
-isc_timer_detach(isc_timer_t **timerp) {
- REQUIRE(timerp != NULL && ISCAPI_TIMER_VALID(*timerp));
-
- if (isc_bind9)
- isc__timer_detach(timerp);
- else
- (*timerp)->methods->detach(timerp);
-
- ENSURE(*timerp == NULL);
-}
-
-isc_result_t
-isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
- const isc_time_t *expires, const isc_interval_t *interval,
- isc_boolean_t purge)
-{
- REQUIRE(ISCAPI_TIMER_VALID(timer));
-
- if (isc_bind9)
- return (isc__timer_reset(timer, type, expires,
- interval, purge));
-
- return (timer->methods->reset(timer, type, expires, interval, purge));
-}
-
-isc_result_t
-isc_timer_touch(isc_timer_t *timer) {
- REQUIRE(ISCAPI_TIMER_VALID(timer));
-
- if (isc_bind9)
- return (isc__timer_touch(timer));
-
- return (timer->methods->touch(timer));
-}
/*! \file */
isc_result_t
-isc__timermgr_nextevent(isc_timermgr_t *timermgr, isc_time_t *when);
+isc_timermgr_nextevent(isc_timermgr_t *timermgr, isc_time_t *when);
void
-isc__timermgr_dispatch(isc_timermgr_t *timermgr);
+isc_timermgr_dispatch(isc_timermgr_t *timermgr);
#endif /* ISC_TIMER_P_H */
static pthread_t blockedthread;
#endif /* ISC_PLATFORM_USETHREADS */
-/*%
- * The following are intended for internal use (indicated by "isc__"
- * prefix) but are not declared as static, allowing direct access from
- * unit tests etc.
- */
-isc_result_t isc__app_start(void);
-isc_result_t isc__app_ctxstart(isc_appctx_t *ctx);
-isc_result_t isc__app_onrun(isc_mem_t *mctx, isc_task_t *task,
- isc_taskaction_t action, void *arg);
-isc_result_t isc__app_ctxrun(isc_appctx_t *ctx);
-isc_result_t isc__app_run(void);
-isc_result_t isc__app_ctxshutdown(isc_appctx_t *ctx);
-isc_result_t isc__app_shutdown(void);
-isc_result_t isc__app_reload(void);
-isc_result_t isc__app_ctxsuspend(isc_appctx_t *ctx);
-void isc__app_ctxfinish(isc_appctx_t *ctx);
-void isc__app_finish(void);
-void isc__app_block(void);
-void isc__app_unblock(void);
-isc_result_t isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp);
-void isc__appctx_destroy(isc_appctx_t **ctxp);
-void isc__appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr);
-void isc__appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr);
-void isc__appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr);
-isc_result_t isc__app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx,
- isc_task_t *task, isc_taskaction_t action,
- void *arg);
+static isc_boolean_t is_running = ISC_FALSE;
/*
* The application context of this module. This implementation actually
#define APPCTX_MAGIC ISC_MAGIC('A', 'p', 'c', 'x')
#define VALID_APPCTX(c) ISC_MAGIC_VALID(c, APPCTX_MAGIC)
-typedef struct isc__appctx {
- isc_appctx_t common;
+typedef struct isc_appctx {
+ unsigned int impmagic;
+ unsigned int magic;
isc_mem_t *mctx;
isc_mutex_t lock;
isc_eventlist_t on_run;
isc_mutex_t readylock;
isc_condition_t ready;
#endif /* ISC_PLATFORM_USETHREADS */
-} isc__appctx_t;
-
-static isc__appctx_t isc_g_appctx;
+} isc_appctx_t;
-static struct {
- isc_appmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *run, *shutdown, *start, *reload, *finish, *block, *unblock;
-} appmethods = {
- {
- isc__appctx_destroy,
- isc__app_ctxstart,
- isc__app_ctxrun,
- isc__app_ctxsuspend,
- isc__app_ctxshutdown,
- isc__app_ctxfinish,
- isc__appctx_settaskmgr,
- isc__appctx_setsocketmgr,
- isc__appctx_settimermgr,
- isc__app_ctxonrun
- },
- (void *)isc__app_run,
- (void *)isc__app_shutdown,
- (void *)isc__app_start,
- (void *)isc__app_reload,
- (void *)isc__app_finish,
- (void *)isc__app_block,
- (void *)isc__app_unblock
-};
+static isc_appctx_t isc_g_appctx;
#ifdef HAVE_LINUXTHREADS
/*!
}
isc_result_t
-isc__app_ctxstart(isc_appctx_t *ctx0) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
+isc_app_ctxstart(isc_appctx_t *ctx) {
isc_result_t result;
int presult;
sigset_t sset;
}
isc_result_t
-isc__app_start(void) {
- isc_g_appctx.common.impmagic = APPCTX_MAGIC;
- isc_g_appctx.common.magic = ISCAPI_APPCTX_MAGIC;
- isc_g_appctx.common.methods = &appmethods.methods;
+isc_app_start(void) {
+ isc_g_appctx.impmagic = APPCTX_MAGIC;
+ isc_g_appctx.magic = ISCAPI_APPCTX_MAGIC;
isc_g_appctx.mctx = NULL;
/* The remaining members will be initialized in ctxstart() */
- return (isc__app_ctxstart((isc_appctx_t *)&isc_g_appctx));
+ return (isc_app_ctxstart((isc_appctx_t *)&isc_g_appctx));
}
isc_result_t
-isc__app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
+isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
void *arg)
{
- return (isc__app_ctxonrun((isc_appctx_t *)&isc_g_appctx, mctx,
+ return (isc_app_ctxonrun((isc_appctx_t *)&isc_g_appctx, mctx,
task, action, arg));
}
isc_result_t
-isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
+isc_app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_event_t *event;
isc_task_t *cloned_task = NULL;
isc_result_t result;
* Event loop for nonthreaded programs.
*/
static isc_result_t
-evloop(isc__appctx_t *ctx) {
+evloop(isc_appctx_t *ctx) {
isc_result_t result;
while (!ctx->want_shutdown) {
/*
* Check the reload (or suspend) case first for exiting the
* loop as fast as possible in case:
- * - the direct call to isc__taskmgr_dispatch() in
- * isc__app_ctxrun() completes all the tasks so far,
+ * - the direct call to isc_taskmgr_dispatch() in
+ * isc_app_ctxrun() completes all the tasks so far,
* - there is thus currently no active task, and
* - there is a timer event
*/
return (ISC_R_RELOAD);
}
- readytasks = isc__taskmgr_ready(ctx->taskmgr);
+ readytasks = isc_taskmgr_ready(ctx->taskmgr);
if (readytasks) {
tv.tv_sec = 0;
tv.tv_usec = 0;
tvp = &tv;
call_timer_dispatch = ISC_TRUE;
} else {
- result = isc__timermgr_nextevent(ctx->timermgr, &when);
+ result = isc_timermgr_nextevent(ctx->timermgr, &when);
if (result != ISC_R_SUCCESS)
tvp = NULL;
else {
}
swait = NULL;
- n = isc__socketmgr_waitevents(ctx->socketmgr, tvp, &swait);
+ n = isc_socketmgr_waitevents(ctx->socketmgr, tvp, &swait);
if (n == 0 || call_timer_dispatch) {
/*
- * We call isc__timermgr_dispatch() only when
+ * We call isc_timermgr_dispatch() only when
* necessary, in order to reduce overhead. If the
* select() call indicates a timeout, we need the
* dispatch. Even if not, if we set the 0-timeout
* call, since this loop only runs in the non-thread
* mode.
*/
- isc__timermgr_dispatch(ctx->timermgr);
+ isc_timermgr_dispatch(ctx->timermgr);
}
if (n > 0)
- (void)isc__socketmgr_dispatch(ctx->socketmgr, swait);
- (void)isc__taskmgr_dispatch(ctx->taskmgr);
+ (void)isc_socketmgr_dispatch(ctx->socketmgr, swait);
+ (void)isc_taskmgr_dispatch(ctx->taskmgr);
}
return (ISC_R_SUCCESS);
}
static isc_boolean_t signalled = ISC_FALSE;
isc_result_t
-isc__nothread_wait_hack(isc_condition_t *cp, isc_mutex_t *mp) {
+isc_nothread_wait_hack(isc_condition_t *cp, isc_mutex_t *mp) {
isc_result_t result;
UNUSED(cp);
}
isc_result_t
-isc__nothread_signal_hack(isc_condition_t *cp) {
+isc_nothread_signal_hack(isc_condition_t *cp) {
UNUSED(cp);
#endif /* ISC_PLATFORM_USETHREADS */
isc_result_t
-isc__app_ctxrun(isc_appctx_t *ctx0) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
+isc_app_ctxrun(isc_appctx_t *ctx) {
int result;
isc_event_t *event, *next_event;
isc_task_t *task;
UNLOCK(&ctx->lock);
#ifndef ISC_PLATFORM_USETHREADS
- if (isc_bind9 && ctx == &isc_g_appctx) {
+ if (ctx == &isc_g_appctx) {
result = handle_signal(SIGHUP, reload_action);
if (result != ISC_R_SUCCESS)
return (ISC_R_SUCCESS);
}
- (void) isc__taskmgr_dispatch(ctx->taskmgr);
+ (void) isc_taskmgr_dispatch(ctx->taskmgr);
result = evloop(ctx);
return (result);
#else /* ISC_PLATFORM_USETHREADS */
* BIND9 internal tools using multiple contexts do not
* rely on signal.
*/
- if (isc_bind9 && ctx != &isc_g_appctx)
+ if (ctx != &isc_g_appctx) {
return (ISC_R_SUCCESS);
+ }
/*
* There is no danger if isc_app_shutdown() is called before we
*/
while (!ctx->want_shutdown) {
#ifdef HAVE_SIGWAIT
- if (isc_bind9) {
- /*
- * BIND9 internal; single context:
- * Wait for SIGHUP, SIGINT, or SIGTERM.
- */
- if (sigemptyset(&sset) != 0 ||
- sigaddset(&sset, SIGHUP) != 0 ||
- sigaddset(&sset, SIGINT) != 0 ||
- sigaddset(&sset, SIGTERM) != 0) {
- isc__strerror(errno, strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_run() sigsetops: %s",
- strbuf);
- return (ISC_R_UNEXPECTED);
- }
+ /*
+ * BIND9 internal; single context:
+ * Wait for SIGHUP, SIGINT, or SIGTERM.
+ */
+ if (sigemptyset(&sset) != 0 ||
+ sigaddset(&sset, SIGHUP) != 0 ||
+ sigaddset(&sset, SIGINT) != 0 ||
+ sigaddset(&sset, SIGTERM) != 0)
+ {
+ isc__strerror(errno, strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_run() sigsetops: %s",
+ strbuf);
+ return (ISC_R_UNEXPECTED);
+ }
#ifndef HAVE_UNIXWARE_SIGWAIT
- result = sigwait(&sset, &sig);
- if (result == 0) {
- if (sig == SIGINT || sig == SIGTERM)
- ctx->want_shutdown = ISC_TRUE;
- else if (sig == SIGHUP)
- ctx->want_reload = ISC_TRUE;
- }
+ result = sigwait(&sset, &sig);
+ if (result == 0) {
+ if (sig == SIGINT || sig == SIGTERM)
+ ctx->want_shutdown = ISC_TRUE;
+ else if (sig == SIGHUP)
+ ctx->want_reload = ISC_TRUE;
+ }
#else /* Using UnixWare sigwait semantics. */
- sig = sigwait(&sset);
- if (sig >= 0) {
- if (sig == SIGINT || sig == SIGTERM)
- ctx->want_shutdown = ISC_TRUE;
- else if (sig == SIGHUP)
- ctx->want_reload = ISC_TRUE;
- }
-#endif /* HAVE_UNIXWARE_SIGWAIT */
- } else {
- /*
- * External, or BIND9 using multiple contexts:
- * wait until woken up.
- */
- LOCK(&ctx->readylock);
- if (ctx->want_shutdown) {
- /* shutdown() won the race. */
- UNLOCK(&ctx->readylock);
- break;
- }
- if (!ctx->want_reload)
- WAIT(&ctx->ready, &ctx->readylock);
- UNLOCK(&ctx->readylock);
+ sig = sigwait(&sset);
+ if (sig >= 0) {
+ if (sig == SIGINT || sig == SIGTERM)
+ ctx->want_shutdown = ISC_TRUE;
+ else if (sig == SIGHUP)
+ ctx->want_reload = ISC_TRUE;
}
+#endif /* HAVE_UNIXWARE_SIGWAIT */
#else /* Don't have sigwait(). */
- if (isc_bind9) {
- /*
- * BIND9 internal; single context:
- * Install a signal handler for SIGHUP, then wait for
- * all signals.
- */
- result = handle_signal(SIGHUP, reload_action);
- if (result != ISC_R_SUCCESS)
- return (ISC_R_SUCCESS);
+ /*
+ * BIND9 internal; single context:
+ * Install a signal handler for SIGHUP, then wait for
+ * all signals.
+ */
+ result = handle_signal(SIGHUP, reload_action);
+ if (result != ISC_R_SUCCESS) {
+ return (ISC_R_SUCCESS);
+ }
- if (sigemptyset(&sset) != 0) {
- isc__strerror(errno, strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_run() sigsetops: %s",
- strbuf);
- return (ISC_R_UNEXPECTED);
- }
+ if (sigemptyset(&sset) != 0) {
+ isc__strerror(errno, strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_run() sigsetops: %s",
+ strbuf);
+ return (ISC_R_UNEXPECTED);
+ }
#ifdef HAVE_GPERFTOOLS_PROFILER
- if (sigaddset(&sset, SIGALRM) != 0) {
- isc__strerror(errno, strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_run() sigsetops: %s",
- strbuf);
- return (ISC_R_UNEXPECTED);
- }
-#endif
- (void)sigsuspend(&sset);
- } else {
- /*
- * External, or BIND9 using multiple contexts:
- * wait until woken up.
- */
- LOCK(&ctx->readylock);
- if (ctx->want_shutdown) {
- /* shutdown() won the race. */
- UNLOCK(&ctx->readylock);
- break;
- }
- if (!ctx->want_reload)
- WAIT(&ctx->ready, &ctx->readylock);
- UNLOCK(&ctx->readylock);
+ if (sigaddset(&sset, SIGALRM) != 0) {
+ isc__strerror(errno, strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_run() sigsetops: %s",
+ strbuf);
+ return (ISC_R_UNEXPECTED);
}
+#endif
+ (void)sigsuspend(&sset);
#endif /* HAVE_SIGWAIT */
if (ctx->want_reload) {
}
isc_result_t
-isc__app_run(void) {
- return (isc__app_ctxrun((isc_appctx_t *)&isc_g_appctx));
-}
-
-isc_result_t
-isc__app_ctxshutdown(isc_appctx_t *ctx0) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
+isc_app_ctxshutdown(isc_appctx_t *ctx) {
isc_boolean_t want_kill = ISC_TRUE;
#ifdef ISC_PLATFORM_USETHREADS
char strbuf[ISC_STRERRORSIZE];
UNLOCK(&ctx->lock);
if (want_kill) {
- if (isc_bind9 && ctx != &isc_g_appctx)
+ if (ctx != &isc_g_appctx) {
/* BIND9 internal, but using multiple contexts */
ctx->want_shutdown = ISC_TRUE;
- else {
+ } else {
#ifndef ISC_PLATFORM_USETHREADS
ctx->want_shutdown = ISC_TRUE;
#else /* ISC_PLATFORM_USETHREADS */
#ifdef HAVE_LINUXTHREADS
- if (isc_bind9) {
- /* BIND9 internal, single context */
- int result;
-
- result = pthread_kill(main_thread, SIGTERM);
- if (result != 0) {
- isc__strerror(result,
- strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_shutdown() "
- "pthread_kill: %s",
- strbuf);
- return (ISC_R_UNEXPECTED);
- }
+ /* BIND9 internal, single context */
+ int result;
+
+ result = pthread_kill(main_thread, SIGTERM);
+ if (result != 0) {
+ isc__strerror(result,
+ strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_shutdown() "
+ "pthread_kill: %s",
+ strbuf);
+ return (ISC_R_UNEXPECTED);
}
#else
- if (isc_bind9) {
- /* BIND9 internal, single context */
- if (kill(getpid(), SIGTERM) < 0) {
- isc__strerror(errno,
- strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_shutdown() "
- "kill: %s", strbuf);
- return (ISC_R_UNEXPECTED);
- }
+ /* BIND9 internal, single context */
+ if (kill(getpid(), SIGTERM) < 0) {
+ isc__strerror(errno,
+ strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_shutdown() "
+ "kill: %s", strbuf);
+ return (ISC_R_UNEXPECTED);
}
#endif /* HAVE_LINUXTHREADS */
- else {
- /* External, multiple contexts */
- LOCK(&ctx->readylock);
- ctx->want_shutdown = ISC_TRUE;
- UNLOCK(&ctx->readylock);
- SIGNAL(&ctx->ready);
- }
#endif /* ISC_PLATFORM_USETHREADS */
}
}
}
isc_result_t
-isc__app_shutdown(void) {
- return (isc__app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
+isc_app_shutdown(void) {
+ return (isc_app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
}
isc_result_t
-isc__app_ctxsuspend(isc_appctx_t *ctx0) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
+isc_app_ctxsuspend(isc_appctx_t *ctx) {
isc_boolean_t want_kill = ISC_TRUE;
#ifdef ISC_PLATFORM_USETHREADS
char strbuf[ISC_STRERRORSIZE];
UNLOCK(&ctx->lock);
if (want_kill) {
- if (isc_bind9 && ctx != &isc_g_appctx)
+ if (ctx != &isc_g_appctx) {
/* BIND9 internal, but using multiple contexts */
ctx->want_reload = ISC_TRUE;
- else {
+ } else {
#ifndef ISC_PLATFORM_USETHREADS
ctx->want_reload = ISC_TRUE;
#else /* ISC_PLATFORM_USETHREADS */
#ifdef HAVE_LINUXTHREADS
- if (isc_bind9) {
- /* BIND9 internal, single context */
- int result;
-
- result = pthread_kill(main_thread, SIGHUP);
- if (result != 0) {
- isc__strerror(result,
- strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_reload() "
- "pthread_kill: %s",
- strbuf);
- return (ISC_R_UNEXPECTED);
- }
+ /* BIND9 internal, single context */
+ int result;
+
+ result = pthread_kill(main_thread, SIGHUP);
+ if (result != 0) {
+ isc__strerror(result,
+ strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_reload() "
+ "pthread_kill: %s",
+ strbuf);
+ return (ISC_R_UNEXPECTED);
}
#else
- if (isc_bind9) {
- /* BIND9 internal, single context */
- if (kill(getpid(), SIGHUP) < 0) {
- isc__strerror(errno,
- strbuf, sizeof(strbuf));
- UNEXPECTED_ERROR(__FILE__, __LINE__,
- "isc_app_reload() "
- "kill: %s", strbuf);
- return (ISC_R_UNEXPECTED);
- }
+ /* BIND9 internal, single context */
+ if (kill(getpid(), SIGHUP) < 0) {
+ isc__strerror(errno,
+ strbuf, sizeof(strbuf));
+ UNEXPECTED_ERROR(__FILE__, __LINE__,
+ "isc_app_reload() "
+ "kill: %s", strbuf);
+ return (ISC_R_UNEXPECTED);
}
#endif /* HAVE_LINUXTHREADS */
- else {
- /* External, multiple contexts */
- LOCK(&ctx->readylock);
- ctx->want_reload = ISC_TRUE;
- UNLOCK(&ctx->readylock);
- SIGNAL(&ctx->ready);
- }
#endif /* ISC_PLATFORM_USETHREADS */
}
}
}
isc_result_t
-isc__app_reload(void) {
- return (isc__app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
+isc_app_reload(void) {
+ return (isc_app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
}
void
-isc__app_ctxfinish(isc_appctx_t *ctx0) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
-
+isc_app_ctxfinish(isc_appctx_t *ctx) {
REQUIRE(VALID_APPCTX(ctx));
DESTROYLOCK(&ctx->lock);
}
void
-isc__app_finish(void) {
- isc__app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
+isc_app_finish(void) {
+ isc_app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
}
void
-isc__app_block(void) {
+isc_app_block(void) {
#ifdef ISC_PLATFORM_USETHREADS
sigset_t sset;
#endif /* ISC_PLATFORM_USETHREADS */
}
void
-isc__app_unblock(void) {
+isc_app_unblock(void) {
#ifdef ISC_PLATFORM_USETHREADS
sigset_t sset;
#endif /* ISC_PLATFORM_USETHREADS */
#endif /* ISC_PLATFORM_USETHREADS */
}
+unsigned int
+isc_appctx_magic(isc_appctx_t *ctx) {
+ return (ctx->magic);
+}
+
isc_result_t
-isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
- isc__appctx_t *ctx;
+isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
+ isc_appctx_t *ctx;
REQUIRE(mctx != NULL);
REQUIRE(ctxp != NULL && *ctxp == NULL);
if (ctx == NULL)
return (ISC_R_NOMEMORY);
- ctx->common.impmagic = APPCTX_MAGIC;
- ctx->common.magic = ISCAPI_APPCTX_MAGIC;
- ctx->common.methods = &appmethods.methods;
+ ctx->impmagic = APPCTX_MAGIC;
+ ctx->magic = ISCAPI_APPCTX_MAGIC;
ctx->mctx = NULL;
isc_mem_attach(mctx, &ctx->mctx);
}
void
-isc__appctx_destroy(isc_appctx_t **ctxp) {
- isc__appctx_t *ctx;
+isc_appctx_destroy(isc_appctx_t **ctxp) {
+ isc_appctx_t *ctx;
REQUIRE(ctxp != NULL);
- ctx = (isc__appctx_t *)*ctxp;
+ ctx = (isc_appctx_t *)*ctxp;
REQUIRE(VALID_APPCTX(ctx));
isc_mem_putanddetach(&ctx->mctx, ctx, sizeof(*ctx));
}
void
-isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
-
+isc_appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr) {
REQUIRE(VALID_APPCTX(ctx));
ctx->taskmgr = taskmgr;
}
void
-isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
-
+isc_appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr) {
REQUIRE(VALID_APPCTX(ctx));
ctx->socketmgr = socketmgr;
}
void
-isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
- isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
-
+isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr) {
REQUIRE(VALID_APPCTX(ctx));
ctx->timermgr = timermgr;
}
-isc_result_t
-isc__app_register(void) {
- return (isc_app_register(isc__appctx_create));
+isc_boolean_t
+isc_app_isrunning() {
+ return (is_running);
}
-#include "../app_api.c"
+isc_result_t
+isc_app_run() {
+ isc_result_t result;
+
+ is_running = ISC_TRUE;
+ result = isc_app_ctxrun((isc_appctx_t *)&isc_g_appctx);
+ is_running = ISC_FALSE;
+
+ return (result);
+}
#include <inttypes.h> /* uintptr_t */
#endif
+#include <isc/app.h>
#include <isc/buffer.h>
#include <isc/bufferlist.h>
#include <isc/condition.h>
*/
#define NRETRIES 10
-typedef struct isc__socket isc__socket_t;
-typedef struct isc__socketmgr isc__socketmgr_t;
+#define NEWCONNSOCK(ev) ((isc_socket_t *)(ev)->newsocket)
-#define NEWCONNSOCK(ev) ((isc__socket_t *)(ev)->newsocket)
-
-struct isc__socket {
+struct isc_socket {
/* Not locked. */
- isc_socket_t common;
- isc__socketmgr_t *manager;
+ unsigned int impmagic;
+ unsigned int magic;
+ isc_socketmgr_t *manager;
isc_mutex_t lock;
isc_sockettype_t type;
const isc_statscounter_t *statsindex;
/* Locked by socket lock. */
- ISC_LINK(isc__socket_t) link;
+ ISC_LINK(isc_socket_t) link;
unsigned int references;
int fd;
int pf;
#define SOCKET_MANAGER_MAGIC ISC_MAGIC('I', 'O', 'm', 'g')
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, SOCKET_MANAGER_MAGIC)
-struct isc__socketmgr {
+struct isc_socketmgr {
/* Not locked. */
- isc_socketmgr_t common;
+ unsigned int impmagic;
+ unsigned int magic;
isc_mem_t *mctx;
isc_mutex_t lock;
isc_mutex_t *fdlock;
#endif
/* Locked by fdlock. */
- isc__socket_t **fds;
+ isc_socket_t **fds;
int *fdstate;
#if defined(USE_EPOLL)
uint32_t *epoll_events;
#endif
/* Locked by manager lock. */
- ISC_LIST(isc__socket_t) socklist;
+ ISC_LIST(isc_socket_t) socklist;
#ifdef USE_SELECT
fd_set *read_fds;
fd_set *read_fds_copy;
};
#ifdef USE_SHARED_MANAGER
-static isc__socketmgr_t *socketmgr = NULL;
+static isc_socketmgr_t *socketmgr = NULL;
#endif /* USE_SHARED_MANAGER */
#define CLOSED 0 /* this one must be zero */
# define MAXSCATTERGATHER_RECV (ISC_SOCKET_MAXSCATTERGATHER)
#endif
-static isc_result_t socket_create(isc_socketmgr_t *manager0, int pf,
+static isc_result_t socket_create(isc_socketmgr_t *manager, int pf,
isc_sockettype_t type,
isc_socket_t **socketp,
isc_socket_t *dup_socket);
-static void send_recvdone_event(isc__socket_t *, isc_socketevent_t **);
-static void send_senddone_event(isc__socket_t *, isc_socketevent_t **);
-static void send_connectdone_event(isc__socket_t *, isc_socket_connev_t **);
-static void free_socket(isc__socket_t **);
-static isc_result_t allocate_socket(isc__socketmgr_t *, isc_sockettype_t,
- isc__socket_t **);
-static void destroy(isc__socket_t **);
+static void send_recvdone_event(isc_socket_t *, isc_socketevent_t **);
+static void send_senddone_event(isc_socket_t *, isc_socketevent_t **);
+static void send_connectdone_event(isc_socket_t *, isc_socket_connev_t **);
+static void free_socket(isc_socket_t **);
+static isc_result_t allocate_socket(isc_socketmgr_t *, isc_sockettype_t,
+ isc_socket_t **);
+static void destroy(isc_socket_t **);
static void internal_accept(isc_task_t *, isc_event_t *);
static void internal_connect(isc_task_t *, isc_event_t *);
static void internal_recv(isc_task_t *, isc_event_t *);
static void internal_send(isc_task_t *, isc_event_t *);
static void internal_fdwatch_write(isc_task_t *, isc_event_t *);
static void internal_fdwatch_read(isc_task_t *, isc_event_t *);
-static void process_cmsg(isc__socket_t *, struct msghdr *, isc_socketevent_t *);
-static void build_msghdr_send(isc__socket_t *, isc_socketevent_t *,
+static void process_cmsg(isc_socket_t *, struct msghdr *, isc_socketevent_t *);
+static void build_msghdr_send(isc_socket_t *, isc_socketevent_t *,
struct msghdr *, struct iovec *, size_t *);
-static void build_msghdr_recv(isc__socket_t *, isc_socketevent_t *,
+static void build_msghdr_recv(isc_socket_t *, isc_socketevent_t *,
struct msghdr *, struct iovec *, size_t *);
#ifdef USE_WATCHER_THREAD
-static isc_boolean_t process_ctlfd(isc__socketmgr_t *manager);
-#endif
-static void setdscp(isc__socket_t *sock, isc_dscp_t dscp);
-
-/*%
- * The following are intended for internal use (indicated by "isc__"
- * prefix) but are not declared as static, allowing direct access from
- * unit tests etc.
- */
-
-isc_result_t
-isc__socket_open(isc_socket_t *sock0);
-isc_result_t
-isc__socket_close(isc_socket_t *sock0);
-isc_result_t
-isc__socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
- isc_socket_t **socketp);
-void
-isc__socket_attach(isc_socket_t *sock, isc_socket_t **socketp);
-void
-isc__socket_detach(isc_socket_t **socketp);
-isc_result_t
-isc__socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
- unsigned int minimum, isc_task_t *task,
- isc_taskaction_t action, void *arg);
-isc_result_t
-isc__socket_recv(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_taskaction_t action, void *arg);
-isc_result_t
-isc__socket_recv2(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_socketevent_t *event, unsigned int flags);
-isc_result_t
-isc__socket_send(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task, isc_taskaction_t action, void *arg);
-isc_result_t
-isc__socket_sendto(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
-isc_result_t
-isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
- isc_task_t *task, isc_taskaction_t action, void *arg);
-isc_result_t
-isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
-isc_result_t
-isc__socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
- isc_task_t *task, isc_taskaction_t action, void *arg,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
- unsigned int flags);
-isc_result_t
-isc__socket_sendto2(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task,
- const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
- isc_socketevent_t *event, unsigned int flags);
-isc_socketevent_t *
-isc_socket_socketevent(isc_mem_t *mctx, void *sender,
- isc_eventtype_t eventtype, isc_taskaction_t action,
- void *arg);
-
-void
-isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active);
-isc_result_t
-isc__socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group);
-isc_result_t
-isc__socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
- unsigned int options);
-isc_result_t
-isc__socket_filter(isc_socket_t *sock, const char *filter);
-isc_result_t
-isc__socket_listen(isc_socket_t *sock, unsigned int backlog);
-isc_result_t
-isc__socket_accept(isc_socket_t *sock,
- isc_task_t *task, isc_taskaction_t action, void *arg);
-isc_result_t
-isc__socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
- isc_task_t *task, isc_taskaction_t action,
- void *arg);
-isc_result_t
-isc__socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp);
-isc_result_t
-isc__socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp);
-void
-isc__socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how);
-isc_sockettype_t
-isc__socket_gettype(isc_socket_t *sock);
-isc_boolean_t
-isc__socket_isbound(isc_socket_t *sock);
-void
-isc__socket_ipv6only(isc_socket_t *sock, isc_boolean_t yes);
-void
-isc__socket_dscp(isc_socket_t *sock, isc_dscp_t dscp);
-isc_result_t
-isc__socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
- isc_sockfdwatch_t callback, void *cbarg,
- isc_task_t *task, isc_socket_t **socketp);
-isc_result_t
-isc__socket_fdwatchpoke(isc_socket_t *sock, int flags);
-isc_result_t
-isc__socket_dup(isc_socket_t *sock, isc_socket_t **socketp);
-int
-isc__socket_getfd(isc_socket_t *sock);
-
-isc_result_t
-isc__socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp);
-isc_result_t
-isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
- unsigned int maxsocks);
-isc_result_t
-isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager0, unsigned int *nsockp);
-void
-isc_socketmgr_setstats(isc_socketmgr_t *manager0, isc_stats_t *stats);
-void
-isc__socketmgr_destroy(isc_socketmgr_t **managerp);
-void
-isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag);
-const char *
-isc__socket_getname(isc_socket_t *socket0);
-void *
-isc__socket_gettag(isc_socket_t *socket0);
-
-#ifdef HAVE_LIBXML2
-void
-isc__socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer);
-#endif
-#ifdef HAVE_JSON
-isc_result_t
-isc__socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats);
+static isc_boolean_t process_ctlfd(isc_socketmgr_t *manager);
#endif
-
-static struct {
- isc_socketmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *recvv, *send, *sendv, *sendto2, *cleanunix, *permunix, *filter,
- *listen, *accept, *getpeername, *isbound;
-} socketmethods = {
- {
- isc__socket_attach,
- isc__socket_detach,
- isc__socket_bind,
- isc__socket_sendto,
- isc__socket_sendto2,
- isc__socket_connect,
- isc__socket_recv,
- isc__socket_recv2,
- isc__socket_cancel,
- isc__socket_getsockname,
- isc__socket_gettype,
- isc__socket_ipv6only,
- isc__socket_fdwatchpoke,
- isc__socket_dup,
- isc__socket_getfd,
- isc__socket_dscp
- },
- (void *)isc__socket_recvv, (void *)isc__socket_send,
- (void *)isc__socket_sendv, (void *)isc__socket_sendto2,
- (void *)isc__socket_cleanunix, (void *)isc__socket_permunix,
- (void *)isc__socket_filter, (void *)isc__socket_listen,
- (void *)isc__socket_accept, (void *)isc__socket_getpeername,
- (void *)isc__socket_isbound
-};
-
-static isc_socketmgrmethods_t socketmgrmethods = {
- isc__socketmgr_destroy,
- isc__socket_create,
- isc__socket_fdwatchcreate
-};
+static void setdscp(isc_socket_t *sock, isc_dscp_t dscp);
#define SELECT_POKE_SHUTDOWN (-1)
#define SELECT_POKE_NOTHING (-2)
#if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL) || \
defined(USE_WATCHER_THREAD)
static void
-manager_log(isc__socketmgr_t *sockmgr,
+manager_log(isc_socketmgr_t *sockmgr,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
const char *fmt, ...) ISC_FORMAT_PRINTF(5, 6);
static void
-manager_log(isc__socketmgr_t *sockmgr,
+manager_log(isc_socketmgr_t *sockmgr,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
const char *fmt, ...)
{
#endif
static void
-socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
+socket_log(isc_socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
isc_msgcat_t *msgcat, int msgset, int message,
const char *fmt, ...) ISC_FORMAT_PRINTF(9, 10);
static void
-socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
+socket_log(isc_socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
isc_msgcat_t *msgcat, int msgset, int message,
const char *fmt, ...)
* setting IPV6_V6ONLY.
*/
static void
-FIX_IPV6_RECVPKTINFO(isc__socket_t *sock)
+FIX_IPV6_RECVPKTINFO(isc_socket_t *sock)
{
char strbuf[ISC_STRERRORSIZE];
int on = 1;
}
static inline isc_result_t
-watch_fd(isc__socketmgr_t *manager, int fd, int msg) {
+watch_fd(isc_socketmgr_t *manager, int fd, int msg) {
isc_result_t result = ISC_R_SUCCESS;
#ifdef USE_KQUEUE
}
static inline isc_result_t
-unwatch_fd(isc__socketmgr_t *manager, int fd, int msg) {
+unwatch_fd(isc_socketmgr_t *manager, int fd, int msg) {
isc_result_t result = ISC_R_SUCCESS;
#ifdef USE_KQUEUE
}
static void
-wakeup_socket(isc__socketmgr_t *manager, int fd, int msg) {
+wakeup_socket(isc_socketmgr_t *manager, int fd, int msg) {
isc_result_t result;
int lockid = FDLOCK_ID(fd);
* will not get partial writes.
*/
static void
-select_poke(isc__socketmgr_t *mgr, int fd, int msg) {
+select_poke(isc_socketmgr_t *mgr, int fd, int msg) {
int cc;
int buf[2];
char strbuf[ISC_STRERRORSIZE];
* Read a message on the internal fd.
*/
static void
-select_readmsg(isc__socketmgr_t *mgr, int *fd, int *msg) {
+select_readmsg(isc_socketmgr_t *mgr, int *fd, int *msg) {
int buf[2];
int cc;
char strbuf[ISC_STRERRORSIZE];
* Update the state of the socketmgr when something changes.
*/
static void
-select_poke(isc__socketmgr_t *manager, int fd, int msg) {
+select_poke(isc_socketmgr_t *manager, int fd, int msg) {
if (msg == SELECT_POKE_SHUTDOWN)
return;
else if (fd >= 0)
* Process control messages received on a socket.
*/
static void
-process_cmsg(isc__socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) {
+process_cmsg(isc_socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) {
#ifdef ISC_NET_BSD44MSGHDR
#ifdef USE_CMSG
struct cmsghdr *cmsgp;
* this transaction can send.
*/
static void
-build_msghdr_send(isc__socket_t *sock, isc_socketevent_t *dev,
+build_msghdr_send(isc_socket_t *sock, isc_socketevent_t *dev,
struct msghdr *msg, struct iovec *iov, size_t *write_countp)
{
unsigned int iovcount;
* this transaction can receive.
*/
static void
-build_msghdr_recv(isc__socket_t *sock, isc_socketevent_t *dev,
+build_msghdr_recv(isc_socket_t *sock, isc_socketevent_t *dev,
struct msghdr *msg, struct iovec *iov, size_t *read_countp)
{
unsigned int iovcount;
}
static void
-set_dev_address(const isc_sockaddr_t *address, isc__socket_t *sock,
+set_dev_address(const isc_sockaddr_t *address, isc_socket_t *sock,
isc_socketevent_t *dev)
{
if (sock->type == isc_sockettype_udp) {
#define DOIO_EOF 3 /* EOF, no event sent */
static int
-doio_recv(isc__socket_t *sock, isc_socketevent_t *dev) {
+doio_recv(isc_socket_t *sock, isc_socketevent_t *dev) {
int cc;
struct iovec iov[MAXSCATTERGATHER_RECV];
size_t read_count;
* No other return values are possible.
*/
static int
-doio_send(isc__socket_t *sock, isc_socketevent_t *dev) {
+doio_send(isc_socket_t *sock, isc_socketevent_t *dev) {
int cc;
struct iovec iov[MAXSCATTERGATHER_SEND];
size_t write_count;
* references exist.
*/
static void
-socketclose(isc__socketmgr_t *manager, isc__socket_t *sock, int fd) {
+socketclose(isc_socketmgr_t *manager, isc_socket_t *sock, int fd) {
isc_sockettype_t type = sock->type;
int lockid = FDLOCK_ID(fd);
}
static void
-destroy(isc__socket_t **sockp) {
+destroy(isc_socket_t **sockp) {
int fd;
- isc__socket_t *sock = *sockp;
- isc__socketmgr_t *manager = sock->manager;
+ isc_socket_t *sock = *sockp;
+ isc_socketmgr_t *manager = sock->manager;
socket_log(sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
ISC_MSG_DESTROYING, "destroying");
}
static isc_result_t
-allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type,
- isc__socket_t **socketp)
+allocate_socket(isc_socketmgr_t *manager, isc_sockettype_t type,
+ isc_socket_t **socketp)
{
- isc__socket_t *sock;
+ isc_socket_t *sock;
isc_result_t result;
ISC_SOCKADDR_LEN_T cmsgbuflen;
if (sock == NULL)
return (ISC_R_NOMEMORY);
- sock->common.magic = 0;
- sock->common.impmagic = 0;
+ sock->magic = 0;
+ sock->impmagic = 0;
sock->references = 0;
sock->manager = manager;
*/
result = isc_mutex_init(&sock->lock);
if (result != ISC_R_SUCCESS) {
- sock->common.magic = 0;
- sock->common.impmagic = 0;
+ sock->magic = 0;
+ sock->impmagic = 0;
goto error;
}
ISC_EVENTATTR_NOPURGE, NULL, ISC_SOCKEVENT_INTW,
NULL, sock, sock, NULL, NULL);
- sock->common.magic = ISCAPI_SOCKET_MAGIC;
- sock->common.impmagic = SOCKET_MAGIC;
+ sock->magic = ISCAPI_SOCKET_MAGIC;
+ sock->impmagic = SOCKET_MAGIC;
*socketp = sock;
return (ISC_R_SUCCESS);
* also close the socket.
*/
static void
-free_socket(isc__socket_t **socketp) {
- isc__socket_t *sock = *socketp;
+free_socket(isc_socket_t **socketp) {
+ isc_socket_t *sock = *socketp;
INSIST(VALID_SOCKET(sock));
INSIST(sock->references == 0);
isc_mem_put(sock->manager->mctx, sock->sendcmsgbuf,
sock->sendcmsgbuflen);
- sock->common.magic = 0;
- sock->common.impmagic = 0;
+ sock->magic = 0;
+ sock->impmagic = 0;
DESTROYLOCK(&sock->lock);
#endif
static void
-use_min_mtu(isc__socket_t *sock) {
+use_min_mtu(isc_socket_t *sock) {
#if !defined(IPV6_USE_MIN_MTU) && !defined(IPV6_MTU)
UNUSED(sock);
#endif
}
static void
-set_tcp_maxseg(isc__socket_t *sock, int size) {
+set_tcp_maxseg(isc_socket_t *sock, int size) {
#ifdef TCP_MAXSEG
if (sock->type == isc_sockettype_tcp)
(void)setsockopt(sock->fd, IPPROTO_TCP, TCP_MAXSEG,
}
static isc_result_t
-opensocket(isc__socketmgr_t *manager, isc__socket_t *sock,
- isc__socket_t *dup_socket)
+opensocket(isc_socketmgr_t *manager, isc_socket_t *sock,
+ isc_socket_t *dup_socket)
{
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
* socket is returned in 'socketp'.
*/
static isc_result_t
-socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
+socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp, isc_socket_t *dup_socket)
{
- isc__socket_t *sock = NULL;
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
+ isc_socket_t *sock = NULL;
isc_result_t result;
int lockid;
sock->pf = pf;
- result = opensocket(manager, sock, (isc__socket_t *)dup_socket);
+ result = opensocket(manager, sock, (isc_socket_t *)dup_socket);
if (result != ISC_R_SUCCESS) {
free_socket(&sock);
return (result);
}
- sock->common.methods = (isc_socketmethods_t *)&socketmethods;
sock->references = 1;
*socketp = (isc_socket_t *)sock;
return (ISC_R_SUCCESS);
}
+unsigned int
+isc_socket_magic(isc_socket_t *sock) {
+ return (sock->magic);
+}
+
/*%
* Create a new 'type' socket managed by 'manager'. Events
* will be posted to 'task' and when dispatched 'action' will be
* in 'socketp'.
*/
isc_result_t
-isc__socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
+isc_socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp)
{
- return (socket_create(manager0, pf, type, socketp, NULL));
+ return (socket_create(manager, pf, type, socketp, NULL));
}
/*%
* in 'socketp'.
*/
isc_result_t
-isc__socket_dup(isc_socket_t *sock0, isc_socket_t **socketp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
return (socket_create((isc_socketmgr_t *) sock->manager,
sock->pf, sock->type, socketp,
- sock0));
+ sock));
}
isc_result_t
-isc__socket_open(isc_socket_t *sock0) {
+isc_socket_open(isc_socket_t *sock) {
isc_result_t result;
- isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
* in 'socketp'.
*/
isc_result_t
-isc__socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags,
+isc_socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
isc_sockfdwatch_t callback, void *cbarg,
isc_task_t *task, isc_socket_t **socketp)
{
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
- isc__socket_t *sock = NULL;
+ isc_socket_t *sock = NULL;
isc_result_t result;
int lockid;
sock->fdwatchtask = task;
sock->statsindex = fdwatchstatsindex;
- sock->common.methods = (isc_socketmethods_t *)&socketmethods;
sock->references = 1;
*socketp = (isc_socket_t *)sock;
*/
isc_result_t
-isc__socket_fdwatchpoke(isc_socket_t *sock0, int flags)
+isc_socket_fdwatchpoke(isc_socket_t *sock, int flags)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
REQUIRE(VALID_SOCKET(sock));
/*
* Attach to a socket. Caller must explicitly detach when it is done.
*/
void
-isc__socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
* up by destroying the socket.
*/
void
-isc__socket_detach(isc_socket_t **socketp) {
- isc__socket_t *sock;
+isc_socket_detach(isc_socket_t **socketp) {
+ isc_socket_t *sock;
isc_boolean_t kill_socket = ISC_FALSE;
REQUIRE(socketp != NULL);
- sock = (isc__socket_t *)*socketp;
+ sock = (isc_socket_t *)*socketp;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
}
isc_result_t
-isc__socket_close(isc_socket_t *sock0) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_close(isc_socket_t *sock) {
int fd;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
fflush(stdout);
REQUIRE(VALID_SOCKET(sock));
* The socket and manager must be locked before calling this function.
*/
static void
-dispatch_recv(isc__socket_t *sock) {
+dispatch_recv(isc_socket_t *sock) {
intev_t *iev;
isc_socketevent_t *ev;
isc_task_t *sender;
}
static void
-dispatch_send(isc__socket_t *sock) {
+dispatch_send(isc_socket_t *sock) {
intev_t *iev;
isc_socketevent_t *ev;
isc_task_t *sender;
* Dispatch an internal accept event.
*/
static void
-dispatch_accept(isc__socket_t *sock) {
+dispatch_accept(isc_socket_t *sock) {
intev_t *iev;
isc_socket_newconnev_t *ev;
}
static void
-dispatch_connect(isc__socket_t *sock) {
+dispatch_connect(isc_socket_t *sock) {
intev_t *iev;
isc_socket_connev_t *ev;
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_recvdone_event(isc__socket_t *sock, isc_socketevent_t **dev) {
+send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
isc_task_t *task;
task = (*dev)->ev_sender;
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_senddone_event(isc__socket_t *sock, isc_socketevent_t **dev) {
+send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
isc_task_t *task;
INSIST(dev != NULL && *dev != NULL);
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_connectdone_event(isc__socket_t *sock, isc_socket_connev_t **dev) {
+send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **dev) {
isc_task_t *task;
INSIST(dev != NULL && *dev != NULL);
*/
static void
internal_accept(isc_task_t *me, isc_event_t *ev) {
- isc__socket_t *sock;
- isc__socketmgr_t *manager;
+ isc_socket_t *sock;
+ isc_socketmgr_t *manager;
isc_socket_newconnev_t *dev;
isc_task_t *task;
ISC_SOCKADDR_LEN_T addrlen;
} else {
inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
NEWCONNSOCK(dev)->references--;
- free_socket((isc__socket_t **)&dev->newsocket);
+ free_socket((isc_socket_t **)&dev->newsocket);
}
/*
static void
internal_recv(isc_task_t *me, isc_event_t *ev) {
isc_socketevent_t *dev;
- isc__socket_t *sock;
+ isc_socket_t *sock;
INSIST(ev->ev_type == ISC_SOCKEVENT_INTR);
static void
internal_send(isc_task_t *me, isc_event_t *ev) {
isc_socketevent_t *dev;
- isc__socket_t *sock;
+ isc_socket_t *sock;
INSIST(ev->ev_type == ISC_SOCKEVENT_INTW);
/*
* Find out what socket this is and lock it.
*/
- sock = (isc__socket_t *)ev->ev_sender;
+ sock = (isc_socket_t *)ev->ev_sender;
INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock);
static void
internal_fdwatch_write(isc_task_t *me, isc_event_t *ev) {
- isc__socket_t *sock;
+ isc_socket_t *sock;
int more_data;
INSIST(ev->ev_type == ISC_SOCKEVENT_INTW);
/*
* Find out what socket this is and lock it.
*/
- sock = (isc__socket_t *)ev->ev_sender;
+ sock = (isc_socket_t *)ev->ev_sender;
INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock);
static void
internal_fdwatch_read(isc_task_t *me, isc_event_t *ev) {
- isc__socket_t *sock;
+ isc_socket_t *sock;
int more_data;
INSIST(ev->ev_type == ISC_SOCKEVENT_INTR);
/*
* Find out what socket this is and lock it.
*/
- sock = (isc__socket_t *)ev->ev_sender;
+ sock = (isc_socket_t *)ev->ev_sender;
INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock);
* and unlocking twice if both reads and writes are possible.
*/
static void
-process_fd(isc__socketmgr_t *manager, int fd, isc_boolean_t readable,
+process_fd(isc_socketmgr_t *manager, int fd, isc_boolean_t readable,
isc_boolean_t writeable)
{
- isc__socket_t *sock;
+ isc_socket_t *sock;
isc_boolean_t unlock_sock;
isc_boolean_t unwatch_read = ISC_FALSE, unwatch_write = ISC_FALSE;
int lockid = FDLOCK_ID(fd);
#ifdef USE_KQUEUE
static isc_boolean_t
-process_fds(isc__socketmgr_t *manager, struct kevent *events, int nevents) {
+process_fds(isc_socketmgr_t *manager, struct kevent *events, int nevents) {
int i;
isc_boolean_t readable, writable;
isc_boolean_t done = ISC_FALSE;
}
#elif defined(USE_EPOLL)
static isc_boolean_t
-process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents)
+process_fds(isc_socketmgr_t *manager, struct epoll_event *events, int nevents)
{
int i;
isc_boolean_t done = ISC_FALSE;
}
#elif defined(USE_DEVPOLL)
static isc_boolean_t
-process_fds(isc__socketmgr_t *manager, struct pollfd *events, int nevents) {
+process_fds(isc_socketmgr_t *manager, struct pollfd *events, int nevents) {
int i;
isc_boolean_t done = ISC_FALSE;
#ifdef USE_WATCHER_THREAD
}
#elif defined(USE_SELECT)
static void
-process_fds(isc__socketmgr_t *manager, int maxfd, fd_set *readfds,
+process_fds(isc_socketmgr_t *manager, int maxfd, fd_set *readfds,
fd_set *writefds)
{
int i;
#ifdef USE_WATCHER_THREAD
static isc_boolean_t
-process_ctlfd(isc__socketmgr_t *manager) {
+process_ctlfd(isc_socketmgr_t *manager) {
int msg, fd;
for (;;) {
*/
static isc_threadresult_t
watcher(void *uap) {
- isc__socketmgr_t *manager = uap;
+ isc_socketmgr_t *manager = uap;
isc_boolean_t done;
int cc;
#ifdef USE_KQUEUE
#endif /* USE_WATCHER_THREAD */
void
-isc__socketmgr_setreserved(isc_socketmgr_t *manager0, isc_uint32_t reserved) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
+isc_socketmgr_setreserved(isc_socketmgr_t *manager, isc_uint32_t reserved) {
+ REQUIRE(VALID_MANAGER(manager));
- REQUIRE(VALID_MANAGER(manager));
-
- manager->reserved = reserved;
+ manager->reserved = reserved;
}
void
-isc__socketmgr_maxudp(isc_socketmgr_t *manager0, int maxudp) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
-
+isc_socketmgr_maxudp(isc_socketmgr_t *manager, int maxudp) {
REQUIRE(VALID_MANAGER(manager));
manager->maxudp = maxudp;
*/
static isc_result_t
-setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
+setup_watcher(isc_mem_t *mctx, isc_socketmgr_t *manager) {
isc_result_t result;
#if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
char strbuf[ISC_STRERRORSIZE];
}
static void
-cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
+cleanup_watcher(isc_mem_t *mctx, isc_socketmgr_t *manager) {
#ifdef USE_WATCHER_THREAD
isc_result_t result;
#endif /* USE_KQUEUE */
}
+unsigned int
+isc_socketmgr_magic(isc_socketmgr_t *manager) {
+ return (manager->magic);
+}
+
isc_result_t
-isc__socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
- return (isc__socketmgr_create2(mctx, managerp, 0));
+isc_socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
+ return (isc_socketmgr_create2(mctx, managerp, 0));
}
isc_result_t
-isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
+isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
unsigned int maxsocks)
{
int i;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
#ifdef USE_WATCHER_THREAD
char strbuf[ISC_STRERRORSIZE];
#endif
manager->reserved = 0;
manager->maxudp = 0;
manager->fds = isc_mem_get(mctx,
- manager->maxsocks * sizeof(isc__socket_t *));
+ manager->maxsocks * sizeof(isc_socket_t *));
if (manager->fds == NULL) {
result = ISC_R_NOMEMORY;
goto free_manager;
#endif
manager->stats = NULL;
- manager->common.methods = &socketmgrmethods;
- manager->common.magic = ISCAPI_SOCKETMGR_MAGIC;
- manager->common.impmagic = SOCKET_MANAGER_MAGIC;
+ manager->magic = ISCAPI_SOCKETMGR_MAGIC;
+ manager->impmagic = SOCKET_MANAGER_MAGIC;
manager->mctx = NULL;
memset(manager->fds, 0, manager->maxsocks * sizeof(isc_socket_t *));
ISC_LIST_INIT(manager->socklist);
}
isc_result_t
-isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager0, unsigned int *nsockp) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
+isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager, unsigned int *nsockp) {
REQUIRE(VALID_MANAGER(manager));
REQUIRE(nsockp != NULL);
}
void
-isc_socketmgr_setstats(isc_socketmgr_t *manager0, isc_stats_t *stats) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
-
+isc_socketmgr_setstats(isc_socketmgr_t *manager, isc_stats_t *stats) {
REQUIRE(VALID_MANAGER(manager));
REQUIRE(ISC_LIST_EMPTY(manager->socklist));
REQUIRE(manager->stats == NULL);
}
void
-isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
- isc__socketmgr_t *manager;
+isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
+ isc_socketmgr_t *manager;
int i;
isc_mem_t *mctx;
*/
REQUIRE(managerp != NULL);
- manager = (isc__socketmgr_t *)*managerp;
+ manager = (isc_socketmgr_t *)*managerp;
REQUIRE(VALID_MANAGER(manager));
#ifdef USE_SHARED_MANAGER
manager->maxsocks * sizeof(uint32_t));
#endif
isc_mem_put(manager->mctx, manager->fds,
- manager->maxsocks * sizeof(isc__socket_t *));
+ manager->maxsocks * sizeof(isc_socket_t *));
isc_mem_put(manager->mctx, manager->fdstate,
manager->maxsocks * sizeof(int));
FDLOCK_COUNT * sizeof(isc_mutex_t));
}
DESTROYLOCK(&manager->lock);
- manager->common.magic = 0;
- manager->common.impmagic = 0;
+ manager->magic = 0;
+ manager->impmagic = 0;
mctx= manager->mctx;
isc_mem_put(mctx, manager, sizeof(*manager));
}
static isc_result_t
-socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
+socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
unsigned int flags)
{
int io_state;
}
isc_result_t
-isc__socket_recvv(isc_socket_t *sock0, isc_bufferlist_t *buflist,
+isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
unsigned int iocount;
isc_buffer_t *buffer;
}
isc_result_t
-isc__socket_recv(isc_socket_t *sock0, isc_region_t *region,
+isc_socket_recv(isc_socket_t *sock, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(action != NULL);
if (dev == NULL)
return (ISC_R_NOMEMORY);
- return (isc__socket_recv2(sock0, region, minimum, task, dev, 0));
+ return (isc_socket_recv2(sock, region, minimum, task, dev, 0));
}
isc_result_t
-isc__socket_recv2(isc_socket_t *sock0, isc_region_t *region,
+isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_socketevent_t *event, unsigned int flags)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
event->ev_sender = sock;
event->result = ISC_R_UNSET;
ISC_LIST_INIT(event->bufferlist);
}
static isc_result_t
-socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
+socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
}
isc_result_t
-isc__socket_send(isc_socket_t *sock, isc_region_t *region,
+isc_socket_send(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
/*
* REQUIRE() checking is performed in isc_socket_sendto().
*/
- return (isc__socket_sendto(sock, region, task, action, arg, NULL,
+ return (isc_socket_sendto(sock, region, task, action, arg, NULL,
NULL));
}
isc_result_t
-isc__socket_sendto(isc_socket_t *sock0, isc_region_t *region,
+isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(region != NULL);
}
isc_result_t
-isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
+isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
- return (isc__socket_sendtov2(sock, buflist, task, action, arg, NULL,
+ return (isc_socket_sendtov2(sock, buflist, task, action, arg, NULL,
NULL, 0));
}
isc_result_t
-isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
+isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
- return (isc__socket_sendtov2(sock, buflist, task, action, arg, address,
+ return (isc_socket_sendtov2(sock, buflist, task, action, arg, address,
pktinfo, 0));
}
isc_result_t
-isc__socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist,
+isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
unsigned int iocount;
isc_buffer_t *buffer;
}
isc_result_t
-isc__socket_sendto2(isc_socket_t *sock0, isc_region_t *region,
+isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
REQUIRE(VALID_SOCKET(sock));
REQUIRE((flags & ~(ISC_SOCKFLAG_IMMEDIATE|ISC_SOCKFLAG_NORETRY)) == 0);
if ((flags & ISC_SOCKFLAG_NORETRY) != 0)
}
void
-isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active) {
+isc_socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active) {
#ifdef ISC_PLATFORM_HAVESYSUNH
int s;
struct stat sb;
}
isc_result_t
-isc__socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
+isc_socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
isc_uint32_t owner, isc_uint32_t group)
{
#ifdef ISC_PLATFORM_HAVESYSUNH
}
isc_result_t
-isc__socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
+isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
char strbuf[ISC_STRERRORSIZE];
int on = 1;
#undef ENABLE_ACCEPTFILTER
isc_result_t
-isc__socket_filter(isc_socket_t *sock0, const char *filter) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_filter(isc_socket_t *sock, const char *filter) {
#if defined(SO_ACCEPTFILTER) && defined(ENABLE_ACCEPTFILTER)
char strbuf[ISC_STRERRORSIZE];
struct accept_filter_arg afa;
* Try enabling TCP Fast Open for a given socket if the OS supports it.
*/
static void
-set_tcp_fastopen(isc__socket_t *sock, unsigned int backlog) {
+set_tcp_fastopen(isc_socket_t *sock, unsigned int backlog) {
#if defined(ISC_PLATFORM_HAVETFO) && defined(TCP_FASTOPEN)
char strbuf[ISC_STRERRORSIZE];
* as well keep things simple rather than having to track them.
*/
isc_result_t
-isc__socket_listen(isc_socket_t *sock0, unsigned int backlog) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
char strbuf[ISC_STRERRORSIZE];
REQUIRE(VALID_SOCKET(sock));
* This should try to do aggressive accept() XXXMLG
*/
isc_result_t
-isc__socket_accept(isc_socket_t *sock0,
+isc_socket_accept(isc_socket_t *sock,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socket_newconnev_t *dev;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
isc_task_t *ntask = NULL;
- isc__socket_t *nsock;
+ isc_socket_t *nsock;
isc_result_t result;
isc_boolean_t do_poke = ISC_FALSE;
}
isc_result_t
-isc__socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
+isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
- isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socket_connev_t *dev;
isc_task_t *ntask = NULL;
- isc__socketmgr_t *manager;
+ isc_socketmgr_t *manager;
int cc;
char strbuf[ISC_STRERRORSIZE];
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
*/
static void
internal_connect(isc_task_t *me, isc_event_t *ev) {
- isc__socket_t *sock;
+ isc_socket_t *sock;
isc_socket_connev_t *dev;
int cc;
isc_result_t result;
}
isc_result_t
-isc__socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
isc_result_t result;
REQUIRE(VALID_SOCKET(sock));
}
isc_result_t
-isc__socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
ISC_SOCKADDR_LEN_T len;
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
* queued for task "task" of type "how". "how" is a bitmask.
*/
void
-isc__socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
REQUIRE(VALID_SOCKET(sock));
/*
ev_link);
NEWCONNSOCK(dev)->references--;
- free_socket((isc__socket_t **)&dev->newsocket);
+ free_socket((isc_socket_t **)&dev->newsocket);
dev->result = ISC_R_CANCELED;
dev->ev_sender = sock;
}
isc_sockettype_t
-isc__socket_gettype(isc_socket_t *sock0) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
-
+isc_socket_gettype(isc_socket_t *sock) {
REQUIRE(VALID_SOCKET(sock));
return (sock->type);
}
-isc_boolean_t
-isc__socket_isbound(isc_socket_t *sock0) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
- isc_boolean_t val;
-
- REQUIRE(VALID_SOCKET(sock));
-
- LOCK(&sock->lock);
- val = ((sock->bound) ? ISC_TRUE : ISC_FALSE);
- UNLOCK(&sock->lock);
-
- return (val);
-}
-
void
-isc__socket_ipv6only(isc_socket_t *sock0, isc_boolean_t yes) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_ipv6only(isc_socket_t *sock, isc_boolean_t yes) {
#if defined(IPV6_V6ONLY)
int onoff = yes ? 1 : 0;
#else
}
static void
-setdscp(isc__socket_t *sock, isc_dscp_t dscp) {
+setdscp(isc_socket_t *sock, isc_dscp_t dscp) {
#if defined(IP_TOS) || defined(IPV6_TCLASS)
int value = dscp << 2;
#endif
}
void
-isc__socket_dscp(isc_socket_t *sock0, isc_dscp_t dscp) {
- isc__socket_t *sock = (isc__socket_t *)sock0;
+isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(dscp < 0x40);
static isc_socketwait_t swait_private;
int
-isc__socketmgr_waitevents(isc_socketmgr_t *manager0, struct timeval *tvp,
+isc_socketmgr_waitevents(isc_socketmgr_t *manager, struct timeval *tvp,
isc_socketwait_t **swaitp)
{
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
int n;
#ifdef USE_KQUEUE
struct timespec ts, *tsp;
}
isc_result_t
-isc__socketmgr_dispatch(isc_socketmgr_t *manager0, isc_socketwait_t *swait) {
- isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
-
+isc_socketmgr_dispatch(isc_socketmgr_t *manager, isc_socketwait_t *swait) {
REQUIRE(swait == &swait_private);
#ifdef USE_SHARED_MANAGER
#endif /* USE_WATCHER_THREAD */
void
-isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_setname(isc_socket_t *sock, const char *name, void *tag) {
/*
* Name 'sock'.
*/
}
const char *
-isc__socket_getname(isc_socket_t *socket0) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_getname(isc_socket_t *sock) {
return (sock->name);
}
void *
-isc__socket_gettag(isc_socket_t *socket0) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_gettag(isc_socket_t *sock) {
return (sock->tag);
}
-isc_result_t
-isc__socket_register(void) {
- return (isc_socket_register(isc__socketmgr_create));
-}
-
int
-isc__socket_getfd(isc_socket_t *socket0) {
- isc__socket_t *sock = (isc__socket_t *)socket0;
-
+isc_socket_getfd(isc_socket_t *sock) {
return ((short) sock->fd);
}
#ifdef HAVE_LIBXML2
#define TRY0(a) do { xmlrc = (a); if (xmlrc < 0) goto error; } while(0)
int
-isc_socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer) {
- isc__socketmgr_t *mgr = (isc__socketmgr_t *)mgr0;
- isc__socket_t *sock = NULL;
+isc_socketmgr_renderxml(isc_socketmgr_t *mgr, xmlTextWriterPtr writer) {
+ isc_socket_t *sock = NULL;
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
ISC_SOCKADDR_LEN_T len;
} while(0)
isc_result_t
-isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) {
+isc_socketmgr_renderjson(isc_socketmgr_t *mgr, json_object *stats) {
isc_result_t result = ISC_R_SUCCESS;
- isc__socketmgr_t *mgr = (isc__socketmgr_t *)mgr0;
- isc__socket_t *sock = NULL;
+ isc_socket_t *sock = NULL;
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
ISC_SOCKADDR_LEN_T len;
}
#endif /* HAVE_JSON */
-#include "../socket_api.c"
+isc_result_t
+isc_socketmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
+ isc_socketmgr_t **managerp)
+{
+ isc_result_t result;
+
+ result = isc_socketmgr_create(mctx, managerp);
+ if (result == ISC_R_SUCCESS) {
+ isc_appctx_setsocketmgr(actx, *managerp);
+ }
+
+ return (result);
+}
isc__socket_recv
isc__socket_recv2
isc__socket_recvv
-isc__socket_register
isc__socket_send
isc__socket_sendto
isc__socket_sendto2
isc_app_finish
isc_app_isrunning
isc_app_onrun
-isc_app_register
isc_app_reload
isc_app_run
isc_app_shutdown
isc_lfsr_init
isc_lfsr_skip
isc_lib_initmsgcat
-isc_lib_register
isc_log_categorybyname
isc_log_closefilelogs
isc_log_create
isc_mem_maxinuse
isc_mem_printallactive
isc_mem_references
-isc_mem_register
@IF NOTYET
isc_mem_renderjson
@END NOTYET
isc_task_purge
isc_task_purgeevent
isc_task_purgerange
-isc_task_register
isc_task_send
isc_task_sendanddetach
isc_task_setname
isc_timer_create
isc_timer_detach
isc_timer_gettype
-isc_timer_register
isc_timer_reset
isc_timer_touch
isc_timermgr_create
isc__backtrace_nsymbols DATA
isc__backtrace_symtable DATA
-isc_bind9 DATA
isc_commandline_argument DATA
isc_commandline_errprint DATA
isc_commandline_index DATA
argv += isc_commandline_index;
/* Common set up */
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_lib_init failed: %u\n", result);
altserveraddr = cp + 1;
}
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_lib_init failed: %u\n", result);
query_array[i].xid = NULL;
}
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_lib_init failed: %u\n", result);
if (argc < 2)
usage();
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_lib_init failed: %u\n", result);
ISC_LIST_INIT(usedbuffers);
ISC_LIST_INIT(usedrdatalists);
ISC_LIST_INIT(prereqlist);
- isc_lib_register();
result = dns_lib_init();
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "dns_lib_init failed: %u\n", result);
./lib/isc/backtrace.c C 2009,2013,2014,2015,2016,2018
./lib/isc/base32.c C 2008,2009,2013,2014,2015,2016,2018
./lib/isc/base64.c C 1998,1999,2000,2001,2003,2004,2005,2007,2009,2013,2014,2015,2016,2018
-./lib/isc/bind9.c C 2013,2016,2018
./lib/isc/buffer.c C 1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2012,2014,2015,2016,2017,2018
./lib/isc/bufferlist.c C 1999,2000,2001,2004,2005,2007,2016,2018
./lib/isc/commandline.c C.PORTION 1999,2000,2001,2004,2005,2007,2008,2014,2015,2016,2018
./lib/isc/include/isc/backtrace.h C 2009,2016,2018
./lib/isc/include/isc/base32.h C 2008,2014,2016,2018
./lib/isc/include/isc/base64.h C 1999,2000,2001,2004,2005,2006,2007,2016,2018
-./lib/isc/include/isc/bind9.h C 2009,2013,2016,2018
./lib/isc/include/isc/boolean.h C 1998,1999,2000,2001,2004,2005,2006,2007,2016,2018
./lib/isc/include/isc/buffer.h C 1998,1999,2000,2001,2002,2004,2005,2006,2007,2008,2010,2012,2014,2016,2017,2018
./lib/isc/include/isc/bufferlist.h C 1999,2000,2001,2004,2005,2006,2007,2016,2018
./lib/isc/sha1.c C 2000,2001,2003,2004,2005,2007,2009,2011,2012,2014,2016,2017,2018
./lib/isc/sha2.c C 2005,2006,2007,2009,2011,2012,2014,2016,2017,2018
./lib/isc/sockaddr.c C 1999,2000,2001,2002,2003,2004,2005,2006,2007,2010,2011,2012,2014,2015,2016,2017,2018
-./lib/isc/socket_api.c C 2009,2011,2012,2013,2014,2015,2016,2018
./lib/isc/sparc64/Makefile.in MAKE 2007,2012,2016,2018
./lib/isc/sparc64/include/Makefile.in MAKE 2007,2012,2016,2018
./lib/isc/sparc64/include/isc/Makefile.in MAKE 2007,2012,2015,2016,2018
projects / thirdparty / bind9.git / commitdiff
