ComputerSurge/bind9
3
0
Fork 0
Code Pull Requests 1 Activity

Remove layering from isc_task and isc_app

Browse Source
This commit is contained in:
Witold Kręcicki
2018-08-06 16:27:02 +02:00
parent fb73a88f78
commit 446b58f36b
5 changed files with 113 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
bin/named/main.c
View File

@@ -1037,15 +1037,9 @@ setup(void) {
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,

161
lib/isc/app_api.c
View File

@@ -1,161 +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 <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();
}

307
lib/isc/task.c
View File

@@ -162,71 +162,12 @@ struct isc__taskmgr {
* 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);
@@ -272,7 +213,7 @@ task_finished(isc__task_t *task) {
}
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;
@@ -332,7 +273,7 @@ isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
}
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;
/*
@@ -442,7 +383,7 @@ task_detach(isc__task_t *task) {
}
void
isc__task_detach(isc_task_t **taskp) {
isc_task_detach(isc_task_t **taskp) {
isc__task_t *task;
bool was_idle;
@@ -499,7 +440,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_send(isc_task_t *task0, isc_event_t **eventp) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle;
@@ -541,7 +482,7 @@ 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) {
bool idle1, idle2;
isc__task_t *task;
@@ -618,13 +559,14 @@ 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 *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.
@@ -651,16 +593,17 @@ 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)
{
/*
* 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
@@ -708,13 +651,14 @@ 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)
{
/*
* Remove events from a task's event queue.
*/
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_unsendrange");
@@ -723,7 +667,7 @@ isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
}
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)
{
/*
@@ -737,7 +681,7 @@ isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
}
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;
@@ -777,7 +721,7 @@ isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
}
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;
@@ -796,7 +740,7 @@ isc__task_shutdown(isc_task_t *task0) {
}
void
isc__task_destroy(isc_task_t **taskp) {
isc_task_destroy(isc_task_t **taskp) {
/*
* Destroy '*taskp'.
@@ -809,7 +753,7 @@ isc__task_destroy(isc_task_t **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;
/*
@@ -824,8 +768,9 @@ isc__task_setname(isc_task_t *task0, const char *name, void *tag) {
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));
@@ -834,7 +779,7 @@ isc__task_getname(isc_task_t *task0) {
}
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));
@@ -843,7 +788,7 @@ isc__task_gettag(isc_task_t *task0) {
}
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));
@@ -855,7 +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_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
@@ -1238,7 +1183,7 @@ manager_free(isc__taskmgr_t *manager) {
}
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;
@@ -1356,7 +1301,7 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
}
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;
@@ -1383,7 +1328,7 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
*/
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);
/*
@@ -1440,7 +1385,7 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
}
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);
@@ -1449,7 +1394,7 @@ isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
}
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);
@@ -1459,7 +1404,7 @@ isc__taskmgr_mode(isc_taskmgr_t *manager0) {
}
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);
@@ -1470,7 +1415,7 @@ isc__taskmgr_pause(isc_taskmgr_t *manager0) {
}
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);
@@ -1490,8 +1435,8 @@ isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0) {
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);
}
@@ -1505,7 +1450,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);
@@ -1514,9 +1459,10 @@ 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 *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);
/*
@@ -1538,10 +1484,11 @@ isc__task_beginexclusive(isc_task_t *task0) {
}
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);
@@ -1551,7 +1498,8 @@ isc__task_endexclusive(isc_task_t *task0) {
}
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;
@@ -1578,9 +1526,10 @@ isc__task_setprivilege(isc_task_t *task0, bool priv) {
}
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);
@@ -1800,7 +1749,7 @@ isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
{
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)
@@ -1809,175 +1758,3 @@ isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
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));
}

90
lib/isc/unix/app.c
View File

@@ -50,34 +50,7 @@
* 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
@@ -165,7 +138,7 @@ handle_signal(int sig, void (*handler)(int)) {
}
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;
@@ -300,25 +273,25 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
}
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;
@@ -357,7 +330,7 @@ isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
}
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;
@@ -518,12 +491,21 @@ 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_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];
@@ -589,12 +571,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_app_ctxsuspend(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
char strbuf[ISC_STRERRORSIZE];
@@ -661,12 +643,12 @@ 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_app_ctxfinish(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@@ -675,12 +657,12 @@ isc__app_ctxfinish(isc_appctx_t *ctx0) {
}
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);
@@ -694,7 +676,7 @@ isc__app_block(void) {
}
void
isc__app_unblock(void) {
isc_app_unblock(void) {
sigset_t sset;
REQUIRE(isc_g_appctx.running);
@@ -711,7 +693,7 @@ isc__app_unblock(void) {
}
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);
@@ -737,7 +719,7 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
}
void
isc__appctx_destroy(isc_appctx_t **ctxp) {
isc_appctx_destroy(isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(ctxp != NULL);
@@ -750,7 +732,7 @@ isc__appctx_destroy(isc_appctx_t **ctxp) {
}
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));
@@ -759,7 +741,7 @@ isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
}
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));
@@ -768,12 +750,10 @@ isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
}
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"

123
lib/isc/win32/app.c
View File

@@ -40,39 +40,8 @@
*/
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)
@@ -112,42 +81,13 @@ typedef struct isc__appctx {
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;
@@ -180,26 +120,26 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
}
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;
@@ -238,7 +178,7 @@ isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
}
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;
@@ -311,12 +251,21 @@ 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_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;
@@ -340,12 +289,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_app_ctxsuspend(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
@@ -370,12 +319,12 @@ 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_app_ctxfinish(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@@ -384,12 +333,12 @@ isc__app_ctxfinish(isc_appctx_t *ctx0) {
}
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);
@@ -398,7 +347,7 @@ isc__app_block(void) {
}
void
isc__app_unblock(void) {
isc_app_unblock(void) {
REQUIRE(isc_g_appctx.running);
REQUIRE(isc_g_appctx.blocked);
@@ -407,7 +356,7 @@ isc__app_unblock(void) {
}
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);
@@ -434,7 +383,7 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
}
void
isc__appctx_destroy(isc_appctx_t **ctxp) {
isc_appctx_destroy(isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(ctxp != NULL);
@@ -447,7 +396,7 @@ isc__appctx_destroy(isc_appctx_t **ctxp) {
}
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));
@@ -456,7 +405,7 @@ isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
}
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));
@@ -465,7 +414,7 @@ isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
}
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));
@@ -474,7 +423,7 @@ isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
}
isc_result_t
isc__app_register(void) {
isc_app_register(void) {
return (isc_app_register(isc__appctx_create));
}