From: Ondřej Surý Date: Tue, 5 Jun 2018 12:36:22 +0000 (+0200) Subject: Remove the isc_bind9 internal flag and flatten the isc__ to isc_ namespace X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=2caba674025e40fb8a918ce93db82bf035439fbf;p=thirdparty%2Fbind9.git Remove the isc_bind9 internal flag and flatten the isc__ to isc_ namespace --- diff --git a/bin/delv/delv.c b/bin/delv/delv.c index 38af967357b..7335cab5ccc 100644 --- a/bin/delv/delv.c +++ b/bin/delv/delv.c @@ -1578,7 +1578,6 @@ main(int argc, char *argv[]) { argc--; argv++; - isc_lib_register(); result = dns_lib_init(); if (result != ISC_R_SUCCESS) fatal("dns_lib_init failed: %d", result); diff --git a/bin/named/main.c b/bin/named/main.c index a5f2c6d6441..6b2de473165 100644 --- a/bin/named/main.c +++ b/bin/named/main.c @@ -836,7 +836,7 @@ create_managers(void) { 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, diff --git a/bin/named/server.c b/bin/named/server.c index 1f827a8700c..fe3032d990e 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -7890,7 +7890,7 @@ load_configuration(const char *filename, named_server_t *server, "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 /* diff --git a/bin/tests/system/dyndb/driver/driver.c b/bin/tests/system/dyndb/driver/driver.c index bef6acb654a..bfc8a5b4489 100644 --- a/bin/tests/system/dyndb/driver/driver.c +++ b/bin/tests/system/dyndb/driver/driver.c @@ -76,11 +76,8 @@ dyndb_init(isc_mem_t *mctx, const char *name, const char *parameters, * 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); diff --git a/lib/dns/dyndb.c b/lib/dns/dyndb.c index e21a84c71e2..1376454225a 100644 --- a/lib/dns/dyndb.c +++ b/lib/dns/dyndb.c @@ -433,7 +433,6 @@ dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, isc_log_t *lctx, dctx->timermgr = tmgr; dctx->hashinit = hashinit; dctx->lctx = lctx; - dctx->refvar = &isc_bind9; isc_mem_attach(mctx, &dctx->mctx); dctx->magic = DNS_DYNDBCTX_MAGIC; diff --git a/lib/dns/openssl_link.c b/lib/dns/openssl_link.c index be36f098365..14232ed94af 100644 --- a/lib/dns/openssl_link.c +++ b/lib/dns/openssl_link.c @@ -102,19 +102,20 @@ mem_alloc(size_t size FLARG) { 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 * @@ -123,11 +124,11 @@ mem_realloc(void *ptr, size_t size FLARG) { 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 } diff --git a/lib/dns/view.c b/lib/dns/view.c index 8fbdd7bf85a..16597243fd8 100644 --- a/lib/dns/view.c +++ b/lib/dns/view.c @@ -119,15 +119,13 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass, 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; @@ -262,10 +260,9 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass, 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); diff --git a/lib/irs/context.c b/lib/irs/context.c index 7d3fbd3743d..5f28618e0ac 100644 --- a/lib/irs/context.c +++ b/lib/irs/context.c @@ -218,7 +218,6 @@ irs_context_create(irs_context_t **contextp) { irs_dnsconf_dnskeylist_t *trustedkeys; irs_dnsconf_dnskey_t *trustedkey; - isc_lib_register(); result = dns_lib_init(); if (result != ISC_R_SUCCESS) return (result); diff --git a/lib/isc/Makefile.in b/lib/isc/Makefile.in index 5edc5635b6e..4f97d130071 100644 --- a/lib/isc/Makefile.in +++ b/lib/isc/Makefile.in @@ -50,7 +50,7 @@ WIN32OBJS = win32/condition.@O@ win32/dir.@O@ win32/errno.@O@ \ # 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@ \ @@ -68,7 +68,7 @@ SYMTBLOBJS = backtrace-emptytbl.@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 \ diff --git a/lib/isc/app_api.c b/lib/isc/app_api.c deleted file mode 100644 index 5563c7cc0b7..00000000000 --- a/lib/isc/app_api.c +++ /dev/null @@ -1,252 +0,0 @@ -/* - * 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 - -#include - -#include -#include -#include -#include -#include - -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(); -} diff --git a/lib/isc/bind9.c b/lib/isc/bind9.c deleted file mode 100644 index 868d1087f86..00000000000 --- a/lib/isc/bind9.c +++ /dev/null @@ -1,25 +0,0 @@ -/* - * 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 - -#include - -/* - * 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; diff --git a/lib/isc/include/isc/app.h b/lib/isc/include/isc/app.h index 310adc7ec1f..63c93e8f68a 100644 --- a/lib/isc/include/isc/app.h +++ b/lib/isc/include/isc/app.h @@ -92,29 +92,6 @@ typedef isc_event_t isc_appevent_t; #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. @@ -124,18 +101,17 @@ typedef struct isc_appmethods { * 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); @@ -355,29 +331,6 @@ isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr); *\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 */ diff --git a/lib/isc/include/isc/bind9.h b/lib/isc/include/isc/bind9.h deleted file mode 100644 index 7edd7c070c9..00000000000 --- a/lib/isc/include/isc/bind9.h +++ /dev/null @@ -1,27 +0,0 @@ -/* - * 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 -#include - -/* - * 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 */ diff --git a/lib/isc/include/isc/lib.h b/lib/isc/include/isc/lib.h index 55ef20a4577..bc1f4976c4a 100644 --- a/lib/isc/include/isc/lib.h +++ b/lib/isc/include/isc/lib.h @@ -29,15 +29,6 @@ isc_lib_initmsgcat(void); * 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 */ diff --git a/lib/isc/include/isc/mem.h b/lib/isc/include/isc/mem.h index d2f2fcf1c0d..f3e26902c11 100644 --- a/lib/isc/include/isc/mem.h +++ b/lib/isc/include/isc/mem.h @@ -136,21 +136,6 @@ LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_defaultflags; #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. @@ -180,44 +165,6 @@ LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_defaultflags; * \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. @@ -227,11 +174,7 @@ typedef struct isc_mempoolmethods { * 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 && \ @@ -241,37 +184,12 @@ struct isc_mem { * 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, @@ -682,51 +600,36 @@ isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit); /* * 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 diff --git a/lib/isc/include/isc/socket.h b/lib/isc/include/isc/socket.h index e6f613b3292..344d150a1c2 100644 --- a/lib/isc/include/isc/socket.h +++ b/lib/isc/include/isc/socket.h @@ -59,55 +59,6 @@ #include #include -#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 /*** @@ -330,100 +281,23 @@ typedef enum { #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 @@ -1228,13 +1102,13 @@ int isc_socket_getfd(isc_socket_t *socket); */ 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'. */ @@ -1255,29 +1129,6 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr, json_object *stats); */ #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 */ diff --git a/lib/isc/include/isc/task.h b/lib/isc/include/isc/task.h index 24b351db408..f0514ddf277 100644 --- a/lib/isc/include/isc/task.h +++ b/lib/isc/include/isc/task.h @@ -145,29 +145,27 @@ typedef struct isc_taskmethods { * 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, @@ -811,31 +809,22 @@ isc_task_register(isc_taskmgrcreatefunc_t createfunc); * 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 diff --git a/lib/isc/include/isc/timer.h b/lib/isc/include/isc/timer.h index 6c7990b5cc7..0656bd0fe0e 100644 --- a/lib/isc/include/isc/timer.h +++ b/lib/isc/include/isc/timer.h @@ -129,12 +129,7 @@ typedef struct { * 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) @@ -143,11 +138,7 @@ struct isc_timermgr { * 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 && \ @@ -396,29 +387,6 @@ isc_timermgr_destroy(isc_timermgr_t **managerp); 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 */ diff --git a/lib/isc/include/isc/types.h b/lib/isc/include/isc/types.h index 7e9fe504d71..1c1e4042322 100644 --- a/lib/isc/include/isc/types.h +++ b/lib/isc/include/isc/types.h @@ -12,8 +12,6 @@ #ifndef ISC_TYPES_H #define ISC_TYPES_H 1 -#include - /*! \file isc/types.h * \brief * OS-specific types, from the OS-specific include directories. diff --git a/lib/isc/lib.c b/lib/isc/lib.c index 559ae1359b2..59b8b267975 100644 --- a/lib/isc/lib.c +++ b/lib/isc/lib.c @@ -76,22 +76,3 @@ isc_lib_initmsgcat(void) { 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); -} diff --git a/lib/isc/mem.c b/lib/isc/mem.c index ff541d54162..f684aae3b8e 100644 --- a/lib/isc/mem.c +++ b/lib/isc/mem.c @@ -19,7 +19,6 @@ #include -#include #include #include #include @@ -55,8 +54,6 @@ LIBISC_EXTERNAL_DATA unsigned int isc_mem_defaultflags = ISC_MEMFLAG_DEFAULT; /* * Types. */ -typedef struct isc__mem isc__mem_t; -typedef struct isc__mempool isc__mempool_t; #if ISC_MEM_TRACKLINES typedef struct debuglink debuglink_t; @@ -88,7 +85,7 @@ typedef struct { */ union { size_t size; - isc__mem_t *ctx; + isc_mem_t *ctx; char bytes[ALIGNMENT_SIZE]; } u; } size_info; @@ -105,11 +102,10 @@ struct stats { /* 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. @@ -117,8 +113,9 @@ static isc_mutex_t createlock; */ 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; @@ -142,7 +139,7 @@ struct isc__mem { 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 */ @@ -161,19 +158,20 @@ struct isc__mem { #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 */ @@ -214,170 +212,16 @@ struct isc__mempool { } 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; @@ -412,7 +256,7 @@ add_trace_entry(isc__mem_t *mctx, const void *ptr, size_t size FLARG) { } 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; @@ -473,7 +317,7 @@ quantize(size_t size) { } 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; @@ -551,7 +395,7 @@ more_basic_blocks(isc__mem_t *ctx) { } 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; @@ -613,7 +457,7 @@ more_frags(isc__mem_t *ctx, size_t new_size) { } 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; @@ -697,7 +541,7 @@ check_overrun(void *mem, size_t size, size_t new_size) { /* 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) { @@ -745,7 +589,7 @@ mem_putunlocked(isc__mem_t *ctx, void *mem, size_t 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 @@ -774,7 +618,7 @@ mem_get(isc__mem_t *ctx, size_t size) { */ /* 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; @@ -788,7 +632,7 @@ mem_put(isc__mem_t *ctx, void *mem, size_t size) { * 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; @@ -812,7 +656,7 @@ mem_getstats(isc__mem_t *ctx, size_t 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); @@ -851,7 +695,6 @@ default_memfree(void *arg, void *ptr) { 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; @@ -876,7 +719,7 @@ isc_mem_createx2(size_t init_max_size, size_t target_size, 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); @@ -919,9 +762,8 @@ isc_mem_createx2(size_t init_max_size, size_t target_size, 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; @@ -1013,16 +855,18 @@ isc_mem_createx2(size_t init_max_size, size_t target_size, } 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)); @@ -1091,9 +935,7 @@ destroy(isc__mem_t *ctx) { } 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); @@ -1105,12 +947,12 @@ isc__mem_attach(isc_mem_t *source0, isc_mem_t **targetp) { } 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); @@ -1137,14 +979,14 @@ isc__mem_detach(isc_mem_t **ctxp) { */ 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); @@ -1164,7 +1006,7 @@ isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG) { 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--; @@ -1200,8 +1042,8 @@ isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG) { } 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 @@ -1209,7 +1051,7 @@ isc__mem_destroy(isc_mem_t **ctxp) { */ REQUIRE(ctxp != NULL); - ctx = (isc__mem_t *)*ctxp; + ctx = (isc_mem_t *)*ctxp; REQUIRE(VALID_CONTEXT(ctx)); MCTXLOCK(ctx, &ctx->lock); @@ -1227,8 +1069,7 @@ isc__mem_destroy(isc_mem_t **ctxp) { } 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; @@ -1236,7 +1077,7 @@ isc___mem_get(isc_mem_t *ctx0, size_t size FLARG) { 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); @@ -1271,8 +1112,7 @@ isc___mem_get(isc_mem_t *ctx0, size_t size FLARG) { } 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; @@ -1290,7 +1130,7 @@ isc___mem_put(isc_mem_t *ctx0, void *ptr, size_t size FLARG) { 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; } @@ -1323,9 +1163,7 @@ isc___mem_put(isc_mem_t *ctx0, void *ptr, size_t size FLARG) { } 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); @@ -1338,7 +1176,7 @@ isc__mem_waterack(isc_mem_t *ctx0, int flag) { #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; @@ -1379,11 +1217,10 @@ print_active(isc__mem_t *mctx, FILE *out) { * 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); @@ -1461,8 +1298,7 @@ isc_mem_stats(isc_mem_t *ctx0, FILE *out) { */ 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; @@ -1485,8 +1321,7 @@ mem_allocateunlocked(isc_mem_t *ctx0, size_t 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; @@ -1525,8 +1360,7 @@ isc___mem_allocate(isc_mem_t *ctx0, size_t size FLARG) { } 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; @@ -1544,7 +1378,7 @@ isc___mem_reallocate(isc_mem_t *ctx0, void *ptr, size_t size FLARG) { * 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); @@ -1557,17 +1391,17 @@ isc___mem_reallocate(isc_mem_t *ctx0, void *ptr, size_t size FLARG) { } 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; @@ -1624,8 +1458,7 @@ isc___mem_free(isc_mem_t *ctx0, void *ptr FLARG) { */ 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; @@ -1634,7 +1467,7 @@ isc___mem_strdup(isc_mem_t *mctx0, const char *s FLARG) { 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); @@ -1643,9 +1476,7 @@ isc___mem_strdup(isc_mem_t *mctx0, const char *s FLARG) { } 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); @@ -1659,9 +1490,7 @@ isc__mem_setdestroycheck(isc_mem_t *ctx0, isc_boolean_t flag) { */ 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); @@ -1672,7 +1501,7 @@ isc_mem_setquota(isc_mem_t *ctx0, size_t quota) { 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)); @@ -1686,8 +1515,8 @@ isc_mem_getquota(isc_mem_t *ctx0) { } 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)); @@ -1701,8 +1530,8 @@ isc__mem_inuse(isc_mem_t *ctx0) { } 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)); @@ -1716,8 +1545,8 @@ isc__mem_maxinuse(isc_mem_t *ctx0) { } 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)); @@ -1731,10 +1560,9 @@ isc__mem_total(isc_mem_t *ctx0) { } 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; @@ -1768,8 +1596,8 @@ isc__mem_setwater(isc_mem_t *ctx0, isc_mem_water_t water, void *water_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)); @@ -1782,9 +1610,7 @@ isc__mem_isovermem(isc_mem_t *ctx0) { } 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); @@ -1795,7 +1621,7 @@ isc_mem_setname(isc_mem_t *ctx0, const char *name, void *tag) { 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)); @@ -1807,7 +1633,7 @@ isc_mem_getname(isc_mem_t *ctx0) { 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)); @@ -1819,9 +1645,8 @@ isc_mem_gettag(isc_mem_t *ctx0) { */ 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); @@ -1831,13 +1656,12 @@ isc__mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) { * 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; @@ -1863,9 +1687,7 @@ isc__mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) { } 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)); @@ -1884,19 +1706,19 @@ isc__mempool_setname(isc_mempool_t *mpctx0, const char *name) { } 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 @@ -1936,10 +1758,10 @@ isc__mempool_destroy(isc_mempool_t **mpctxp) { 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); @@ -1948,9 +1770,7 @@ isc__mempool_destroy(isc_mempool_t **mpctxp) { } 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); @@ -1959,10 +1779,10 @@ isc__mempool_associatelock(isc_mempool_t *mpctx0, isc_mutex_t *lock) { } 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)); @@ -2035,9 +1855,8 @@ isc___mempool_get(isc_mempool_t *mpctx0 FLARG) { /* 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)); @@ -2093,9 +1912,7 @@ isc___mempool_put(isc_mempool_t *mpctx0, void *mem FLARG) { */ 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) @@ -2109,7 +1926,7 @@ isc__mempool_setfreemax(isc_mempool_t *mpctx0, unsigned int limit) { 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)); @@ -2127,7 +1944,7 @@ isc_mempool_getfreemax(isc_mempool_t *mpctx0) { 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)); @@ -2144,9 +1961,7 @@ isc_mempool_getfreecount(isc_mempool_t *mpctx0) { } 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)); @@ -2162,7 +1977,7 @@ isc__mempool_setmaxalloc(isc_mempool_t *mpctx0, unsigned int limit) { 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)); @@ -2179,8 +1994,8 @@ isc_mempool_getmaxalloc(isc_mempool_t *mpctx0) { } 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)); @@ -2197,9 +2012,7 @@ isc__mempool_getallocated(isc_mempool_t *mpctx0) { } 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)); @@ -2214,7 +2027,7 @@ isc__mempool_setfillcount(isc_mempool_t *mpctx0, unsigned int limit) { 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; @@ -2231,33 +2044,27 @@ isc_mempool_getfillcount(isc_mempool_t *mpctx0) { 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; @@ -2271,6 +2078,7 @@ print_contexts(FILE *file) { } fflush(file); } +#endif void isc_mem_printallactive(FILE *file) { @@ -2307,7 +2115,7 @@ isc_mem_checkdestroyed(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)); @@ -2330,7 +2138,7 @@ typedef struct summarystat { #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; @@ -2440,7 +2248,7 @@ xml_renderctx(isc__mem_t *ctx, summarystat_t *summary, int isc_mem_renderxml(xmlTextWriterPtr writer) { - isc__mem_t *ctx; + isc_mem_t *ctx; summarystat_t summary; isc_uint64_t lost; int xmlrc; @@ -2520,7 +2328,7 @@ isc_mem_renderxml(xmlTextWriterPtr writer) { } 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]; @@ -2624,7 +2432,7 @@ json_renderctx(isc__mem_t *ctx, summarystat_t *summary, json_object *array) { 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; @@ -2682,352 +2490,18 @@ isc_mem_renderjson(json_object *memobj) { } #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); -} diff --git a/lib/isc/socket_api.c b/lib/isc/socket_api.c deleted file mode 100644 index 36b3d0e33dc..00000000000 --- a/lib/isc/socket_api.c +++ /dev/null @@ -1,397 +0,0 @@ -/* - * 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 - -#include -#include -#include -#include -#include -#include - -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)); -} diff --git a/lib/isc/task.c b/lib/isc/task.c index 7669045a5a3..0b197773cc9 100644 --- a/lib/isc/task.c +++ b/lib/isc/task.c @@ -88,13 +88,11 @@ static const char *statenames[] = { #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; @@ -109,9 +107,9 @@ struct isc__task { 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 @@ -123,11 +121,10 @@ struct isc__task { #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 @@ -136,9 +133,9 @@ struct isc__taskmgr { #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; @@ -157,7 +154,7 @@ struct isc__taskmgr { * 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 */ @@ -168,139 +165,32 @@ struct isc__taskmgr { #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); @@ -326,17 +216,21 @@ task_finished(isc__task_t *task) { 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; @@ -384,18 +278,15 @@ isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum, 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. */ @@ -413,7 +304,7 @@ isc__task_attach(isc_task_t *source0, isc_task_t **targetp) { } 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; @@ -457,10 +348,10 @@ task_shutdown(isc__task_t *task) { * 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)); @@ -478,7 +369,7 @@ task_ready(isc__task_t *task) { } static inline isc_boolean_t -task_detach(isc__task_t *task) { +task_detach(isc_task_t *task) { /* * Caller must be holding the task lock. @@ -507,8 +398,8 @@ task_detach(isc__task_t *task) { } 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; /* @@ -516,7 +407,7 @@ isc__task_detach(isc_task_t **taskp) { */ REQUIRE(taskp != NULL); - task = (isc__task_t *)*taskp; + task = (isc_task_t *)*taskp; REQUIRE(VALID_TASK(task)); XTRACE("isc_task_detach"); @@ -532,7 +423,7 @@ isc__task_detach(isc_task_t **taskp) { } 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; @@ -564,8 +455,7 @@ task_send(isc__task_t *task, isc_event_t **eventp) { } 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; /* @@ -606,9 +496,9 @@ isc__task_send(isc_task_t *task0, isc_event_t **eventp) { } 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 @@ -616,7 +506,7 @@ isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) { */ REQUIRE(taskp != NULL); - task = (isc__task_t *)*taskp; + task = (isc_task_t *)*taskp; REQUIRE(VALID_TASK(task)); XTRACE("isc_task_sendanddetach"); @@ -642,7 +532,7 @@ isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) { #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) { @@ -683,10 +573,9 @@ dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first, } 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; @@ -716,7 +605,7 @@ isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first, } 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) { /* @@ -725,12 +614,11 @@ isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type, 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; /* @@ -773,7 +661,7 @@ 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_task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first, isc_eventtype_t last, void *tag, isc_eventlist_t *events) { @@ -783,12 +671,12 @@ isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first, 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) { /* @@ -797,15 +685,14 @@ isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type, 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; @@ -842,8 +729,8 @@ isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action, } 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; /* @@ -856,12 +743,13 @@ isc__task_shutdown(isc_task_t *task0) { 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'. @@ -874,9 +762,7 @@ isc__task_destroy(isc_task_t **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'. */ @@ -890,27 +776,21 @@ isc__task_setname(isc_task_t *task0, const char *name, void *tag) { } 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); @@ -920,9 +800,7 @@ isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) { } 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); @@ -943,8 +821,8 @@ isc__task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) { * 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; @@ -962,9 +840,9 @@ empty_readyq(isc__taskmgr_t *manager) { * * 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); @@ -988,7 +866,7 @@ pop_readyq(isc__taskmgr_t *manager) { * 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, @@ -997,12 +875,12 @@ push_readyq(isc__taskmgr_t *manager, isc__task_t *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 */ @@ -1303,7 +1181,7 @@ static isc_threadresult_t 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")); @@ -1322,7 +1200,7 @@ run(void *uap) { #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 @@ -1333,8 +1211,8 @@ manager_free(isc__taskmgr_t *manager) { #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); @@ -1344,13 +1222,19 @@ manager_free(isc__taskmgr_t *manager) { #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. @@ -1377,9 +1261,8 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers, 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); @@ -1489,9 +1372,9 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers, } 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; /* @@ -1499,7 +1382,7 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) { */ REQUIRE(managerp != NULL); - manager = (isc__taskmgr_t *)*managerp; + manager = (isc_taskmgr_t *)*managerp; REQUIRE(VALID_MANAGER(manager)); #ifndef USE_WORKER_THREADS @@ -1527,8 +1410,9 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) { * 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); /* @@ -1584,10 +1468,10 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) { * 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; @@ -1608,17 +1492,14 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) { } 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; @@ -1628,8 +1509,7 @@ isc__taskmgr_mode(isc_taskmgr_t *manager0) { #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 @@ -1647,9 +1527,7 @@ isc__taskmgr_ready(isc_taskmgr_t *manager0) { } 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; @@ -1664,8 +1542,7 @@ isc__taskmgr_dispatch(isc_taskmgr_t *manager0) { #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) { @@ -1675,9 +1552,7 @@ isc__taskmgr_pause(isc_taskmgr_t *manager0) { } 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; @@ -1688,22 +1563,19 @@ isc__taskmgr_resume(isc_taskmgr_t *manager0) { #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)); @@ -1711,7 +1583,7 @@ isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) { 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); @@ -1720,10 +1592,9 @@ isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) { } 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); /* @@ -1748,10 +1619,9 @@ isc__task_beginexclusive(isc_task_t *task0) { } 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); @@ -1760,40 +1630,41 @@ isc__task_endexclusive(isc_task_t *task0) { 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); @@ -1802,14 +1673,9 @@ isc__task_privilege(isc_task_t *task0) { 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)); @@ -1819,9 +1685,8 @@ isc_task_exiting(isc_task_t *t) { #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); @@ -1928,10 +1793,9 @@ isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) { } 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); @@ -2031,32 +1895,6 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) { } #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, @@ -2064,268 +1902,12 @@ isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx, { 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); } diff --git a/lib/isc/tests/mem_test.c b/lib/isc/tests/mem_test.c index 60aa07e2f74..fe4a9cb07a5 100644 --- a/lib/isc/tests/mem_test.c +++ b/lib/isc/tests/mem_test.c @@ -273,7 +273,7 @@ ATF_TC_BODY(isc_mem_noflags, tc) { 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); @@ -324,7 +324,7 @@ ATF_TC_BODY(isc_mem_recordflag, tc) { 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); @@ -375,7 +375,7 @@ ATF_TC_BODY(isc_mem_traceflag, tc) { 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); diff --git a/lib/isc/tests/task_test.c b/lib/isc/tests/task_test.c index 49615f9b4a9..ee5af8d2cb5 100644 --- a/lib/isc/tests/task_test.c +++ b/lib/isc/tests/task_test.c @@ -140,8 +140,8 @@ ATF_TC_BODY(all_events, tc) { 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); } @@ -181,7 +181,7 @@ ATF_TC_BODY(privileged_events, tc) { * 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); @@ -241,14 +241,14 @@ ATF_TC_BODY(privileged_events, tc) { 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); } @@ -310,7 +310,7 @@ ATF_TC_BODY(privilege_drop, tc) { * 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); @@ -370,15 +370,15 @@ ATF_TC_BODY(privilege_drop, tc) { 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); } diff --git a/lib/isc/timer.c b/lib/isc/timer.c index e979b044b8c..e65a3e9fda7 100644 --- a/lib/isc/timer.c +++ b/lib/isc/timer.c @@ -34,16 +34,9 @@ #include #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)) @@ -65,13 +58,14 @@ #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; @@ -85,104 +79,49 @@ struct isc__timer { 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 @@ -192,13 +131,13 @@ schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) { 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. @@ -268,7 +207,7 @@ schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) { * 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 @@ -301,21 +240,21 @@ schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) { "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. @@ -323,7 +262,7 @@ deschedule(isc__timer_t *timer) { manager = timer->manager; if (timer->index > 0) { -#ifdef USE_TIMER_THREAD +#ifdef ISC_PLATFORM_USETHREADS if (timer->index == 1) need_wakeup = ISC_TRUE; #endif @@ -331,20 +270,20 @@ deschedule(isc__timer_t *timer) { 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. @@ -364,19 +303,18 @@ destroy(isc__timer_t *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; @@ -457,9 +395,8 @@ isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type, 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); @@ -478,8 +415,8 @@ isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type, 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)); @@ -492,13 +429,12 @@ isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type, } 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; /* @@ -568,8 +504,7 @@ isc__timer_reset(isc_timer_t *timer0, isc_timertype_t type, } 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)); @@ -582,8 +517,7 @@ isc_timer_gettype(isc_timer_t *timer0) { } 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; @@ -613,9 +547,7 @@ isc__timer_touch(isc_timer_t *timer0) { } 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. */ @@ -631,8 +563,8 @@ isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) { } 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; /* @@ -640,7 +572,7 @@ isc__timer_detach(isc_timer_t **timerp) { */ REQUIRE(timerp != NULL); - timer = (isc__timer_t *)*timerp; + timer = (isc_timer_t *)*timerp; REQUIRE(VALID_TIMER(timer)); LOCK(&timer->lock); @@ -657,11 +589,11 @@ isc__timer_detach(isc_timer_t **timerp) { } 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; @@ -775,13 +707,13 @@ dispatch(isc__timermgr_t *manager, isc_time_t *now) { } } -#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; @@ -820,11 +752,11 @@ run(void *uap) { 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; @@ -838,7 +770,7 @@ sooner(void *v1, void *v2) { static void set_index(void *what, unsigned int index) { - isc__timer_t *timer; + isc_timer_t *timer; timer = what; REQUIRE(VALID_TIMER(timer)); @@ -847,8 +779,8 @@ set_index(void *what, unsigned int index) { } 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; /* @@ -857,21 +789,20 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) { 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); @@ -891,7 +822,7 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) { 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); @@ -918,10 +849,10 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) { } 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; @@ -929,21 +860,19 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) { } 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; /* @@ -951,12 +880,12 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) { */ 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); @@ -964,24 +893,21 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) { 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. */ @@ -990,89 +916,56 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) { "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, @@ -1080,110 +973,10 @@ 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)); -} diff --git a/lib/isc/timer_p.h b/lib/isc/timer_p.h index 9a37675134c..c28552cbc1f 100644 --- a/lib/isc/timer_p.h +++ b/lib/isc/timer_p.h @@ -15,9 +15,9 @@ /*! \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 */ diff --git a/lib/isc/unix/app.c b/lib/isc/unix/app.c index 118729e9ab4..93a67da7022 100644 --- a/lib/isc/unix/app.c +++ b/lib/isc/unix/app.c @@ -59,33 +59,7 @@ 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 @@ -94,8 +68,9 @@ isc_result_t isc__app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx, #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; @@ -120,38 +95,9 @@ typedef struct isc__appctx { 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 /*! @@ -204,8 +150,7 @@ handle_signal(int sig, void (*handler)(int)) { } 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; @@ -376,29 +321,27 @@ isc__app_ctxstart(isc_appctx_t *ctx0) { } 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; @@ -438,7 +381,7 @@ isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task, * 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) { @@ -452,8 +395,8 @@ evloop(isc__appctx_t *ctx) { /* * 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 */ @@ -462,14 +405,14 @@ evloop(isc__appctx_t *ctx) { 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 { @@ -486,11 +429,11 @@ evloop(isc__appctx_t *ctx) { } 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 @@ -503,11 +446,11 @@ evloop(isc__appctx_t *ctx) { * 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); } @@ -535,7 +478,7 @@ static isc_boolean_t in_recursive_evloop = ISC_FALSE; 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); @@ -561,7 +504,7 @@ isc__nothread_wait_hack(isc_condition_t *cp, isc_mutex_t *mp) { } isc_result_t -isc__nothread_signal_hack(isc_condition_t *cp) { +isc_nothread_signal_hack(isc_condition_t *cp) { UNUSED(cp); @@ -574,8 +517,7 @@ isc__nothread_signal_hack(isc_condition_t *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; @@ -616,13 +558,13 @@ isc__app_ctxrun(isc_appctx_t *ctx0) { 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 */ @@ -630,8 +572,9 @@ isc__app_ctxrun(isc_appctx_t *ctx0) { * 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 @@ -641,98 +584,68 @@ isc__app_ctxrun(isc_appctx_t *ctx0) { */ 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) { @@ -749,13 +662,7 @@ isc__app_ctxrun(isc_appctx_t *ctx0) { } 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]; @@ -775,49 +682,38 @@ isc__app_ctxshutdown(isc_appctx_t *ctx0) { 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 */ } } @@ -826,13 +722,12 @@ isc__app_ctxshutdown(isc_appctx_t *ctx0) { } 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]; @@ -853,49 +748,38 @@ isc__app_ctxsuspend(isc_appctx_t *ctx0) { 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 */ } } @@ -904,26 +788,24 @@ isc__app_ctxsuspend(isc_appctx_t *ctx0) { } 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 */ @@ -941,7 +823,7 @@ isc__app_block(void) { } void -isc__app_unblock(void) { +isc_app_unblock(void) { #ifdef ISC_PLATFORM_USETHREADS sigset_t sset; #endif /* ISC_PLATFORM_USETHREADS */ @@ -961,9 +843,14 @@ isc__app_unblock(void) { #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); @@ -972,9 +859,8 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) { 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); @@ -989,11 +875,11 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) { } 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)); @@ -1002,35 +888,38 @@ isc__appctx_destroy(isc_appctx_t **ctxp) { } 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); +} diff --git a/lib/isc/unix/socket.c b/lib/isc/unix/socket.c index ae1b7498d68..9afde7cf418 100644 --- a/lib/isc/unix/socket.c +++ b/lib/isc/unix/socket.c @@ -38,6 +38,7 @@ #include /* uintptr_t */ #endif +#include #include #include #include @@ -324,21 +325,19 @@ typedef isc_event_t intev_t; */ #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; @@ -390,9 +389,10 @@ struct isc__socket { #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; @@ -423,7 +423,7 @@ struct isc__socketmgr { #endif /* Locked by fdlock. */ - isc__socket_t **fds; + isc_socket_t **fds; int *fdstate; #if defined(USE_EPOLL) uint32_t *epoll_events; @@ -433,7 +433,7 @@ struct isc__socketmgr { #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; @@ -452,7 +452,7 @@ struct isc__socketmgr { }; #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 */ @@ -469,202 +469,32 @@ static isc__socketmgr_t *socketmgr = NULL; # 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) @@ -787,11 +617,11 @@ static const isc_statscounter_t rawstatsindex[] = { #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, ...) { @@ -811,12 +641,12 @@ manager_log(isc__socketmgr_t *sockmgr, #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, ...) @@ -851,7 +681,7 @@ socket_log(isc__socket_t *sock, const isc_sockaddr_t *address, * 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; @@ -900,7 +730,7 @@ dec_stats(isc_stats_t *stats, isc_statscounter_t counterid) { } 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 @@ -980,7 +810,7 @@ watch_fd(isc__socketmgr_t *manager, int fd, int msg) { } 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 @@ -1073,7 +903,7 @@ unwatch_fd(isc__socketmgr_t *manager, int fd, int msg) { } 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); @@ -1141,7 +971,7 @@ wakeup_socket(isc__socketmgr_t *manager, int fd, int msg) { * 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]; @@ -1180,7 +1010,7 @@ select_poke(isc__socketmgr_t *mgr, int fd, int msg) { * 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]; @@ -1210,7 +1040,7 @@ select_readmsg(isc__socketmgr_t *mgr, int *fd, int *msg) { * 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) @@ -1313,7 +1143,7 @@ cmsg_space(ISC_SOCKADDR_LEN_T len) { * 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; @@ -1443,7 +1273,7 @@ process_cmsg(isc__socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) { * 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; @@ -1675,7 +1505,7 @@ build_msghdr_send(isc__socket_t *sock, isc_socketevent_t *dev, * 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; @@ -1790,7 +1620,7 @@ build_msghdr_recv(isc__socket_t *sock, isc_socketevent_t *dev, } 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) { @@ -1868,7 +1698,7 @@ dump_msg(struct msghdr *msg) { #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; @@ -2063,7 +1893,7 @@ doio_recv(isc__socket_t *sock, isc_socketevent_t *dev) { * 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; @@ -2182,7 +2012,7 @@ doio_send(isc__socket_t *sock, isc_socketevent_t *dev) { * 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); @@ -2250,10 +2080,10 @@ socketclose(isc__socketmgr_t *manager, isc__socket_t *sock, int 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"); @@ -2286,10 +2116,10 @@ destroy(isc__socket_t **sockp) { } 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; @@ -2298,8 +2128,8 @@ allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type, 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; @@ -2384,8 +2214,8 @@ allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type, */ 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; } @@ -2399,8 +2229,8 @@ allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type, 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); @@ -2425,8 +2255,8 @@ allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type, * 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); @@ -2447,8 +2277,8 @@ free_socket(isc__socket_t **socketp) { 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); @@ -2552,7 +2382,7 @@ clear_bsdcompat(void) { #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 @@ -2577,7 +2407,7 @@ use_min_mtu(isc__socket_t *sock) { } 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, @@ -2586,8 +2416,8 @@ set_tcp_maxseg(isc__socket_t *sock, int size) { } 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]; @@ -2973,11 +2803,10 @@ setup_done: * 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; @@ -3012,13 +2841,12 @@ socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type, 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; @@ -3054,6 +2882,11 @@ socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type, 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 @@ -3061,10 +2894,10 @@ socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type, * 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)); } /*% @@ -3072,21 +2905,18 @@ isc__socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type, * 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)); @@ -3137,12 +2967,11 @@ isc__socket_open(isc_socket_t *sock0) { * 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; @@ -3163,7 +2992,6 @@ isc__socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags, sock->fdwatchtask = task; sock->statsindex = fdwatchstatsindex; - sock->common.methods = (isc_socketmethods_t *)&socketmethods; sock->references = 1; *socketp = (isc_socket_t *)sock; @@ -3208,10 +3036,8 @@ isc__socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags, */ 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)); /* @@ -3242,9 +3068,7 @@ isc__socket_fdwatchpoke(isc_socket_t *sock0, int flags) * 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); @@ -3260,12 +3084,12 @@ isc__socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) { * 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); @@ -3282,10 +3106,9 @@ isc__socket_detach(isc_socket_t **socketp) { } 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)); @@ -3333,7 +3156,7 @@ isc__socket_close(isc_socket_t *sock0) { * 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; @@ -3367,7 +3190,7 @@ dispatch_recv(isc__socket_t *sock) { } 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; @@ -3404,7 +3227,7 @@ dispatch_send(isc__socket_t *sock) { * 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; @@ -3430,7 +3253,7 @@ dispatch_accept(isc__socket_t *sock) { } static void -dispatch_connect(isc__socket_t *sock) { +dispatch_connect(isc_socket_t *sock) { intev_t *iev; isc_socket_connev_t *ev; @@ -3460,7 +3283,7 @@ dispatch_connect(isc__socket_t *sock) { * 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; @@ -3483,7 +3306,7 @@ send_recvdone_event(isc__socket_t *sock, isc_socketevent_t **dev) { * 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); @@ -3507,7 +3330,7 @@ send_senddone_event(isc__socket_t *sock, isc_socketevent_t **dev) { * 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); @@ -3534,8 +3357,8 @@ send_connectdone_event(isc__socket_t *sock, isc_socket_connev_t **dev) { */ 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; @@ -3773,7 +3596,7 @@ internal_accept(isc_task_t *me, isc_event_t *ev) { } 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); } /* @@ -3797,7 +3620,7 @@ internal_accept(isc_task_t *me, isc_event_t *ev) { 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); @@ -3862,14 +3685,14 @@ internal_recv(isc_task_t *me, isc_event_t *ev) { 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); @@ -3916,7 +3739,7 @@ internal_send(isc_task_t *me, isc_event_t *ev) { 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); @@ -3924,7 +3747,7 @@ internal_fdwatch_write(isc_task_t *me, isc_event_t *ev) { /* * 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); @@ -3957,7 +3780,7 @@ internal_fdwatch_write(isc_task_t *me, isc_event_t *ev) { 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); @@ -3965,7 +3788,7 @@ internal_fdwatch_read(isc_task_t *me, isc_event_t *ev) { /* * 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); @@ -4001,10 +3824,10 @@ internal_fdwatch_read(isc_task_t *me, isc_event_t *ev) { * 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); @@ -4070,7 +3893,7 @@ check_write: #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; @@ -4112,7 +3935,7 @@ process_fds(isc__socketmgr_t *manager, struct kevent *events, int nevents) { } #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; @@ -4161,7 +3984,7 @@ process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents) } #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 @@ -4197,7 +4020,7 @@ process_fds(isc__socketmgr_t *manager, struct pollfd *events, int nevents) { } #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; @@ -4217,7 +4040,7 @@ process_fds(isc__socketmgr_t *manager, int maxfd, fd_set *readfds, #ifdef USE_WATCHER_THREAD static isc_boolean_t -process_ctlfd(isc__socketmgr_t *manager) { +process_ctlfd(isc_socketmgr_t *manager) { int msg, fd; for (;;) { @@ -4265,7 +4088,7 @@ process_ctlfd(isc__socketmgr_t *manager) { */ 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 @@ -4415,18 +4238,14 @@ watcher(void *uap) { #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; @@ -4437,7 +4256,7 @@ isc__socketmgr_maxudp(isc_socketmgr_t *manager0, int 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]; @@ -4608,7 +4427,7 @@ setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) { } 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; @@ -4647,17 +4466,22 @@ cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) { #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 @@ -4690,7 +4514,7 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp, 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; @@ -4711,9 +4535,8 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp, #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); @@ -4850,8 +4673,7 @@ free_manager: } 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); @@ -4861,9 +4683,7 @@ isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager0, unsigned int *nsockp) { } 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); @@ -4873,8 +4693,8 @@ isc_socketmgr_setstats(isc_socketmgr_t *manager0, isc_stats_t *stats) { } 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; @@ -4883,7 +4703,7 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) { */ REQUIRE(managerp != NULL); - manager = (isc__socketmgr_t *)*managerp; + manager = (isc_socketmgr_t *)*managerp; REQUIRE(VALID_MANAGER(manager)); #ifdef USE_SHARED_MANAGER @@ -4954,7 +4774,7 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) { 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)); @@ -4968,8 +4788,8 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) { 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)); @@ -4983,7 +4803,7 @@ isc__socketmgr_destroy(isc_socketmgr_t **managerp) { } 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; @@ -5055,13 +4875,12 @@ socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task, } 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; @@ -5110,13 +4929,12 @@ isc__socket_recvv(isc_socket_t *sock0, isc_bufferlist_t *buflist, } 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); @@ -5131,16 +4949,14 @@ isc__socket_recv(isc_socket_t *sock0, isc_region_t *region, 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); @@ -5165,7 +4981,7 @@ isc__socket_recv2(isc_socket_t *sock0, isc_region_t *region, } 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) { @@ -5259,24 +5075,23 @@ socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task, } 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); @@ -5299,31 +5114,30 @@ isc__socket_sendto(isc_socket_t *sock0, isc_region_t *region, } 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; @@ -5358,13 +5172,11 @@ isc__socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist, } 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) @@ -5381,7 +5193,7 @@ isc__socket_sendto2(isc_socket_t *sock0, isc_region_t *region, } 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; @@ -5511,7 +5323,7 @@ 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_socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm, isc_uint32_t owner, isc_uint32_t group) { #ifdef ISC_PLATFORM_HAVESYSUNH @@ -5567,10 +5379,9 @@ isc__socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm, } 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; @@ -5644,8 +5455,7 @@ isc__socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr, #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; @@ -5677,7 +5487,7 @@ isc__socket_filter(isc_socket_t *sock0, const char *filter) { * 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]; @@ -5747,8 +5557,7 @@ set_tcp_fastopen(isc__socket_t *sock, unsigned int backlog) { * 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)); @@ -5784,14 +5593,13 @@ isc__socket_listen(isc_socket_t *sock0, unsigned int backlog) { * 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; @@ -5859,13 +5667,12 @@ isc__socket_accept(isc_socket_t *sock0, } 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]; @@ -6018,7 +5825,7 @@ isc__socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr, */ 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; @@ -6134,8 +5941,7 @@ internal_connect(isc_task_t *me, isc_event_t *ev) { } 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)); @@ -6156,8 +5962,7 @@ isc__socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) { } 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]; @@ -6195,9 +6000,7 @@ isc__socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) { * 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)); /* @@ -6276,7 +6079,7 @@ isc__socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) { 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; @@ -6315,31 +6118,14 @@ isc__socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) { } 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 @@ -6371,7 +6157,7 @@ isc__socket_ipv6only(isc_socket_t *sock0, isc_boolean_t yes) { } 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 @@ -6415,8 +6201,7 @@ setdscp(isc__socket_t *sock, isc_dscp_t dscp) { } 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); @@ -6457,10 +6242,9 @@ isc_socket_socketevent(isc_mem_t *mctx, void *sender, 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; @@ -6557,9 +6341,7 @@ isc__socketmgr_waitevents(isc_socketmgr_t *manager0, struct timeval *tvp, } 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 @@ -6580,9 +6362,7 @@ isc__socketmgr_dispatch(isc_socketmgr_t *manager0, isc_socketwait_t *swait) { #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'. */ @@ -6596,28 +6376,17 @@ isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag) { } 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); } @@ -6641,9 +6410,8 @@ _socktype(isc_sockettype_t type) #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; @@ -6758,10 +6526,9 @@ isc_socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer) { } 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; @@ -6889,4 +6656,16 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) { } #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); +} diff --git a/lib/isc/win32/libisc.def.in b/lib/isc/win32/libisc.def.in index 45112ef3a04..7ba730989a3 100644 --- a/lib/isc/win32/libisc.def.in +++ b/lib/isc/win32/libisc.def.in @@ -87,7 +87,6 @@ isc__socket_permunix isc__socket_recv isc__socket_recv2 isc__socket_recvv -isc__socket_register isc__socket_send isc__socket_sendto isc__socket_sendto2 @@ -123,7 +122,6 @@ isc_app_ctxsuspend isc_app_finish isc_app_isrunning isc_app_onrun -isc_app_register isc_app_reload isc_app_run isc_app_shutdown @@ -351,7 +349,6 @@ isc_lfsr_generate32 isc_lfsr_init isc_lfsr_skip isc_lib_initmsgcat -isc_lib_register isc_log_categorybyname isc_log_closefilelogs isc_log_create @@ -404,7 +401,6 @@ isc_mem_isovermem isc_mem_maxinuse isc_mem_printallactive isc_mem_references -isc_mem_register @IF NOTYET isc_mem_renderjson @END NOTYET @@ -649,7 +645,6 @@ isc_task_privilege isc_task_purge isc_task_purgeevent isc_task_purgerange -isc_task_register isc_task_send isc_task_sendanddetach isc_task_setname @@ -705,7 +700,6 @@ isc_timer_attach isc_timer_create isc_timer_detach isc_timer_gettype -isc_timer_register isc_timer_reset isc_timer_touch isc_timermgr_create @@ -783,7 +777,6 @@ EXPORTS isc__backtrace_nsymbols DATA isc__backtrace_symtable DATA -isc_bind9 DATA isc_commandline_argument DATA isc_commandline_errprint DATA isc_commandline_index DATA diff --git a/lib/samples/nsprobe.c b/lib/samples/nsprobe.c index eb4b8af4f06..cfe952491d9 100644 --- a/lib/samples/nsprobe.c +++ b/lib/samples/nsprobe.c @@ -1057,7 +1057,6 @@ main(int argc, char *argv[]) { 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); diff --git a/lib/samples/resolve.c b/lib/samples/resolve.c index 628f863f627..ba167400d5c 100644 --- a/lib/samples/resolve.c +++ b/lib/samples/resolve.c @@ -361,7 +361,6 @@ main(int argc, char *argv[]) { altserveraddr = cp + 1; } - isc_lib_register(); result = dns_lib_init(); if (result != ISC_R_SUCCESS) { fprintf(stderr, "dns_lib_init failed: %u\n", result); diff --git a/lib/samples/sample-async.c b/lib/samples/sample-async.c index dfa1a052c91..42b2a1f25e3 100644 --- a/lib/samples/sample-async.c +++ b/lib/samples/sample-async.c @@ -321,7 +321,6 @@ main(int argc, char *argv[]) { 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); diff --git a/lib/samples/sample-request.c b/lib/samples/sample-request.c index e60a6df8592..c27394e1148 100644 --- a/lib/samples/sample-request.c +++ b/lib/samples/sample-request.c @@ -173,7 +173,6 @@ main(int argc, char *argv[]) { 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); diff --git a/lib/samples/sample-update.c b/lib/samples/sample-update.c index d452e434aca..8120afa7c44 100644 --- a/lib/samples/sample-update.c +++ b/lib/samples/sample-update.c @@ -235,7 +235,6 @@ main(int argc, char *argv[]) { 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); diff --git a/util/copyrights b/util/copyrights index 961b457cb7a..fc235f0bdd0 100644 --- a/util/copyrights +++ b/util/copyrights @@ -3479,7 +3479,6 @@ ./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 @@ -3510,7 +3509,6 @@ ./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 @@ -3670,7 +3668,6 @@ ./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