NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"linked to zlib version: %s", zlibVersion());
#endif
-#ifdef ISC_PLATFORM_USETHREADS
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"threads support is enabled");
-#else
- isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
- NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
- "threads support is disabled");
-#endif
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-
-#include <config.h>
-
-#include <stdbool.h>
-#include <unistd.h>
-
-#include <isc/app.h>
-#include <isc/magic.h>
-#include <isc/mutex.h>
-#include <isc/once.h>
-#include <isc/util.h>
-
-static bool is_running = false;
-
-#define ISCAPI_APPMETHODS_VALID(m) ISC_MAGIC_VALID(m, ISCAPI_APPMETHODS_MAGIC)
-
-isc_result_t
-isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
- return (isc__appctx_create(mctx, ctxp));
-}
-
-void
-isc_appctx_destroy(isc_appctx_t **ctxp) {
- REQUIRE(ctxp != NULL && ISCAPI_APPCTX_VALID(*ctxp));
-
- isc__appctx_destroy(ctxp);
- ENSURE(*ctxp == NULL);
-}
-
-isc_result_t
-isc_app_ctxstart(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- return (isc__app_ctxstart(ctx));
-}
-
-isc_result_t
-isc_app_ctxrun(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- return (isc__app_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));
-
- return (isc__app_ctxonrun(ctx, mctx, task, action, arg));
-}
-
-isc_result_t
-isc_app_ctxsuspend(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- return (isc__app_ctxsuspend(ctx));
-}
-
-isc_result_t
-isc_app_ctxshutdown(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- return (isc__app_ctxshutdown(ctx));
-}
-
-void
-isc_app_ctxfinish(isc_appctx_t *ctx) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
-
- isc__app_ctxfinish(ctx);
-}
-
-void
-isc_appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- REQUIRE(taskmgr != NULL);
-
- isc__appctx_settaskmgr(ctx, taskmgr);
-}
-
-void
-isc_appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- REQUIRE(socketmgr != NULL);
-
- isc__appctx_setsocketmgr(ctx, socketmgr);
-}
-
-void
-isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr) {
- REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- REQUIRE(timermgr != NULL);
-
- isc__appctx_settimermgr(ctx, timermgr);
-}
-
-isc_result_t
-isc_app_start(void) {
- return (isc__app_start());
-}
-
-isc_result_t
-isc_app_onrun(isc_mem_t *mctx, isc_task_t *task,
- isc_taskaction_t action, void *arg)
-{
- return (isc__app_onrun(mctx, task, action, arg));
-}
-
-isc_result_t
-isc_app_run() {
- isc_result_t result;
-
- is_running = ISC_TRUE;
- result = isc__app_run();
- is_running = ISC_FALSE;
-
- return (result);
-}
-
-bool
-isc_app_isrunning() {
- return (is_running);
-}
-
-isc_result_t
-isc_app_shutdown(void) {
- return (isc__app_shutdown());
-}
-
-isc_result_t
-isc_app_reload(void) {
- return (isc__app_reload());
-}
-
-void
-isc_app_finish(void) {
- isc__app_finish();
-}
-
-void
-isc_app_block(void) {
- isc__app_block();
-}
-
-void
-isc_app_unblock(void) {
- isc__app_unblock();
-}
* 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);
bool
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);
-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_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, bool priv);
-bool
-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);
-
static inline bool
empty_readyq(isc__taskmgr_t *manager);
}
isc_result_t
-isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
+isc_task_create(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp)
{
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
}
void
-isc__task_attach(isc_task_t *source0, isc_task_t **targetp) {
+isc_task_attach(isc_task_t *source0, isc_task_t **targetp) {
isc__task_t *source = (isc__task_t *)source0;
/*
}
void
-isc__task_detach(isc_task_t **taskp) {
+isc_task_detach(isc_task_t **taskp) {
isc__task_t *task;
bool was_idle;
}
void
-isc__task_send(isc_task_t *task0, isc_event_t **eventp) {
+isc_task_send(isc_task_t *task0, isc_event_t **eventp) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle;
}
void
-isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
+isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
bool idle1, idle2;
isc__task_t *task;
}
unsigned int
-isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
+isc_task_purgerange(isc_task_t *task0, 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;
+ REQUIRE(VALID_TASK(task));
/*
* Purge events from a task's event queue.
}
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)
{
/*
* Purge events from a task's event queue.
*/
+ REQUIRE(VALID_TASK(task));
XTRACE("isc_task_purge");
- return (isc__task_purgerange(task, sender, type, type, tag));
+ return (isc_task_purgerange(task, sender, type, type, tag));
}
bool
}
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)
{
/*
* Remove events from a task's event queue.
*/
+ REQUIRE(VALID_TASK(task));
XTRACE("isc_task_unsendrange");
}
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)
{
/*
}
isc_result_t
-isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
+isc_task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
void *arg)
{
isc__task_t *task = (isc__task_t *)task0;
}
void
-isc__task_shutdown(isc_task_t *task0) {
+isc_task_shutdown(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle;
}
void
-isc__task_destroy(isc_task_t **taskp) {
+isc_task_destroy(isc_task_t **taskp) {
/*
* Destroy '*taskp'.
}
void
-isc__task_setname(isc_task_t *task0, const char *name, void *tag) {
+isc_task_setname(isc_task_t *task0, const char *name, void *tag) {
isc__task_t *task = (isc__task_t *)task0;
/*
UNLOCK(&task->lock);
}
+
const char *
-isc__task_getname(isc_task_t *task0) {
+isc_task_getname(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
}
void *
-isc__task_gettag(isc_task_t *task0) {
+isc_task_gettag(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
}
void
-isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
+isc_task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
}
void
-isc__task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
+isc_task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
}
isc_result_t
-isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
+isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_taskmgr_t **managerp)
{
isc_result_t result;
}
void
-isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
+isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
isc__taskmgr_t *manager;
isc__task_t *task;
unsigned int i;
*/
LOCK(&manager->excl_lock);
if (manager->excl != NULL)
- isc__task_detach((isc_task_t **) &manager->excl);
+ isc_task_detach((isc_task_t **) &manager->excl);
UNLOCK(&manager->excl_lock);
/*
}
void
-isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
+isc_taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
LOCK(&manager->lock);
}
isc_taskmgrmode_t
-isc__taskmgr_mode(isc_taskmgr_t *manager0) {
+isc_taskmgr_mode(isc_taskmgr_t *manager0) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
isc_taskmgrmode_t mode;
LOCK(&manager->lock);
}
void
-isc__taskmgr_pause(isc_taskmgr_t *manager0) {
+isc_taskmgr_pause(isc_taskmgr_t *manager0) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
manager->pause_requested = true;
LOCK(&manager->lock);
}
void
-isc__taskmgr_resume(isc_taskmgr_t *manager0) {
+isc_taskmgr_resume(isc_taskmgr_t *manager0) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
LOCK(&manager->lock);
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);
+ isc_task_detach((isc_task_t **) &mgr->excl);
+ isc_task_attach(task0, (isc_task_t **) &mgr->excl);
UNLOCK(&mgr->excl_lock);
}
LOCK(&mgr->excl_lock);
if (mgr->excl != NULL)
- isc__task_attach((isc_task_t *) mgr->excl, taskp);
+ isc_task_attach((isc_task_t *) mgr->excl, taskp);
else
result = ISC_R_NOTFOUND;
UNLOCK(&mgr->excl_lock);
}
isc_result_t
-isc__task_beginexclusive(isc_task_t *task0) {
+isc_task_beginexclusive(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
+ REQUIRE(VALID_TASK(task));
REQUIRE(task->state == task_state_running);
/*
}
void
-isc__task_endexclusive(isc_task_t *task0) {
+isc_task_endexclusive(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
+ REQUIRE(VALID_TASK(task));
REQUIRE(task->state == task_state_running);
LOCK(&manager->lock);
REQUIRE(manager->exclusive_requested);
}
void
-isc__task_setprivilege(isc_task_t *task0, bool priv) {
+isc_task_setprivilege(isc_task_t *task0, bool priv) {
+ REQUIRE(ISCAPI_TASK_VALID(task0));
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
bool oldpriv;
}
bool
-isc__task_privilege(isc_task_t *task0) {
+isc_task_privilege(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
- bool priv;
+ isc_boolean_t priv;
+ REQUIRE(VALID_TASK(task));
LOCK(&task->lock);
priv = (task->flags & TASK_F_PRIVILEGED);
{
isc_result_t result;
- result = isc__taskmgr_create(mctx, workers, default_quantum,
+ result = isc_taskmgr_create(mctx, workers, default_quantum,
managerp);
if (result == ISC_R_SUCCESS)
return (result);
}
-isc_result_t
-isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
- unsigned int default_quantum, isc_taskmgr_t **managerp)
-{
- return (isc__taskmgr_create(mctx, workers,
- default_quantum, managerp));
-}
-
-void
-isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
- REQUIRE(managerp != NULL && ISCAPI_TASKMGR_VALID(*managerp));
-
- isc__taskmgr_destroy(managerp);
-
- ENSURE(*managerp == NULL);
-}
-
-void
-isc_taskmgr_setmode(isc_taskmgr_t *manager, isc_taskmgrmode_t mode) {
- REQUIRE(ISCAPI_TASKMGR_VALID(manager));
-
- isc__taskmgr_setmode(manager, mode);
-}
-
-isc_taskmgrmode_t
-isc_taskmgr_mode(isc_taskmgr_t *manager) {
- REQUIRE(ISCAPI_TASKMGR_VALID(manager));
-
- return (isc__taskmgr_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);
-
- return (isc__task_create(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);
-
- isc__task_attach(source, targetp);
-
- ENSURE(*targetp == source);
-}
-
-void
-isc_task_detach(isc_task_t **taskp) {
- REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
-
- isc__task_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);
-
- isc__task_send(task, eventp);
-}
-
-void
-isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
- REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
- REQUIRE(eventp != NULL && *eventp != NULL);
-
- isc__task_sendanddetach(taskp, eventp);
-
- 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));
-
- return (isc__task_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));
-
- return (isc__task_onshutdown(task, action, arg));
-}
-
-void
-isc_task_shutdown(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- isc__task_shutdown(task);
-}
-
-void
-isc_task_destroy(isc_task_t **taskp) {
- isc__task_destroy(taskp);
-}
-
-void
-isc_task_setname(isc_task_t *task, const char *name, void *tag) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- isc__task_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));
-
- return (isc__task_purge(task, sender, type, tag));
-}
-
-isc_result_t
-isc_task_beginexclusive(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- return (isc__task_beginexclusive(task));
-}
-
-void
-isc_task_endexclusive(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- isc__task_endexclusive(task);
-}
-
-void
-isc_task_setprivilege(isc_task_t *task, bool priv) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- isc__task_setprivilege(task, priv);
-}
-
-bool
-isc_task_privilege(isc_task_t *task) {
- REQUIRE(ISCAPI_TASK_VALID(task));
-
- return (isc__task_privilege(task));
-}
-
-void
-isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) {
- isc__task_getcurrenttime(task, t);
-}
-
-void
-isc_task_getcurrenttimex(isc_task_t *task, isc_time_t *t) {
- 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));
-
- return (isc__task_purgerange(task, sender, first, last, tag));
-}
* as an event loop dispatching various events.
*/
static pthread_t blockedthread;
-
-/*%
- * 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;
/*
* The application context of this module. This implementation actually
}
isc_result_t
-isc__app_ctxstart(isc_appctx_t *ctx0) {
+isc_app_ctxstart(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_result_t result;
int presult;
}
isc_result_t
-isc__app_start(void) {
+isc_app_start(void) {
isc_g_appctx.common.impmagic = APPCTX_MAGIC;
isc_g_appctx.common.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 *ctx0, isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
}
isc_result_t
-isc__app_ctxrun(isc_appctx_t *ctx0) {
+isc_app_ctxrun(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
int result;
isc_event_t *event, *next_event;
}
isc_result_t
-isc__app_run(void) {
- return (isc__app_ctxrun((isc_appctx_t *)&isc_g_appctx));
+isc_app_run(void) {
+ isc_result_t result;
+ is_running = ISC_TRUE;
+ result = isc_app_ctxrun((isc_appctx_t *)&isc_g_appctx);
+ is_running = ISC_FALSE;
+ return result;
+}
+
+isc_boolean_t
+isc_app_isrunning() {
+ return (is_running);
}
isc_result_t
-isc__app_ctxshutdown(isc_appctx_t *ctx0) {
+isc_app_ctxshutdown(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
char strbuf[ISC_STRERRORSIZE];
}
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_app_ctxsuspend(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
char strbuf[ISC_STRERRORSIZE];
}
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_app_ctxfinish(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
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) {
sigset_t sset;
REQUIRE(isc_g_appctx.running);
REQUIRE(!isc_g_appctx.blocked);
}
void
-isc__app_unblock(void) {
+isc_app_unblock(void) {
sigset_t sset;
REQUIRE(isc_g_appctx.running);
}
isc_result_t
-isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
+isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(mctx != NULL);
}
void
-isc__appctx_destroy(isc_appctx_t **ctxp) {
+isc_appctx_destroy(isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(ctxp != NULL);
}
void
-isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
+isc_appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
void
-isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
+isc_appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
void
-isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
+isc_appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
ctx->timermgr = timermgr;
}
-
-#include "../app_api.c"
*/
static isc_thread_t blockedthread;
+static isc_boolean_t is_running;
-/*%
- * 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);
-
-/*
- * The application context of this module. This implementation actually
- * doesn't use it. (This may change in the future).
- */
#define APPCTX_MAGIC ISC_MAGIC('A', 'p', 'c', 'x')
#define VALID_APPCTX(c) ISC_MAGIC_VALID(c, APPCTX_MAGIC)
static isc__appctx_t isc_g_appctx;
-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
-};
-
/*
* We need to remember which thread is the main thread...
*/
static isc_thread_t main_thread;
isc_result_t
-isc__app_ctxstart(isc_appctx_t *ctx0) {
+isc_app_ctxstart(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_result_t result;
}
isc_result_t
-isc__app_start(void) {
+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_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 *ctx0, isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
}
isc_result_t
-isc__app_ctxrun(isc_appctx_t *ctx0) {
+isc_app_ctxrun(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_event_t *event, *next_event;
isc_task_t *task;
}
isc_result_t
-isc__app_run(void) {
- return (isc__app_ctxrun((isc_appctx_t *)&isc_g_appctx));
+isc_app_run(void) {
+ isc_result_t result;
+ is_running = ISC_TRUE;
+ result = isc_app_ctxrun((isc_appctx_t *)&isc_g_appctx);
+ is_running = ISC_FALSE;
+ return result;
+}
+
+isc_boolean_t
+isc_app_isrunning() {
+ return (is_running);
}
isc_result_t
-isc__app_ctxshutdown(isc_appctx_t *ctx0) {
+isc_app_ctxshutdown(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
}
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_app_ctxsuspend(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
}
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_app_ctxfinish(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
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) {
REQUIRE(isc_g_appctx.running);
REQUIRE(!isc_g_appctx.blocked);
}
void
-isc__app_unblock(void) {
+isc_app_unblock(void) {
REQUIRE(isc_g_appctx.running);
REQUIRE(isc_g_appctx.blocked);
}
isc_result_t
-isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
+isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(mctx != NULL);
}
void
-isc__appctx_destroy(isc_appctx_t **ctxp) {
+isc_appctx_destroy(isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(ctxp != NULL);
}
void
-isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
+isc_appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
void
-isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
+isc_appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
void
-isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
+isc_appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
}
isc_result_t
-isc__app_register(void) {
+isc_app_register(void) {
return (isc_app_register(isc__appctx_create));
}
projects / thirdparty / bind9.git / commitdiff
