task.c revision bae70907555b89759d803402111b06a2aefd1b67
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews/*
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * Copyright (C) 1998, 1999 Internet Software Consortium.
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews *
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * Permission to use, copy, modify, and distribute this software for any
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * purpose with or without fee is hereby granted, provided that the above
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * copyright notice and this permission notice appear in all copies.
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews *
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews * SOFTWARE.
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews */
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <config.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/assertions.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/boolean.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/thread.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/mutex.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/condition.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/error.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include <isc/task.h>
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#include "util.h"
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#ifdef ISC_TASK_TRACE
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#define XTRACE(m) printf("%s task %p thread %lu\n", (m), \
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews task, isc_thread_self())
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#else
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#define XTRACE(m)
393fd55d91306e6def3a3d06748eee031f57bd17Mark Andrews#endif
/***
*** Types.
***/
typedef enum {
task_state_idle, task_state_ready, task_state_running,
task_state_shutdown
} task_state_t;
#define TASK_MAGIC 0x5441534BU /* TASK. */
#define VALID_TASK(t) ((t) != NULL && \
(t)->magic == TASK_MAGIC)
struct isc_task {
/* Not locked. */
unsigned int magic;
isc_taskmgr_t * manager;
isc_mutex_t lock;
isc_mem_t * mctx;
/* Locked by task lock. */
task_state_t state;
unsigned int references;
isc_eventlist_t events;
isc_eventlist_t on_shutdown;
unsigned int quantum;
isc_boolean_t enqueue_allowed;
isc_boolean_t shutting_down;
/* Locked by task manager lock. */
LINK(isc_task_t) link;
LINK(isc_task_t) ready_link;
};
#define TASK_MANAGER_MAGIC 0x54534B4DU /* TSKM. */
#define VALID_MANAGER(m) ((m) != NULL && \
(m)->magic == TASK_MANAGER_MAGIC)
struct isc_taskmgr {
/* Not locked. */
unsigned int magic;
isc_mem_t * mctx;
isc_mutex_t lock;
unsigned int workers;
isc_thread_t * threads;
/* Locked by task manager lock. */
unsigned int default_quantum;
LIST(isc_task_t) tasks;
LIST(isc_task_t) ready_tasks;
isc_condition_t work_available;
isc_boolean_t exiting;
};
#define DEFAULT_DEFAULT_QUANTUM 5
#define FINISHED(m) ((m)->exiting && EMPTY((m)->tasks))
/***
*** Events.
***/
static inline isc_event_t *
event_allocate(isc_mem_t *mctx, void *sender, isc_eventtype_t type,
isc_taskaction_t action, void *arg, size_t size)
{
isc_event_t *event;
event = isc_mem_get(mctx, size);
if (event == NULL)
return (NULL);
event->mctx = mctx;
event->size = size;
event->sender = sender;
event->type = type;
event->action = action;
event->arg = arg;
event->destroy = NULL;
INIT_LINK(event, link);
return (event);
}
isc_event_t *
isc_event_allocate(isc_mem_t *mctx, void *sender, isc_eventtype_t type,
isc_taskaction_t action, void *arg, size_t size)
{
if (size < sizeof (struct isc_event))
return (NULL);
if (type < 0)
return (NULL);
if (action == NULL)
return (NULL);
return (event_allocate(mctx, sender, type, action, arg, size));
}
void
isc_event_free(isc_event_t **eventp) {
isc_event_t *event;
REQUIRE(eventp != NULL);
event = *eventp;
REQUIRE(event != NULL);
if (event->destroy != NULL)
(event->destroy)(event);
isc_mem_put(event->mctx, event, event->size);
*eventp = NULL;
}
/***
*** Tasks.
***/
static void
task_free(isc_task_t *task) {
isc_taskmgr_t *manager = task->manager;
XTRACE("free task");
REQUIRE(EMPTY(task->events));
REQUIRE(EMPTY(task->on_shutdown));
LOCK(&manager->lock);
UNLINK(manager->tasks, task, link);
if (FINISHED(manager)) {
/*
* All tasks have completed and the
* task manager is exiting. Wake up
* any idle worker threads so they
* can exit.
*/
BROADCAST(&manager->work_available);
}
UNLOCK(&manager->lock);
(void)isc_mutex_destroy(&task->lock);
task->magic = 0;
isc_mem_put(task->mctx, task, sizeof *task);
}
isc_result_t
isc_task_create(isc_taskmgr_t *manager, isc_mem_t *mctx, unsigned int quantum,
isc_task_t **taskp)
{
isc_task_t *task;
REQUIRE(VALID_MANAGER(manager));
REQUIRE(taskp != NULL && *taskp == NULL);
if (mctx == NULL)
mctx = manager->mctx;
task = isc_mem_get(mctx, sizeof *task);
if (task == NULL)
return (ISC_R_NOMEMORY);
task->manager = manager;
task->mctx = mctx;
if (isc_mutex_init(&task->lock) != ISC_R_SUCCESS) {
isc_mem_put(mctx, task, sizeof *task);
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_mutex_init() failed");
return (ISC_R_UNEXPECTED);
}
task->state = task_state_idle;
task->references = 1;
INIT_LIST(task->events);
INIT_LIST(task->on_shutdown);
task->quantum = quantum;
task->enqueue_allowed = ISC_TRUE;
task->shutting_down = ISC_FALSE;
INIT_LINK(task, link);
INIT_LINK(task, ready_link);
LOCK(&manager->lock);
if (task->quantum == 0)
task->quantum = manager->default_quantum;
APPEND(manager->tasks, task, link);
UNLOCK(&manager->lock);
task->magic = TASK_MAGIC;
*taskp = task;
return (ISC_R_SUCCESS);
}
void
isc_task_attach(isc_task_t *task, isc_task_t **taskp) {
REQUIRE(VALID_TASK(task));
REQUIRE(taskp != NULL && *taskp == NULL);
LOCK(&task->lock);
task->references++;
UNLOCK(&task->lock);
*taskp = task;
}
void
isc_task_detach(isc_task_t **taskp) {
isc_boolean_t free_task = ISC_FALSE;
isc_task_t *task;
XTRACE("isc_task_detach");
REQUIRE(taskp != NULL);
task = *taskp;
REQUIRE(VALID_TASK(task));
LOCK(&task->lock);
REQUIRE(task->references > 0);
task->references--;
if (task->state == task_state_shutdown && task->references == 0)
free_task = ISC_TRUE;
UNLOCK(&task->lock);
if (free_task)
task_free(task);
*taskp = NULL;
}
isc_mem_t *
isc_task_mem(isc_task_t *task) {
REQUIRE(VALID_TASK(task));
return (task->mctx);
}
isc_result_t
isc_task_send(isc_task_t *task, isc_event_t **eventp) {
isc_boolean_t was_idle = ISC_FALSE;
isc_boolean_t disallowed = ISC_FALSE;
isc_result_t result = ISC_R_SUCCESS;
isc_event_t *event;
REQUIRE(VALID_TASK(task));
REQUIRE(eventp != NULL);
event = *eventp;
REQUIRE(event != NULL);
REQUIRE(event->sender != NULL);
REQUIRE(event->type > 0);
XTRACE("sending");
/*
* We're trying hard to hold locks for as short a time as possible.
* We're also trying to hold as few locks as possible. This is why
* some processing is deferred until after a lock is released.
*/
LOCK(&task->lock);
/*
* Note: we require that task->shutting_down implies
* !task->enqueue_allowed.
*/
if (task->enqueue_allowed) {
if (task->state == task_state_idle) {
was_idle = ISC_TRUE;
INSIST(EMPTY(task->events));
task->state = task_state_ready;
}
INSIST(task->state == task_state_ready ||
task->state == task_state_running);
ENQUEUE(task->events, event, link);
} else {
disallowed = ISC_TRUE;
if (task->state == task_state_shutdown)
result = ISC_R_TASKSHUTDOWN;
else if (task->shutting_down)
result = ISC_R_TASKSHUTTINGDOWN;
else
result = ISC_R_TASKNOSEND;
}
UNLOCK(&task->lock);
if (disallowed)
return (result);
if (was_idle) {
isc_taskmgr_t *manager;
/*
* We need to add this task to the ready queue.
*
* We've waited until now to do it, rather than doing it
* while holding the task lock, because we don't want to
* block while holding the task lock.
*
* We've changed the state to ready, so no one else will
* be trying to add this task to the ready queue. It
* thus doesn't matter if more events have been added to
* the queue after we gave up the task lock.
*
* Shutting down a task requires posting a shutdown event
* to the task's queue and then executing it, so there's
* no way the task can disappear. A task is always on the
* task manager's 'tasks' list, so the task manager can
* always post a shutdown event to all tasks if it is
* requested to shutdown.
*/
manager = task->manager;
INSIST(VALID_MANAGER(manager));
LOCK(&manager->lock);
ENQUEUE(manager->ready_tasks, task, ready_link);
SIGNAL(&manager->work_available);
UNLOCK(&manager->lock);
}
*eventp = NULL;
XTRACE("sent");
return (ISC_R_SUCCESS);
}
unsigned int
isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type) {
isc_event_t *event, *next_event;
isc_eventlist_t purgeable;
unsigned int purge_count;
REQUIRE(VALID_TASK(task));
REQUIRE(type >= 0);
/*
* Purge events matching 'sender' and 'type'. sender == NULL means
* "any sender". type == NULL means any type. Task manager events
* cannot be purged.
*
* Purging never changes the state of the task.
*/
INIT_LIST(purgeable);
purge_count = 0;
LOCK(&task->lock);
for (event = HEAD(task->events);
event != NULL;
event = next_event) {
next_event = NEXT(event, link);
if ((sender == NULL || event->sender == sender) &&
((type == 0 && event->type > 0) || event->type == type)) {
DEQUEUE(task->events, event, link);
ENQUEUE(purgeable, event, link);
}
}
UNLOCK(&task->lock);
for (event = HEAD(purgeable);
event != NULL;
event = next_event) {
next_event = NEXT(event, link);
isc_event_free(&event);
purge_count++;
}
return (purge_count);
}
isc_result_t
isc_task_allowsend(isc_task_t *task, isc_boolean_t enqueue_allowed) {
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(VALID_TASK(task));
LOCK(&task->lock);
if (task->state == task_state_shutdown)
result = ISC_R_TASKSHUTDOWN;
else if (task->shutting_down)
result = ISC_R_TASKSHUTTINGDOWN;
else
task->enqueue_allowed = enqueue_allowed;
UNLOCK(&task->lock);
return (result);
}
isc_result_t
isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg) {
isc_boolean_t disallowed = ISC_FALSE;
isc_result_t result = ISC_R_SUCCESS;
isc_event_t *event;
REQUIRE(VALID_TASK(task));
event = event_allocate(task->mctx,
NULL,
ISC_TASKEVENT_SHUTDOWN,
action,
arg,
sizeof *event);
if (event == NULL)
return (ISC_R_NOMEMORY);
LOCK(&task->lock);
if (task->state == task_state_shutdown) {
disallowed = ISC_TRUE;
result = ISC_R_TASKSHUTDOWN;
} else if (task->shutting_down) {
disallowed = ISC_TRUE;
result = ISC_R_TASKSHUTTINGDOWN;
} else
ENQUEUE(task->on_shutdown, event, link);
UNLOCK(&task->lock);
if (disallowed)
isc_mem_put(task->mctx, event, sizeof *event);
return (result);
}
void
isc_task_shutdown(isc_task_t *task) {
isc_boolean_t was_idle = ISC_FALSE;
isc_boolean_t queued_something = ISC_FALSE;
isc_event_t *event, *prev;
REQUIRE(VALID_TASK(task));
/*
* This routine is very similar to isc_task_send() above.
*/
LOCK(&task->lock);
if (!task->shutting_down) {
if (task->state == task_state_idle) {
was_idle = ISC_TRUE;
INSIST(EMPTY(task->events));
task->state = task_state_ready;
}
INSIST(task->state == task_state_ready ||
task->state == task_state_running);
/*
* Note that we post shutdown events LIFO.
*/
for (event = TAIL(task->on_shutdown);
event != NULL;
event = prev) {
prev = PREV(event, link);
DEQUEUE(task->on_shutdown, event, link);
ENQUEUE(task->events, event, link);
queued_something = ISC_TRUE;
}
task->enqueue_allowed = ISC_FALSE;
task->shutting_down = ISC_TRUE;
}
UNLOCK(&task->lock);
if (was_idle && queued_something) {
isc_taskmgr_t *manager;
manager = task->manager;
INSIST(VALID_MANAGER(manager));
LOCK(&manager->lock);
ENQUEUE(manager->ready_tasks, task, ready_link);
SIGNAL(&manager->work_available);
UNLOCK(&manager->lock);
}
}
void
isc_task_destroy(isc_task_t **taskp) {
REQUIRE(taskp != NULL);
isc_task_shutdown(*taskp);
isc_task_detach(taskp);
}
/***
*** Task Manager.
***/
static isc_threadresult_t
#ifdef _WIN32
WINAPI
#endif
run(void *uap) {
isc_taskmgr_t *manager = uap;
isc_task_t *task;
XTRACE("start");
REQUIRE(VALID_MANAGER(manager));
/*
* Again we're trying to hold the lock for as short a time as possible
* and to do as little locking and unlocking as possible.
*
* In both while loops, the appropriate lock must be held before the
* while body starts. Code which acquired the lock at the top of
* the loop would be more readable, but would result in a lot of
* extra locking. Compare:
*
* Straightforward:
*
* LOCK();
* ...
* UNLOCK();
* while (expression) {
* LOCK();
* ...
* UNLOCK();
*
* Unlocked part here...
*
* LOCK();
* ...
* UNLOCK();
* }
*
* Note how if the loop continues we unlock and then immediately lock.
* For N iterations of the loop, this code does 2N+1 locks and 2N+1
* unlocks. Also note that the lock is not held when the while
* condition is tested, which may or may not be important, depending
* on the expression.
*
* As written:
*
* LOCK();
* while (expression) {
* ...
* UNLOCK();
*
* Unlocked part here...
*
* LOCK();
* ...
* }
* UNLOCK();
*
* For N iterations of the loop, this code does N+1 locks and N+1
* unlocks. The while expression is always protected by the lock.
*/
LOCK(&manager->lock);
while (!FINISHED(manager)) {
/*
* For reasons similar to those given in the comment in
* isc_task_send() above, it is safe for us to dequeue
* the task while only holding the manager lock, and then
* change the task to running state while only holding the
* task lock.
*/
while (EMPTY(manager->ready_tasks) && !FINISHED(manager)) {
XTRACE("wait");
WAIT(&manager->work_available, &manager->lock);
XTRACE("awake");
}
XTRACE("working");
task = HEAD(manager->ready_tasks);
if (task != NULL) {
unsigned int dispatch_count = 0;
isc_boolean_t done = ISC_FALSE;
isc_boolean_t requeue = ISC_FALSE;
isc_boolean_t free_task = ISC_FALSE;
isc_event_t *event;
INSIST(VALID_TASK(task));
/*
* Note we only unlock the manager lock if we actually
* have a task to do. We must reacquire the manager
* lock before exiting the 'if (task != NULL)' block.
*/
DEQUEUE(manager->ready_tasks, task, ready_link);
UNLOCK(&manager->lock);
LOCK(&task->lock);
INSIST(task->state == task_state_ready);
if (EMPTY(task->events)) {
/*
* The task became runnable, but all events
* in the run queue were subsequently purged.
* Put the task to sleep.
*/
task->state = task_state_idle;
done = ISC_TRUE;
XTRACE("ready but empty");
} else
task->state = task_state_running;
while (!done) {
INSIST(!EMPTY(task->events));
event = HEAD(task->events);
DEQUEUE(task->events, event, link);
UNLOCK(&task->lock);
/*
* Execute the event action.
*/
XTRACE("execute action");
if (event->action != NULL)
(event->action)(task, event);
dispatch_count++;
LOCK(&task->lock);
if (EMPTY(task->events)) {
/*
* Nothing else to do for this task
* right now. If it is shutting down,
* then it is done, otherwise we just
* put it to sleep.
*/
XTRACE("empty");
if (task->shutting_down) {
XTRACE("shutdown");
if (task->references == 0)
free_task = ISC_TRUE;
task->state =
task_state_shutdown;
} else
task->state = task_state_idle;
done = ISC_TRUE;
} else if (dispatch_count >= task->quantum) {
/*
* Our quantum has expired, but
* there is more work to be done.
* We'll requeue it to the ready
* queue later.
*
* We don't check quantum until
* dispatching at least one event,
* so the minimum quantum is one.
*/
XTRACE("quantum");
task->state = task_state_ready;
requeue = ISC_TRUE;
done = ISC_TRUE;
}
}
UNLOCK(&task->lock);
if (free_task)
task_free(task);
LOCK(&manager->lock);
if (requeue) {
/*
* We know we're awake, so we don't have
* to wakeup any sleeping threads if the
* ready queue is empty before we requeue.
*
* A possible optimization if the queue is
* empty is to 'goto' the 'if (task != NULL)'
* block, avoiding the ENQUEUE of the task
* and the subsequent immediate DEQUEUE
* (since it is the only executable task).
* We don't do this because then we'd be
* skipping the exit_requested check. The
* cost of ENQUEUE is low anyway, especially
* when you consider that we'd have to do
* an extra EMPTY check to see if we could
* do the optimization. If the ready queue
* were usually nonempty, the 'optimization'
* might even hurt rather than help.
*/
ENQUEUE(manager->ready_tasks, task,
ready_link);
}
}
}
UNLOCK(&manager->lock);
XTRACE("exit");
return ((isc_threadresult_t)0);
}
static void
manager_free(isc_taskmgr_t *manager) {
(void)isc_condition_destroy(&manager->work_available);
(void)isc_mutex_destroy(&manager->lock);
isc_mem_put(manager->mctx, manager->threads,
manager->workers * sizeof (isc_thread_t));
manager->magic = 0;
isc_mem_put(manager->mctx, manager, sizeof *manager);
}
isc_result_t
isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_taskmgr_t **managerp)
{
unsigned int i, started = 0;
isc_taskmgr_t *manager;
isc_thread_t *threads;
REQUIRE(workers > 0);
manager = isc_mem_get(mctx, sizeof *manager);
if (manager == NULL)
return (ISC_R_NOMEMORY);
manager->magic = TASK_MANAGER_MAGIC;
manager->mctx = mctx;
threads = isc_mem_get(mctx, workers * sizeof (isc_thread_t));
if (threads == NULL) {
isc_mem_put(mctx, manager, sizeof *manager);
return (ISC_R_NOMEMORY);
}
manager->threads = threads;
manager->workers = 0;
if (isc_mutex_init(&manager->lock) != ISC_R_SUCCESS) {
isc_mem_put(mctx, threads, workers * sizeof (isc_thread_t));
isc_mem_put(mctx, manager, sizeof *manager);
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_mutex_init() failed");
return (ISC_R_UNEXPECTED);
}
if (default_quantum == 0)
default_quantum = DEFAULT_DEFAULT_QUANTUM;
manager->default_quantum = default_quantum;
INIT_LIST(manager->tasks);
INIT_LIST(manager->ready_tasks);
if (isc_condition_init(&manager->work_available) != ISC_R_SUCCESS) {
(void)isc_mutex_destroy(&manager->lock);
isc_mem_put(mctx, threads, workers * sizeof (isc_thread_t));
isc_mem_put(mctx, manager, sizeof *manager);
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_condition_init() failed");
return (ISC_R_UNEXPECTED);
}
manager->exiting = ISC_FALSE;
manager->workers = 0;
LOCK(&manager->lock);
/*
* Start workers.
*/
for (i = 0; i < workers; i++) {
if (isc_thread_create(run, manager,
&manager->threads[manager->workers]) ==
ISC_R_SUCCESS) {
manager->workers++;
started++;
}
}
UNLOCK(&manager->lock);
if (started == 0) {
manager_free(manager);
return (ISC_R_NOTHREADS);
}
*managerp = manager;
return (ISC_R_SUCCESS);
}
void
isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
isc_taskmgr_t *manager;
isc_task_t *task;
isc_event_t *event, *prev;
unsigned int i;
REQUIRE(managerp != NULL);
manager = *managerp;
REQUIRE(VALID_MANAGER(manager));
XTRACE("isc_taskmgr_destroy");
/*
* Only one non-worker thread may ever call this routine.
* If a worker thread wants to initiate shutdown of the
* task manager, it should ask some non-worker thread to call
* isc_taskmgr_destroy(), e.g. by signalling a condition variable
* that the startup thread is sleeping on.
*/
/*
* Unlike elsewhere, we're going to hold this lock a long time.
* We need to do so, because otherwise the list of tasks could
* change while we were traversing it.
*
* This is also the only function where we will hold both the
* task manager lock and a task lock at the same time.
*/
LOCK(&manager->lock);
/*
* Make sure we only get called once.
*/
INSIST(!manager->exiting);
manager->exiting = ISC_TRUE;
/*
* Post the shutdown event to every task (if it hasn't already been
* posted).
*/
for (task = HEAD(manager->tasks);
task != NULL;
task = NEXT(task, link)) {
LOCK(&task->lock);
if (!task->shutting_down) {
/*
* Note that we post shutdown events LIFO.
*/
for (event = TAIL(task->on_shutdown);
event != NULL;
event = prev) {
prev = PREV(event, link);
DEQUEUE(task->on_shutdown, event, link);
ENQUEUE(task->events, event, link);
}
if (task->state == task_state_idle) {
task->state = task_state_ready;
ENQUEUE(manager->ready_tasks, task,
ready_link);
}
INSIST(task->state == task_state_ready ||
task->state == task_state_running);
task->enqueue_allowed = ISC_FALSE;
task->shutting_down = ISC_TRUE;
}
UNLOCK(&task->lock);
}
/*
* Wake up any sleeping workers. This ensures we get work done if
* there's work left to do, and if there are already no tasks left
* it will cause the workers to see manager->exiting.
*/
BROADCAST(&manager->work_available);
UNLOCK(&manager->lock);
/*
* Wait for all the worker threads to exit.
*/
for (i = 0; i < manager->workers; i++)
(void)isc_thread_join(manager->threads[i], NULL);
manager_free(manager);
*managerp = NULL;
}