Files
Ondřej Surý f5c204ac3e Move the library init and shutdown to executables
Instead of relying on unreliable order of execution of the library
constructors and destructors, move them to individual binaries.  The
advantage is that the execution time and order will remain constant and
will not depend on the dynamic load dependency solver.

This requires more work, but that was mitigated by a simple requirement,
any executable using libisc and libdns, must include <isc/lib.h> and
<dns/lib.h> respectively (in this particular order).  In turn, these two
headers must not be included from within any library as they contain
inlined functions marked with constructor/destructor attributes.
2025-02-22 16:19:00 +01:00

311 lines
7.3 KiB
C

/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* 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 https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <isc/buffer.h>
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/mutex.h>
#include <isc/region.h>
#include <isc/result.h>
#include <isc/types.h>
#include <isc/util.h>
#include <isc/uv.h>
#include <dns/dyndb.h>
#include <dns/types.h>
#include <dns/view.h>
#include <dns/zone.h>
#include "dyndb_p.h"
#define CHECK(op) \
do { \
result = (op); \
if (result != ISC_R_SUCCESS) \
goto cleanup; \
} while (0)
typedef struct dyndb_implementation dyndb_implementation_t;
struct dyndb_implementation {
isc_mem_t *mctx;
uv_lib_t handle;
dns_dyndb_register_t *register_func;
dns_dyndb_destroy_t *destroy_func;
char *name;
void *inst;
LINK(dyndb_implementation_t) link;
};
/*
* List of dyndb implementations. Locked by dyndb_lock.
*
* These are stored here so they can be cleaned up on shutdown.
* (The order in which they are stored is not important.)
*/
static LIST(dyndb_implementation_t) dyndb_implementations;
/* Locks dyndb_implementations. */
static isc_mutex_t dyndb_lock;
void
dns__dyndb_initialize(void) {
isc_mutex_init(&dyndb_lock);
INIT_LIST(dyndb_implementations);
}
void
dns__dyndb_shutdown(void) {
isc_mutex_destroy(&dyndb_lock);
}
static dyndb_implementation_t *
impfind(const char *name) {
dyndb_implementation_t *imp;
for (imp = ISC_LIST_HEAD(dyndb_implementations); imp != NULL;
imp = ISC_LIST_NEXT(imp, link))
{
if (strcasecmp(name, imp->name) == 0) {
return imp;
}
}
return NULL;
}
static isc_result_t
load_symbol(uv_lib_t *handle, const char *filename, const char *symbol_name,
void **symbolp) {
void *symbol;
int r;
REQUIRE(handle != NULL);
REQUIRE(symbolp != NULL && *symbolp == NULL);
r = uv_dlsym(handle, symbol_name, &symbol);
if (r != 0) {
const char *errmsg = uv_dlerror(handle);
if (errmsg == NULL) {
errmsg = "returned function pointer is NULL";
}
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_ERROR,
"failed to lookup symbol %s in "
"DynDB module '%s': %s",
symbol_name, filename, errmsg);
return ISC_R_FAILURE;
}
*symbolp = symbol;
return ISC_R_SUCCESS;
}
static void
unload_library(dyndb_implementation_t **impp);
static isc_result_t
load_library(isc_mem_t *mctx, const char *filename, const char *instname,
dyndb_implementation_t **impp) {
isc_result_t result;
dyndb_implementation_t *imp = NULL;
dns_dyndb_version_t *version_func = NULL;
int version;
int r;
REQUIRE(impp != NULL && *impp == NULL);
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_INFO, "loading DynDB instance '%s' driver '%s'",
instname, filename);
imp = isc_mem_get(mctx, sizeof(*imp));
*imp = (dyndb_implementation_t){
.name = isc_mem_strdup(mctx, instname),
};
isc_mem_attach(mctx, &imp->mctx);
INIT_LINK(imp, link);
r = uv_dlopen(filename, &imp->handle);
if (r != 0) {
const char *errmsg = uv_dlerror(&imp->handle);
if (errmsg == NULL) {
errmsg = "unknown error";
}
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_ERROR,
"failed to dlopen() DynDB instance '%s' driver "
"'%s': %s",
instname, filename, errmsg);
CHECK(ISC_R_FAILURE);
}
CHECK(load_symbol(&imp->handle, filename, "dyndb_version",
(void **)&version_func));
version = version_func(NULL);
if (version < (DNS_DYNDB_VERSION - DNS_DYNDB_AGE) ||
version > DNS_DYNDB_VERSION)
{
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_ERROR,
"driver API version mismatch: %d/%d", version,
DNS_DYNDB_VERSION);
CHECK(ISC_R_FAILURE);
}
CHECK(load_symbol(&imp->handle, filename, "dyndb_init",
(void **)&imp->register_func));
CHECK(load_symbol(&imp->handle, filename, "dyndb_destroy",
(void **)&imp->destroy_func));
*impp = imp;
return ISC_R_SUCCESS;
cleanup:
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_ERROR,
"failed to dynamically load DynDB instance '%s' driver "
"'%s': %s",
instname, filename, isc_result_totext(result));
unload_library(&imp);
return result;
}
static void
unload_library(dyndb_implementation_t **impp) {
dyndb_implementation_t *imp;
REQUIRE(impp != NULL && *impp != NULL);
imp = *impp;
*impp = NULL;
/*
* This is a resource leak, but there is nothing we can currently do
* about it due to how configuration loading/reloading is designed.
*/
/* uv_dlclose(&imp->handle); */
isc_mem_free(imp->mctx, imp->name);
isc_mem_putanddetach(&imp->mctx, imp, sizeof(*imp));
}
isc_result_t
dns_dyndb_load(const char *libname, const char *name, const char *parameters,
const char *file, unsigned long line, isc_mem_t *mctx,
const dns_dyndbctx_t *dctx) {
isc_result_t result;
dyndb_implementation_t *implementation = NULL;
REQUIRE(DNS_DYNDBCTX_VALID(dctx));
REQUIRE(name != NULL);
LOCK(&dyndb_lock);
/* duplicate instance names are not allowed */
if (impfind(name) != NULL) {
CHECK(ISC_R_EXISTS);
}
CHECK(load_library(mctx, libname, name, &implementation));
CHECK(implementation->register_func(mctx, name, parameters, file, line,
dctx, &implementation->inst));
APPEND(dyndb_implementations, implementation, link);
result = ISC_R_SUCCESS;
cleanup:
if (result != ISC_R_SUCCESS) {
if (implementation != NULL) {
unload_library(&implementation);
}
}
UNLOCK(&dyndb_lock);
return result;
}
void
dns_dyndb_cleanup(void) {
dyndb_implementation_t *elem;
dyndb_implementation_t *prev;
LOCK(&dyndb_lock);
elem = TAIL(dyndb_implementations);
while (elem != NULL) {
prev = PREV(elem, link);
UNLINK(dyndb_implementations, elem, link);
isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DYNDB,
ISC_LOG_INFO, "unloading DynDB instance '%s'",
elem->name);
elem->destroy_func(&elem->inst);
ENSURE(elem->inst == NULL);
unload_library(&elem);
elem = prev;
}
UNLOCK(&dyndb_lock);
}
void
dns_dyndb_createctx(isc_mem_t *mctx, const void *hashinit, dns_view_t *view,
dns_zonemgr_t *zmgr, isc_loopmgr_t *loopmgr,
dns_dyndbctx_t **dctxp) {
dns_dyndbctx_t *dctx;
REQUIRE(dctxp != NULL && *dctxp == NULL);
dctx = isc_mem_get(mctx, sizeof(*dctx));
*dctx = (dns_dyndbctx_t){
.loopmgr = loopmgr,
.hashinit = hashinit,
};
if (view != NULL) {
dns_view_attach(view, &dctx->view);
}
if (zmgr != NULL) {
dns_zonemgr_attach(zmgr, &dctx->zmgr);
}
isc_mem_attach(mctx, &dctx->mctx);
dctx->magic = DNS_DYNDBCTX_MAGIC;
*dctxp = dctx;
}
void
dns_dyndb_destroyctx(dns_dyndbctx_t **dctxp) {
dns_dyndbctx_t *dctx;
REQUIRE(dctxp != NULL && DNS_DYNDBCTX_VALID(*dctxp));
dctx = *dctxp;
*dctxp = NULL;
dctx->magic = 0;
if (dctx->view != NULL) {
dns_view_detach(&dctx->view);
}
if (dctx->zmgr != NULL) {
dns_zonemgr_detach(&dctx->zmgr);
}
dctx->loopmgr = NULL;
isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(*dctx));
}