mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-31 22:45:39 +00:00
Code Issues Releases Wiki Activity

apply the modified style

Browse Source
This commit is contained in:
Evan Hunt
2020-02-13 14:44:37 -08:00
parent 0255a97473
commit e851ed0bb5
669 changed files with 35995 additions and 42219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

372
lib/isc/task.c
View File

@@ -93,31 +93,31 @@ static const char *statenames[] = {
};
#endif /* if defined(HAVE_LIBXML2) || defined(HAVE_JSON_C) */
#define TASK_MAGIC ISC_MAGIC('T', 'A', 'S', 'K')
#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;
typedef struct isc__task isc__task_t;
typedef struct isc__taskmgr isc__taskmgr_t;
typedef struct isc__taskqueue isc__taskqueue_t;
struct isc__task {
/* Not locked. */
isc_task_t common;
isc_task_t common;
isc__taskmgr_t *manager;
isc_mutex_t lock;
isc_mutex_t lock;
/* Locked by task lock. */
task_state_t state;
isc_refcount_t references;
task_state_t state;
isc_refcount_t references;
isc_eventlist_t events;
isc_eventlist_t on_shutdown;
unsigned int nevents;
unsigned int quantum;
isc_stdtime_t now;
isc_time_t tnow;
char name[16];
void * tag;
unsigned int threadid;
bool bound;
unsigned int nevents;
unsigned int quantum;
isc_stdtime_t now;
isc_time_t tnow;
char name[16];
void *tag;
unsigned int threadid;
bool bound;
/* Protected by atomics */
atomic_uint_fast32_t flags;
/* Locked by task manager lock. */
@@ -127,7 +127,7 @@ struct isc__task {
};
#define TASK_F_SHUTTINGDOWN 0x01
#define TASK_F_PRIVILEGED 0x02
#define TASK_F_PRIVILEGED 0x02
#define TASK_SHUTTINGDOWN(t) \
((atomic_load_acquire(&(t)->flags) & TASK_F_SHUTTINGDOWN) != 0)
@@ -138,43 +138,43 @@ struct isc__task {
#define TASK_FLAG_CLR(t, f) atomic_fetch_and_release(&(t)->flags, ~(f))
#define TASK_MANAGER_MAGIC ISC_MAGIC('T', 'S', 'K', 'M')
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TASK_MANAGER_MAGIC)
#define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TASK_MANAGER_MAGIC)
typedef ISC_LIST(isc__task_t) isc__tasklist_t;
struct isc__taskqueue {
/* Everything locked by lock */
isc_mutex_t lock;
isc_mutex_t lock;
isc__tasklist_t ready_tasks;
isc__tasklist_t ready_priority_tasks;
isc_condition_t work_available;
isc_thread_t thread;
unsigned int threadid;
isc_thread_t thread;
unsigned int threadid;
isc__taskmgr_t *manager;
};
struct isc__taskmgr {
/* Not locked. */
isc_taskmgr_t common;
isc_mem_t * mctx;
isc_mutex_t lock;
isc_mutex_t halt_lock;
isc_condition_t halt_cond;
unsigned int workers;
isc_taskmgr_t common;
isc_mem_t *mctx;
isc_mutex_t lock;
isc_mutex_t halt_lock;
isc_condition_t halt_cond;
unsigned int workers;
atomic_uint_fast32_t tasks_running;
atomic_uint_fast32_t tasks_ready;
atomic_uint_fast32_t curq;
atomic_uint_fast32_t tasks_count;
isc__taskqueue_t * queues;
isc_nm_t * nm;
isc__taskqueue_t *queues;
isc_nm_t *nm;
/* Locked by task manager lock. */
unsigned int default_quantum;
LIST(isc__task_t) tasks;
atomic_uint_fast32_t mode;
atomic_bool pause_req;
atomic_bool exclusive_req;
atomic_bool exiting;
atomic_bool pause_req;
atomic_bool exclusive_req;
atomic_bool exiting;
/* Locked by halt_lock */
unsigned int halted;
@@ -184,14 +184,12 @@ struct isc__taskmgr {
* to protect the access. We can't use 'lock' since isc_task_detach()
* will try to acquire it.
*/
isc_mutex_t excl_lock;
isc_mutex_t excl_lock;
isc__task_t *excl;
};
void
isc__taskmgr_pause(isc_taskmgr_t *manager0);
void
isc__taskmgr_resume(isc_taskmgr_t *manager0);
void isc__taskmgr_pause(isc_taskmgr_t *manager0);
void isc__taskmgr_resume(isc_taskmgr_t *manager0);
#define DEFAULT_DEFAULT_QUANTUM 25
#define FINISHED(m) \
@@ -204,31 +202,24 @@ isc__taskmgr_resume(isc_taskmgr_t *manager0);
* unit tests etc.
*/
bool
isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
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);
static inline bool
empty_readyq(isc__taskmgr_t *manager, int c);
bool isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
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);
static inline bool empty_readyq(isc__taskmgr_t *manager, int c);
static inline isc__task_t *
pop_readyq(isc__taskmgr_t *manager, int c);
static inline isc__task_t *pop_readyq(isc__taskmgr_t *manager, int c);
static inline void
push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c);
static inline void push_readyq(isc__taskmgr_t *manager, isc__task_t *task,
int c);
static inline void
wake_all_queues(isc__taskmgr_t *manager);
static inline void wake_all_queues(isc__taskmgr_t *manager);
/***
*** Tasks.
***/
static inline void
wake_all_queues(isc__taskmgr_t *manager)
{
wake_all_queues(isc__taskmgr_t *manager) {
for (unsigned int i = 0; i < manager->workers; i++) {
LOCK(&manager->queues[i].lock);
BROADCAST(&manager->queues[i].work_available);
@@ -237,8 +228,7 @@ wake_all_queues(isc__taskmgr_t *manager)
}
static void
task_finished(isc__task_t *task)
{
task_finished(isc__task_t *task) {
isc__taskmgr_t *manager = task->manager;
REQUIRE(EMPTY(task->events));
REQUIRE(task->nevents == 0);
@@ -270,18 +260,16 @@ task_finished(isc__task_t *task)
isc_result_t
isc_task_create(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp)
{
isc_task_t **taskp) {
return (isc_task_create_bound(manager0, quantum, taskp, -1));
}
isc_result_t
isc_task_create_bound(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp, int threadid)
{
isc_task_t **taskp, int threadid) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
isc__task_t * task;
bool exiting;
isc__task_t *task;
bool exiting;
REQUIRE(VALID_MANAGER(manager));
REQUIRE(taskp != NULL && *taskp == NULL);
@@ -348,8 +336,7 @@ isc_task_create_bound(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;
/*
@@ -367,9 +354,8 @@ isc_task_attach(isc_task_t *source0, isc_task_t **targetp)
}
static inline bool
task_shutdown(isc__task_t *task)
{
bool was_idle = false;
task_shutdown(isc__task_t *task) {
bool was_idle = false;
isc_event_t *event, *prev;
/*
@@ -412,10 +398,9 @@ task_shutdown(isc__task_t *task)
* Caller must NOT hold manager lock.
*/
static inline void
task_ready(isc__task_t *task)
{
task_ready(isc__task_t *task) {
isc__taskmgr_t *manager = task->manager;
bool has_privilege = isc_task_privilege((isc_task_t *)task);
bool has_privilege = isc_task_privilege((isc_task_t *)task);
REQUIRE(VALID_MANAGER(manager));
REQUIRE(task->state == task_state_ready);
@@ -431,8 +416,7 @@ task_ready(isc__task_t *task)
}
static inline bool
task_detach(isc__task_t *task)
{
task_detach(isc__task_t *task) {
/*
* Caller must be holding the task lock.
*/
@@ -440,7 +424,8 @@ task_detach(isc__task_t *task)
XTRACE("detach");
if (isc_refcount_decrement(&task->references) == 1 &&
task->state == task_state_idle) {
task->state == task_state_idle)
{
INSIST(EMPTY(task->events));
/*
* There are no references to this task, and no
@@ -458,10 +443,9 @@ 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;
bool was_idle;
/*
* Detach *taskp from its task.
@@ -485,9 +469,8 @@ isc_task_detach(isc_task_t **taskp)
}
static inline bool
task_send(isc__task_t *task, isc_event_t **eventp, int c)
{
bool was_idle = false;
task_send(isc__task_t *task, isc_event_t **eventp, int c) {
bool was_idle = false;
isc_event_t *event;
/*
@@ -521,22 +504,19 @@ task_send(isc__task_t *task, isc_event_t **eventp, int c)
}
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_sendto(task0, eventp, -1);
}
void
isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp)
{
isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
isc_task_sendtoanddetach(taskp, eventp, -1);
}
void
isc_task_sendto(isc_task_t *task0, isc_event_t **eventp, int c)
{
isc_task_sendto(isc_task_t *task0, isc_event_t **eventp, int c) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle;
bool was_idle;
/*
* Send '*event' to 'task'.
@@ -583,9 +563,8 @@ isc_task_sendto(isc_task_t *task0, isc_event_t **eventp, int c)
}
void
isc_task_sendtoanddetach(isc_task_t **taskp, isc_event_t **eventp, int c)
{
bool idle1, idle2;
isc_task_sendtoanddetach(isc_task_t **taskp, isc_event_t **eventp, int c) {
bool idle1, idle2;
isc__task_t *task;
/*
@@ -629,8 +608,7 @@ isc_task_sendtoanddetach(isc_task_t **taskp, isc_event_t **eventp, int c)
static unsigned int
dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag, isc_eventlist_t *events,
bool purging)
{
bool purging) {
isc_event_t *event, *next_event;
unsigned int count = 0;
@@ -654,7 +632,8 @@ dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first,
if (event->ev_type >= first && event->ev_type <= last &&
(sender == NULL || event->ev_sender == sender) &&
(tag == NULL || event->ev_tag == tag) &&
(!purging || PURGE_OK(event))) {
(!purging || PURGE_OK(event)))
{
DEQUEUE(task->events, event, ev_link);
task->nevents--;
ENQUEUE(*events, event, ev_link);
@@ -669,12 +648,11 @@ 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_eventtype_t last, void *tag)
{
isc__task_t * task = (isc__task_t *)task0;
unsigned int count;
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;
isc_event_t *event, *next_event;
REQUIRE(VALID_TASK(task));
/*
@@ -701,8 +679,8 @@ 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, void *tag)
{
isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag) {
/*
* Purge events from a task's event queue.
*/
@@ -714,8 +692,7 @@ 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)
{
isc_task_purgeevent(isc_task_t *task0, isc_event_t *event) {
isc__task_t *task = (isc__task_t *)task0;
isc_event_t *curr_event, *next_event;
@@ -739,7 +716,8 @@ isc_task_purgeevent(isc_task_t *task0, isc_event_t *event)
LOCK(&task->lock);
for (curr_event = HEAD(task->events); curr_event != NULL;
curr_event = next_event) {
curr_event = next_event)
{
next_event = NEXT(curr_event, ev_link);
if (curr_event == event && PURGE_OK(event)) {
DEQUEUE(task->events, curr_event, ev_link);
@@ -760,8 +738,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_eventtype_t last, void *tag, isc_eventlist_t *events)
{
isc_eventtype_t last, void *tag, isc_eventlist_t *events) {
/*
* Remove events from a task's event queue.
*/
@@ -775,8 +752,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, void *tag,
isc_eventlist_t *events)
{
isc_eventlist_t *events) {
/*
* Remove events from a task's event queue.
*/
@@ -788,10 +764,9 @@ isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type, void *tag,
}
isc_result_t
isc_task_onshutdown(isc_task_t *task0, isc_taskaction_t action, void *arg)
{
isc_task_onshutdown(isc_task_t *task0, isc_taskaction_t action, void *arg) {
isc__task_t *task = (isc__task_t *)task0;
bool disallowed = false;
bool disallowed = false;
isc_result_t result = ISC_R_SUCCESS;
isc_event_t *event;
@@ -824,10 +799,9 @@ isc_task_onshutdown(isc_task_t *task0, isc_taskaction_t action, void *arg)
}
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;
bool was_idle;
/*
* Shutdown 'task'.
@@ -845,8 +819,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'.
*/
@@ -858,8 +831,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;
/*
@@ -875,8 +847,7 @@ isc_task_setname(isc_task_t *task0, const char *name, void *tag)
}
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));
@@ -885,8 +856,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));
@@ -895,8 +865,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));
@@ -908,8 +877,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));
@@ -932,8 +900,7 @@ isc_task_getcurrenttimex(isc_task_t *task0, isc_time_t *t)
* Caller must hold the task manager lock.
*/
static inline bool
empty_readyq(isc__taskmgr_t *manager, int c)
{
empty_readyq(isc__taskmgr_t *manager, int c) {
isc__tasklist_t queue;
if (atomic_load_relaxed(&manager->mode) == isc_taskmgrmode_normal) {
@@ -953,8 +920,7 @@ empty_readyq(isc__taskmgr_t *manager, int c)
* Caller must hold the task manager lock.
*/
static inline isc__task_t *
pop_readyq(isc__taskmgr_t *manager, int c)
{
pop_readyq(isc__taskmgr_t *manager, int c) {
isc__task_t *task;
if (atomic_load_relaxed(&manager->mode) == isc_taskmgrmode_normal) {
@@ -981,8 +947,7 @@ pop_readyq(isc__taskmgr_t *manager, int c)
* Caller must hold the task manager lock.
*/
static inline void
push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c)
{
push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c) {
ENQUEUE(manager->queues[c].ready_tasks, task, ready_link);
if (TASK_PRIVILEGED(task)) {
ENQUEUE(manager->queues[c].ready_priority_tasks, task,
@@ -993,8 +958,7 @@ push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c)
}
static void
dispatch(isc__taskmgr_t *manager, unsigned int threadid)
{
dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
isc__task_t *task;
REQUIRE(VALID_MANAGER(manager));
@@ -1068,7 +1032,8 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
while ((empty_readyq(manager, threadid) &&
!atomic_load_relaxed(&manager->pause_req) &&
!atomic_load_relaxed(&manager->exclusive_req)) &&
!FINISHED(manager)) {
!FINISHED(manager))
{
XTHREADTRACE("wait");
XTHREADTRACE(atomic_load_relaxed(&manager->pause_req)
? "paused"
@@ -1084,7 +1049,8 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
XTHREADTRACE("working");
if (atomic_load_relaxed(&manager->pause_req) ||
atomic_load_relaxed(&manager->exclusive_req)) {
atomic_load_relaxed(&manager->exclusive_req))
{
UNLOCK(&manager->queues[threadid].lock);
XTHREADTRACE("halting");
@@ -1105,7 +1071,8 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
manager->halted++;
BROADCAST(&manager->halt_cond);
while (atomic_load_relaxed(&manager->pause_req) ||
atomic_load_relaxed(&manager->exclusive_req)) {
atomic_load_relaxed(&manager->exclusive_req))
{
WAIT(&manager->halt_cond, &manager->halt_lock);
}
manager->halted--;
@@ -1120,9 +1087,9 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
task = pop_readyq(manager, threadid);
if (task != NULL) {
unsigned int dispatch_count = 0;
bool done = false;
bool requeue = false;
bool finished = false;
bool done = false;
bool requeue = false;
bool finished = false;
isc_event_t *event;
INSIST(VALID_TASK(task));
@@ -1171,7 +1138,8 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
if (isc_refcount_current(&task->references) ==
0 &&
EMPTY(task->events) &&
!TASK_SHUTTINGDOWN(task)) {
!TASK_SHUTTINGDOWN(task))
{
bool was_idle;
/*
@@ -1296,7 +1264,8 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
if (atomic_load_relaxed(&manager->mode) !=
isc_taskmgrmode_normal &&
atomic_load_explicit(&manager->tasks_running,
memory_order_acquire) == 0) {
memory_order_acquire) == 0)
{
UNLOCK(&manager->queues[threadid].lock);
LOCK(&manager->lock);
/*
@@ -1309,11 +1278,12 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid)
if (atomic_load(&manager->mode) !=
isc_taskmgrmode_normal &&
atomic_load_explicit(&manager->tasks_running,
memory_order_acquire) == 0) {
bool empty = true;
memory_order_acquire) == 0)
{
bool empty = true;
unsigned int i;
for (i = 0; i < manager->workers && empty;
i++) {
for (i = 0; i < manager->workers && empty; i++)
{
LOCK(&manager->queues[i].lock);
empty &= empty_readyq(manager, i);
UNLOCK(&manager->queues[i].lock);
@@ -1340,11 +1310,10 @@ static isc_threadresult_t
#ifdef _WIN32
WINAPI
#endif /* ifdef _WIN32 */
run(void *queuep)
{
run(void *queuep) {
isc__taskqueue_t *tq = queuep;
isc__taskmgr_t * manager = tq->manager;
int threadid = tq->threadid;
isc__taskmgr_t *manager = tq->manager;
int threadid = tq->threadid;
isc_thread_setaffinity(threadid);
XTHREADTRACE("starting");
@@ -1361,8 +1330,7 @@ static isc_threadresult_t
}
static void
manager_free(isc__taskmgr_t *manager)
{
manager_free(isc__taskmgr_t *manager) {
for (unsigned int i = 0; i < manager->workers; i++) {
isc_mutex_destroy(&manager->queues[i].lock);
}
@@ -1378,9 +1346,8 @@ manager_free(isc__taskmgr_t *manager)
isc_result_t
isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_nm_t *nm,
isc_taskmgr_t **managerp)
{
unsigned int i;
isc_taskmgr_t **managerp) {
unsigned int i;
isc__taskmgr_t *manager;
/*
@@ -1454,12 +1421,11 @@ 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;
bool exiting;
isc__task_t *task;
unsigned int i;
bool exiting;
/*
* Destroy '*managerp'.
@@ -1516,8 +1482,8 @@ isc_taskmgr_destroy(isc_taskmgr_t **managerp)
* posted). To make things easier post idle tasks to worker 0.
*/
LOCK(&manager->queues[0].lock);
for (task = HEAD(manager->tasks); task != NULL;
task = NEXT(task, link)) {
for (task = HEAD(manager->tasks); task != NULL; task = NEXT(task, link))
{
LOCK(&task->lock);
if (task_shutdown(task)) {
task->threadid = 0;
@@ -1555,28 +1521,26 @@ isc_taskmgr_destroy(isc_taskmgr_t **managerp)
}
void
isc_taskmgr_setprivilegedmode(isc_taskmgr_t *manager0)
{
isc_taskmgr_setprivilegedmode(isc_taskmgr_t *manager0) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
atomic_store(&manager->mode, isc_taskmgrmode_privileged);
}
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;
return (atomic_load(&manager->mode));
}
void
isc__taskmgr_pause(isc_taskmgr_t *manager0)
{
isc__taskmgr_pause(isc_taskmgr_t *manager0) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
LOCK(&manager->halt_lock);
while (atomic_load_relaxed(&manager->exclusive_req) ||
atomic_load_relaxed(&manager->pause_req)) {
atomic_load_relaxed(&manager->pause_req))
{
UNLOCK(&manager->halt_lock);
/* This is ugly but pause is used EXCLUSIVELY in tests */
isc_thread_yield();
@@ -1592,8 +1556,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->halt_lock);
if (atomic_load(&manager->pause_req)) {
@@ -1607,10 +1570,9 @@ isc__taskmgr_resume(isc_taskmgr_t *manager0)
}
void
isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0)
{
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__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_MANAGER(mgr));
REQUIRE(VALID_TASK(task));
@@ -1623,10 +1585,9 @@ 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_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(VALID_MANAGER(mgr));
REQUIRE(taskp != NULL && *taskp == NULL);
@@ -1643,9 +1604,8 @@ isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp)
}
isc_result_t
isc_task_beginexclusive(isc_task_t *task0)
{
isc__task_t * task = (isc__task_t *)task0;
isc_task_beginexclusive(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager;
REQUIRE(VALID_TASK(task));
@@ -1661,7 +1621,8 @@ isc_task_beginexclusive(isc_task_t *task0)
UNLOCK(&manager->excl_lock);
if (atomic_load_relaxed(&manager->exclusive_req) ||
atomic_load_relaxed(&manager->pause_req)) {
atomic_load_relaxed(&manager->pause_req))
{
return (ISC_R_LOCKBUSY);
}
@@ -1681,9 +1642,8 @@ isc_task_beginexclusive(isc_task_t *task0)
}
void
isc_task_endexclusive(isc_task_t *task0)
{
isc__task_t * task = (isc__task_t *)task0;
isc_task_endexclusive(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager;
REQUIRE(VALID_TASK(task));
@@ -1704,12 +1664,11 @@ isc_task_endexclusive(isc_task_t *task0)
}
void
isc_task_pause(isc_task_t *task0)
{
isc_task_pause(isc_task_t *task0) {
REQUIRE(ISCAPI_TASK_VALID(task0));
isc__task_t * task = (isc__task_t *)task0;
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
bool running = false;
bool running = false;
LOCK(&task->lock);
INSIST(task->state == task_state_idle ||
@@ -1736,10 +1695,9 @@ isc_task_pause(isc_task_t *task0)
}
void
isc_task_unpause(isc_task_t *task0)
{
isc_task_unpause(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle = false;
bool was_idle = false;
REQUIRE(ISCAPI_TASK_VALID(task0));
@@ -1764,12 +1722,11 @@ isc_task_unpause(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__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
uint_fast32_t oldflags, newflags;
uint_fast32_t oldflags, newflags;
oldflags = atomic_load_acquire(&task->flags);
do {
@@ -1796,8 +1753,7 @@ 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;
REQUIRE(VALID_TASK(task));
@@ -1805,8 +1761,7 @@ isc_task_privilege(isc_task_t *task0)
}
bool
isc_task_exiting(isc_task_t *t)
{
isc_task_exiting(isc_task_t *t) {
isc__task_t *task = (isc__task_t *)t;
REQUIRE(VALID_TASK(task));
@@ -1821,11 +1776,10 @@ isc_task_exiting(isc_task_t *t)
goto error; \
} while (0)
int
isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, void *writer0)
{
isc__taskmgr_t * mgr = (isc__taskmgr_t *)mgr0;
isc__task_t * task = NULL;
int xmlrc;
isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, void *writer0) {
isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
isc__task_t *task = NULL;
int xmlrc;
xmlTextWriterPtr writer = (xmlTextWriterPtr)writer0;
LOCK(&mgr->lock);
@@ -1932,13 +1886,12 @@ error:
} while (0)
isc_result_t
isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, void *tasks0)
{
isc_result_t result = ISC_R_SUCCESS;
isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, void *tasks0) {
isc_result_t result = ISC_R_SUCCESS;
isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
isc__task_t * task = NULL;
json_object * obj = NULL, *array = NULL, *taskobj = NULL;
json_object * tasks = (json_object *)tasks0;
isc__task_t *task = NULL;
json_object *obj = NULL, *array = NULL, *taskobj = NULL;
json_object *tasks = (json_object *)tasks0;
LOCK(&mgr->lock);
@@ -1974,7 +1927,8 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, void *tasks0)
CHECKMEM(array);
for (task = ISC_LIST_HEAD(mgr->tasks); task != NULL;
task = ISC_LIST_NEXT(task, link)) {
task = ISC_LIST_NEXT(task, link))
{
char buf[255];
LOCK(&task->lock);
@@ -2034,8 +1988,8 @@ error:
isc_result_t
isc_taskmgr_createinctx(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_taskmgr_t **managerp)
{
unsigned int default_quantum,
isc_taskmgr_t **managerp) {
isc_result_t result;
result = isc_taskmgr_create(mctx, workers, default_quantum, NULL,