1*00b67f09SDavid van Moolenbroek /* $NetBSD: task.c,v 1.11 2014/12/10 04:37:59 christos Exp $ */
2*00b67f09SDavid van Moolenbroek
3*00b67f09SDavid van Moolenbroek /*
4*00b67f09SDavid van Moolenbroek * Copyright (C) 2004-2014 Internet Systems Consortium, Inc. ("ISC")
5*00b67f09SDavid van Moolenbroek * Copyright (C) 1998-2003 Internet Software Consortium.
6*00b67f09SDavid van Moolenbroek *
7*00b67f09SDavid van Moolenbroek * Permission to use, copy, modify, and/or distribute this software for any
8*00b67f09SDavid van Moolenbroek * purpose with or without fee is hereby granted, provided that the above
9*00b67f09SDavid van Moolenbroek * copyright notice and this permission notice appear in all copies.
10*00b67f09SDavid van Moolenbroek *
11*00b67f09SDavid van Moolenbroek * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
12*00b67f09SDavid van Moolenbroek * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
13*00b67f09SDavid van Moolenbroek * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
14*00b67f09SDavid van Moolenbroek * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
15*00b67f09SDavid van Moolenbroek * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
16*00b67f09SDavid van Moolenbroek * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17*00b67f09SDavid van Moolenbroek * PERFORMANCE OF THIS SOFTWARE.
18*00b67f09SDavid van Moolenbroek */
19*00b67f09SDavid van Moolenbroek
20*00b67f09SDavid van Moolenbroek /* Id */
21*00b67f09SDavid van Moolenbroek
22*00b67f09SDavid van Moolenbroek /*! \file
23*00b67f09SDavid van Moolenbroek * \author Principal Author: Bob Halley
24*00b67f09SDavid van Moolenbroek */
25*00b67f09SDavid van Moolenbroek
26*00b67f09SDavid van Moolenbroek /*
27*00b67f09SDavid van Moolenbroek * XXXRTH Need to document the states a task can be in, and the rules
28*00b67f09SDavid van Moolenbroek * for changing states.
29*00b67f09SDavid van Moolenbroek */
30*00b67f09SDavid van Moolenbroek
31*00b67f09SDavid van Moolenbroek #include <config.h>
32*00b67f09SDavid van Moolenbroek
33*00b67f09SDavid van Moolenbroek #include <isc/app.h>
34*00b67f09SDavid van Moolenbroek #include <isc/condition.h>
35*00b67f09SDavid van Moolenbroek #include <isc/event.h>
36*00b67f09SDavid van Moolenbroek #include <isc/json.h>
37*00b67f09SDavid van Moolenbroek #include <isc/magic.h>
38*00b67f09SDavid van Moolenbroek #include <isc/mem.h>
39*00b67f09SDavid van Moolenbroek #include <isc/msgs.h>
40*00b67f09SDavid van Moolenbroek #include <isc/once.h>
41*00b67f09SDavid van Moolenbroek #include <isc/platform.h>
42*00b67f09SDavid van Moolenbroek #include <isc/string.h>
43*00b67f09SDavid van Moolenbroek #include <isc/task.h>
44*00b67f09SDavid van Moolenbroek #include <isc/thread.h>
45*00b67f09SDavid van Moolenbroek #include <isc/util.h>
46*00b67f09SDavid van Moolenbroek #include <isc/xml.h>
47*00b67f09SDavid van Moolenbroek
48*00b67f09SDavid van Moolenbroek #ifdef OPENSSL_LEAKS
49*00b67f09SDavid van Moolenbroek #include <openssl/err.h>
50*00b67f09SDavid van Moolenbroek #endif
51*00b67f09SDavid van Moolenbroek
52*00b67f09SDavid van Moolenbroek /*%
53*00b67f09SDavid van Moolenbroek * For BIND9 internal applications:
54*00b67f09SDavid van Moolenbroek * when built with threads we use multiple worker threads shared by the whole
55*00b67f09SDavid van Moolenbroek * application.
56*00b67f09SDavid van Moolenbroek * when built without threads we share a single global task manager and use
57*00b67f09SDavid van Moolenbroek * an integrated event loop for socket, timer, and other generic task events.
58*00b67f09SDavid van Moolenbroek * For generic library:
59*00b67f09SDavid van Moolenbroek * we don't use either of them: an application can have multiple task managers
60*00b67f09SDavid van Moolenbroek * whether or not it's threaded, and if the application is threaded each thread
61*00b67f09SDavid van Moolenbroek * is expected to have a separate manager; no "worker threads" are shared by
62*00b67f09SDavid van Moolenbroek * the application threads.
63*00b67f09SDavid van Moolenbroek */
64*00b67f09SDavid van Moolenbroek #ifdef ISC_PLATFORM_USETHREADS
65*00b67f09SDavid van Moolenbroek #define USE_WORKER_THREADS
66*00b67f09SDavid van Moolenbroek #else
67*00b67f09SDavid van Moolenbroek #define USE_SHARED_MANAGER
68*00b67f09SDavid van Moolenbroek #endif /* ISC_PLATFORM_USETHREADS */
69*00b67f09SDavid van Moolenbroek
70*00b67f09SDavid van Moolenbroek #include "task_p.h"
71*00b67f09SDavid van Moolenbroek
72*00b67f09SDavid van Moolenbroek #ifdef ISC_TASK_TRACE
73*00b67f09SDavid van Moolenbroek #define XTRACE(m) fprintf(stderr, "task %p thread %lu: %s\n", \
74*00b67f09SDavid van Moolenbroek task, isc_thread_self(), (m))
75*00b67f09SDavid van Moolenbroek #define XTTRACE(t, m) fprintf(stderr, "task %p thread %lu: %s\n", \
76*00b67f09SDavid van Moolenbroek (t), isc_thread_self(), (m))
77*00b67f09SDavid van Moolenbroek #define XTHREADTRACE(m) fprintf(stderr, "thread %lu: %s\n", \
78*00b67f09SDavid van Moolenbroek isc_thread_self(), (m))
79*00b67f09SDavid van Moolenbroek #else
80*00b67f09SDavid van Moolenbroek #define XTRACE(m)
81*00b67f09SDavid van Moolenbroek #define XTTRACE(t, m)
82*00b67f09SDavid van Moolenbroek #define XTHREADTRACE(m)
83*00b67f09SDavid van Moolenbroek #endif
84*00b67f09SDavid van Moolenbroek
85*00b67f09SDavid van Moolenbroek /***
86*00b67f09SDavid van Moolenbroek *** Types.
87*00b67f09SDavid van Moolenbroek ***/
88*00b67f09SDavid van Moolenbroek
89*00b67f09SDavid van Moolenbroek typedef enum {
90*00b67f09SDavid van Moolenbroek task_state_idle, task_state_ready, task_state_running,
91*00b67f09SDavid van Moolenbroek task_state_done
92*00b67f09SDavid van Moolenbroek } task_state_t;
93*00b67f09SDavid van Moolenbroek
94*00b67f09SDavid van Moolenbroek #if defined(HAVE_LIBXML2) || defined(HAVE_JSON)
95*00b67f09SDavid van Moolenbroek static const char *statenames[] = {
96*00b67f09SDavid van Moolenbroek "idle", "ready", "running", "done",
97*00b67f09SDavid van Moolenbroek };
98*00b67f09SDavid van Moolenbroek #endif
99*00b67f09SDavid van Moolenbroek
100*00b67f09SDavid van Moolenbroek #define TASK_MAGIC ISC_MAGIC('T', 'A', 'S', 'K')
101*00b67f09SDavid van Moolenbroek #define VALID_TASK(t) ISC_MAGIC_VALID(t, TASK_MAGIC)
102*00b67f09SDavid van Moolenbroek
103*00b67f09SDavid van Moolenbroek typedef struct isc__task isc__task_t;
104*00b67f09SDavid van Moolenbroek typedef struct isc__taskmgr isc__taskmgr_t;
105*00b67f09SDavid van Moolenbroek
106*00b67f09SDavid van Moolenbroek struct isc__task {
107*00b67f09SDavid van Moolenbroek /* Not locked. */
108*00b67f09SDavid van Moolenbroek isc_task_t common;
109*00b67f09SDavid van Moolenbroek isc__taskmgr_t * manager;
110*00b67f09SDavid van Moolenbroek isc_mutex_t lock;
111*00b67f09SDavid van Moolenbroek /* Locked by task lock. */
112*00b67f09SDavid van Moolenbroek task_state_t state;
113*00b67f09SDavid van Moolenbroek unsigned int references;
114*00b67f09SDavid van Moolenbroek isc_eventlist_t events;
115*00b67f09SDavid van Moolenbroek isc_eventlist_t on_shutdown;
116*00b67f09SDavid van Moolenbroek unsigned int nevents;
117*00b67f09SDavid van Moolenbroek unsigned int quantum;
118*00b67f09SDavid van Moolenbroek unsigned int flags;
119*00b67f09SDavid van Moolenbroek isc_stdtime_t now;
120*00b67f09SDavid van Moolenbroek char name[16];
121*00b67f09SDavid van Moolenbroek void * tag;
122*00b67f09SDavid van Moolenbroek /* Locked by task manager lock. */
123*00b67f09SDavid van Moolenbroek LINK(isc__task_t) link;
124*00b67f09SDavid van Moolenbroek LINK(isc__task_t) ready_link;
125*00b67f09SDavid van Moolenbroek LINK(isc__task_t) ready_priority_link;
126*00b67f09SDavid van Moolenbroek };
127*00b67f09SDavid van Moolenbroek
128*00b67f09SDavid van Moolenbroek #define TASK_F_SHUTTINGDOWN 0x01
129*00b67f09SDavid van Moolenbroek #define TASK_F_PRIVILEGED 0x02
130*00b67f09SDavid van Moolenbroek
131*00b67f09SDavid van Moolenbroek #define TASK_SHUTTINGDOWN(t) (((t)->flags & TASK_F_SHUTTINGDOWN) \
132*00b67f09SDavid van Moolenbroek != 0)
133*00b67f09SDavid van Moolenbroek
134*00b67f09SDavid van Moolenbroek #define TASK_MANAGER_MAGIC ISC_MAGIC('T', 'S', 'K', 'M')
135*00b67f09SDavid van Moolenbroek #define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TASK_MANAGER_MAGIC)
136*00b67f09SDavid van Moolenbroek
137*00b67f09SDavid van Moolenbroek typedef ISC_LIST(isc__task_t) isc__tasklist_t;
138*00b67f09SDavid van Moolenbroek
139*00b67f09SDavid van Moolenbroek struct isc__taskmgr {
140*00b67f09SDavid van Moolenbroek /* Not locked. */
141*00b67f09SDavid van Moolenbroek isc_taskmgr_t common;
142*00b67f09SDavid van Moolenbroek isc_mem_t * mctx;
143*00b67f09SDavid van Moolenbroek isc_mutex_t lock;
144*00b67f09SDavid van Moolenbroek #ifdef ISC_PLATFORM_USETHREADS
145*00b67f09SDavid van Moolenbroek unsigned int workers;
146*00b67f09SDavid van Moolenbroek isc_thread_t * threads;
147*00b67f09SDavid van Moolenbroek #endif /* ISC_PLATFORM_USETHREADS */
148*00b67f09SDavid van Moolenbroek /* Locked by task manager lock. */
149*00b67f09SDavid van Moolenbroek unsigned int default_quantum;
150*00b67f09SDavid van Moolenbroek LIST(isc__task_t) tasks;
151*00b67f09SDavid van Moolenbroek isc__tasklist_t ready_tasks;
152*00b67f09SDavid van Moolenbroek isc__tasklist_t ready_priority_tasks;
153*00b67f09SDavid van Moolenbroek isc_taskmgrmode_t mode;
154*00b67f09SDavid van Moolenbroek #ifdef ISC_PLATFORM_USETHREADS
155*00b67f09SDavid van Moolenbroek isc_condition_t work_available;
156*00b67f09SDavid van Moolenbroek isc_condition_t exclusive_granted;
157*00b67f09SDavid van Moolenbroek isc_condition_t paused;
158*00b67f09SDavid van Moolenbroek #endif /* ISC_PLATFORM_USETHREADS */
159*00b67f09SDavid van Moolenbroek unsigned int tasks_running;
160*00b67f09SDavid van Moolenbroek unsigned int tasks_ready;
161*00b67f09SDavid van Moolenbroek isc_boolean_t pause_requested;
162*00b67f09SDavid van Moolenbroek isc_boolean_t exclusive_requested;
163*00b67f09SDavid van Moolenbroek isc_boolean_t exiting;
164*00b67f09SDavid van Moolenbroek isc__task_t *excl;
165*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
166*00b67f09SDavid van Moolenbroek unsigned int refs;
167*00b67f09SDavid van Moolenbroek #endif /* ISC_PLATFORM_USETHREADS */
168*00b67f09SDavid van Moolenbroek };
169*00b67f09SDavid van Moolenbroek
170*00b67f09SDavid van Moolenbroek #define DEFAULT_TASKMGR_QUANTUM 10
171*00b67f09SDavid van Moolenbroek #define DEFAULT_DEFAULT_QUANTUM 5
172*00b67f09SDavid van Moolenbroek #define FINISHED(m) ((m)->exiting && EMPTY((m)->tasks))
173*00b67f09SDavid van Moolenbroek
174*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
175*00b67f09SDavid van Moolenbroek static isc__taskmgr_t *taskmgr = NULL;
176*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
177*00b67f09SDavid van Moolenbroek
178*00b67f09SDavid van Moolenbroek /*%
179*00b67f09SDavid van Moolenbroek * The following are intended for internal use (indicated by "isc__"
180*00b67f09SDavid van Moolenbroek * prefix) but are not declared as static, allowing direct access from
181*00b67f09SDavid van Moolenbroek * unit tests etc.
182*00b67f09SDavid van Moolenbroek */
183*00b67f09SDavid van Moolenbroek
184*00b67f09SDavid van Moolenbroek isc_result_t
185*00b67f09SDavid van Moolenbroek isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
186*00b67f09SDavid van Moolenbroek isc_task_t **taskp);
187*00b67f09SDavid van Moolenbroek void
188*00b67f09SDavid van Moolenbroek isc__task_attach(isc_task_t *source0, isc_task_t **targetp);
189*00b67f09SDavid van Moolenbroek void
190*00b67f09SDavid van Moolenbroek isc__task_detach(isc_task_t **taskp);
191*00b67f09SDavid van Moolenbroek void
192*00b67f09SDavid van Moolenbroek isc__task_send(isc_task_t *task0, isc_event_t **eventp);
193*00b67f09SDavid van Moolenbroek void
194*00b67f09SDavid van Moolenbroek isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp);
195*00b67f09SDavid van Moolenbroek unsigned int
196*00b67f09SDavid van Moolenbroek isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
197*00b67f09SDavid van Moolenbroek isc_eventtype_t last, void *tag);
198*00b67f09SDavid van Moolenbroek unsigned int
199*00b67f09SDavid van Moolenbroek isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
200*00b67f09SDavid van Moolenbroek void *tag);
201*00b67f09SDavid van Moolenbroek isc_boolean_t
202*00b67f09SDavid van Moolenbroek isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
203*00b67f09SDavid van Moolenbroek unsigned int
204*00b67f09SDavid van Moolenbroek isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
205*00b67f09SDavid van Moolenbroek isc_eventtype_t last, void *tag,
206*00b67f09SDavid van Moolenbroek isc_eventlist_t *events);
207*00b67f09SDavid van Moolenbroek unsigned int
208*00b67f09SDavid van Moolenbroek isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
209*00b67f09SDavid van Moolenbroek void *tag, isc_eventlist_t *events);
210*00b67f09SDavid van Moolenbroek isc_result_t
211*00b67f09SDavid van Moolenbroek isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
212*00b67f09SDavid van Moolenbroek void *arg);
213*00b67f09SDavid van Moolenbroek void
214*00b67f09SDavid van Moolenbroek isc__task_shutdown(isc_task_t *task0);
215*00b67f09SDavid van Moolenbroek void
216*00b67f09SDavid van Moolenbroek isc__task_destroy(isc_task_t **taskp);
217*00b67f09SDavid van Moolenbroek void
218*00b67f09SDavid van Moolenbroek isc__task_setname(isc_task_t *task0, const char *name, void *tag);
219*00b67f09SDavid van Moolenbroek const char *
220*00b67f09SDavid van Moolenbroek isc__task_getname(isc_task_t *task0);
221*00b67f09SDavid van Moolenbroek void *
222*00b67f09SDavid van Moolenbroek isc__task_gettag(isc_task_t *task0);
223*00b67f09SDavid van Moolenbroek void
224*00b67f09SDavid van Moolenbroek isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t);
225*00b67f09SDavid van Moolenbroek isc_result_t
226*00b67f09SDavid van Moolenbroek isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
227*00b67f09SDavid van Moolenbroek unsigned int default_quantum, isc_taskmgr_t **managerp);
228*00b67f09SDavid van Moolenbroek void
229*00b67f09SDavid van Moolenbroek isc__taskmgr_destroy(isc_taskmgr_t **managerp);
230*00b67f09SDavid van Moolenbroek void
231*00b67f09SDavid van Moolenbroek isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
232*00b67f09SDavid van Moolenbroek isc_result_t
233*00b67f09SDavid van Moolenbroek isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
234*00b67f09SDavid van Moolenbroek isc_result_t
235*00b67f09SDavid van Moolenbroek isc__task_beginexclusive(isc_task_t *task);
236*00b67f09SDavid van Moolenbroek void
237*00b67f09SDavid van Moolenbroek isc__task_endexclusive(isc_task_t *task0);
238*00b67f09SDavid van Moolenbroek void
239*00b67f09SDavid van Moolenbroek isc__task_setprivilege(isc_task_t *task0, isc_boolean_t priv);
240*00b67f09SDavid van Moolenbroek isc_boolean_t
241*00b67f09SDavid van Moolenbroek isc__task_privilege(isc_task_t *task0);
242*00b67f09SDavid van Moolenbroek void
243*00b67f09SDavid van Moolenbroek isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode);
244*00b67f09SDavid van Moolenbroek isc_taskmgrmode_t
245*00b67f09SDavid van Moolenbroek isc__taskmgr_mode(isc_taskmgr_t *manager0);
246*00b67f09SDavid van Moolenbroek
247*00b67f09SDavid van Moolenbroek static inline isc_boolean_t
248*00b67f09SDavid van Moolenbroek empty_readyq(isc__taskmgr_t *manager);
249*00b67f09SDavid van Moolenbroek
250*00b67f09SDavid van Moolenbroek static inline isc__task_t *
251*00b67f09SDavid van Moolenbroek pop_readyq(isc__taskmgr_t *manager);
252*00b67f09SDavid van Moolenbroek
253*00b67f09SDavid van Moolenbroek static inline void
254*00b67f09SDavid van Moolenbroek push_readyq(isc__taskmgr_t *manager, isc__task_t *task);
255*00b67f09SDavid van Moolenbroek
256*00b67f09SDavid van Moolenbroek static struct isc__taskmethods {
257*00b67f09SDavid van Moolenbroek isc_taskmethods_t methods;
258*00b67f09SDavid van Moolenbroek
259*00b67f09SDavid van Moolenbroek /*%
260*00b67f09SDavid van Moolenbroek * The following are defined just for avoiding unused static functions.
261*00b67f09SDavid van Moolenbroek */
262*00b67f09SDavid van Moolenbroek void *purgeevent, *unsendrange, *getname, *gettag, *getcurrenttime;
263*00b67f09SDavid van Moolenbroek } taskmethods = {
264*00b67f09SDavid van Moolenbroek {
265*00b67f09SDavid van Moolenbroek isc__task_attach,
266*00b67f09SDavid van Moolenbroek isc__task_detach,
267*00b67f09SDavid van Moolenbroek isc__task_destroy,
268*00b67f09SDavid van Moolenbroek isc__task_send,
269*00b67f09SDavid van Moolenbroek isc__task_sendanddetach,
270*00b67f09SDavid van Moolenbroek isc__task_unsend,
271*00b67f09SDavid van Moolenbroek isc__task_onshutdown,
272*00b67f09SDavid van Moolenbroek isc__task_shutdown,
273*00b67f09SDavid van Moolenbroek isc__task_setname,
274*00b67f09SDavid van Moolenbroek isc__task_purge,
275*00b67f09SDavid van Moolenbroek isc__task_purgerange,
276*00b67f09SDavid van Moolenbroek isc__task_beginexclusive,
277*00b67f09SDavid van Moolenbroek isc__task_endexclusive,
278*00b67f09SDavid van Moolenbroek isc__task_setprivilege,
279*00b67f09SDavid van Moolenbroek isc__task_privilege
280*00b67f09SDavid van Moolenbroek },
281*00b67f09SDavid van Moolenbroek (void *)isc_task_purgeevent,
282*00b67f09SDavid van Moolenbroek (void *)isc__task_unsendrange,
283*00b67f09SDavid van Moolenbroek (void *)isc__task_getname,
284*00b67f09SDavid van Moolenbroek (void *)isc__task_gettag,
285*00b67f09SDavid van Moolenbroek (void *)isc__task_getcurrenttime
286*00b67f09SDavid van Moolenbroek };
287*00b67f09SDavid van Moolenbroek
288*00b67f09SDavid van Moolenbroek static isc_taskmgrmethods_t taskmgrmethods = {
289*00b67f09SDavid van Moolenbroek isc__taskmgr_destroy,
290*00b67f09SDavid van Moolenbroek isc__taskmgr_setmode,
291*00b67f09SDavid van Moolenbroek isc__taskmgr_mode,
292*00b67f09SDavid van Moolenbroek isc__task_create,
293*00b67f09SDavid van Moolenbroek isc_taskmgr_setexcltask,
294*00b67f09SDavid van Moolenbroek isc_taskmgr_excltask
295*00b67f09SDavid van Moolenbroek };
296*00b67f09SDavid van Moolenbroek
297*00b67f09SDavid van Moolenbroek /***
298*00b67f09SDavid van Moolenbroek *** Tasks.
299*00b67f09SDavid van Moolenbroek ***/
300*00b67f09SDavid van Moolenbroek
301*00b67f09SDavid van Moolenbroek static void
task_finished(isc__task_t * task)302*00b67f09SDavid van Moolenbroek task_finished(isc__task_t *task) {
303*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = task->manager;
304*00b67f09SDavid van Moolenbroek
305*00b67f09SDavid van Moolenbroek REQUIRE(EMPTY(task->events));
306*00b67f09SDavid van Moolenbroek REQUIRE(task->nevents == 0);
307*00b67f09SDavid van Moolenbroek REQUIRE(EMPTY(task->on_shutdown));
308*00b67f09SDavid van Moolenbroek REQUIRE(task->references == 0);
309*00b67f09SDavid van Moolenbroek REQUIRE(task->state == task_state_done);
310*00b67f09SDavid van Moolenbroek
311*00b67f09SDavid van Moolenbroek XTRACE("task_finished");
312*00b67f09SDavid van Moolenbroek
313*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
314*00b67f09SDavid van Moolenbroek UNLINK(manager->tasks, task, link);
315*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
316*00b67f09SDavid van Moolenbroek if (FINISHED(manager)) {
317*00b67f09SDavid van Moolenbroek /*
318*00b67f09SDavid van Moolenbroek * All tasks have completed and the
319*00b67f09SDavid van Moolenbroek * task manager is exiting. Wake up
320*00b67f09SDavid van Moolenbroek * any idle worker threads so they
321*00b67f09SDavid van Moolenbroek * can exit.
322*00b67f09SDavid van Moolenbroek */
323*00b67f09SDavid van Moolenbroek BROADCAST(&manager->work_available);
324*00b67f09SDavid van Moolenbroek }
325*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
326*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
327*00b67f09SDavid van Moolenbroek
328*00b67f09SDavid van Moolenbroek DESTROYLOCK(&task->lock);
329*00b67f09SDavid van Moolenbroek task->common.impmagic = 0;
330*00b67f09SDavid van Moolenbroek task->common.magic = 0;
331*00b67f09SDavid van Moolenbroek isc_mem_put(manager->mctx, task, sizeof(*task));
332*00b67f09SDavid van Moolenbroek }
333*00b67f09SDavid van Moolenbroek
334*00b67f09SDavid van Moolenbroek isc_result_t
isc__task_create(isc_taskmgr_t * manager0,unsigned int quantum,isc_task_t ** taskp)335*00b67f09SDavid van Moolenbroek isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
336*00b67f09SDavid van Moolenbroek isc_task_t **taskp)
337*00b67f09SDavid van Moolenbroek {
338*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
339*00b67f09SDavid van Moolenbroek isc__task_t *task;
340*00b67f09SDavid van Moolenbroek isc_boolean_t exiting;
341*00b67f09SDavid van Moolenbroek isc_result_t result;
342*00b67f09SDavid van Moolenbroek
343*00b67f09SDavid van Moolenbroek REQUIRE(VALID_MANAGER(manager));
344*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL && *taskp == NULL);
345*00b67f09SDavid van Moolenbroek
346*00b67f09SDavid van Moolenbroek task = isc_mem_get(manager->mctx, sizeof(*task));
347*00b67f09SDavid van Moolenbroek if (task == NULL)
348*00b67f09SDavid van Moolenbroek return (ISC_R_NOMEMORY);
349*00b67f09SDavid van Moolenbroek XTRACE("isc_task_create");
350*00b67f09SDavid van Moolenbroek task->manager = manager;
351*00b67f09SDavid van Moolenbroek result = isc_mutex_init(&task->lock);
352*00b67f09SDavid van Moolenbroek if (result != ISC_R_SUCCESS) {
353*00b67f09SDavid van Moolenbroek isc_mem_put(manager->mctx, task, sizeof(*task));
354*00b67f09SDavid van Moolenbroek return (result);
355*00b67f09SDavid van Moolenbroek }
356*00b67f09SDavid van Moolenbroek task->state = task_state_idle;
357*00b67f09SDavid van Moolenbroek task->references = 1;
358*00b67f09SDavid van Moolenbroek INIT_LIST(task->events);
359*00b67f09SDavid van Moolenbroek INIT_LIST(task->on_shutdown);
360*00b67f09SDavid van Moolenbroek task->nevents = 0;
361*00b67f09SDavid van Moolenbroek task->quantum = quantum;
362*00b67f09SDavid van Moolenbroek task->flags = 0;
363*00b67f09SDavid van Moolenbroek task->now = 0;
364*00b67f09SDavid van Moolenbroek memset(task->name, 0, sizeof(task->name));
365*00b67f09SDavid van Moolenbroek task->tag = NULL;
366*00b67f09SDavid van Moolenbroek INIT_LINK(task, link);
367*00b67f09SDavid van Moolenbroek INIT_LINK(task, ready_link);
368*00b67f09SDavid van Moolenbroek INIT_LINK(task, ready_priority_link);
369*00b67f09SDavid van Moolenbroek
370*00b67f09SDavid van Moolenbroek exiting = ISC_FALSE;
371*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
372*00b67f09SDavid van Moolenbroek if (!manager->exiting) {
373*00b67f09SDavid van Moolenbroek if (task->quantum == 0)
374*00b67f09SDavid van Moolenbroek task->quantum = manager->default_quantum;
375*00b67f09SDavid van Moolenbroek APPEND(manager->tasks, task, link);
376*00b67f09SDavid van Moolenbroek } else
377*00b67f09SDavid van Moolenbroek exiting = ISC_TRUE;
378*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
379*00b67f09SDavid van Moolenbroek
380*00b67f09SDavid van Moolenbroek if (exiting) {
381*00b67f09SDavid van Moolenbroek DESTROYLOCK(&task->lock);
382*00b67f09SDavid van Moolenbroek isc_mem_put(manager->mctx, task, sizeof(*task));
383*00b67f09SDavid van Moolenbroek return (ISC_R_SHUTTINGDOWN);
384*00b67f09SDavid van Moolenbroek }
385*00b67f09SDavid van Moolenbroek
386*00b67f09SDavid van Moolenbroek task->common.methods = (isc_taskmethods_t *)&taskmethods;
387*00b67f09SDavid van Moolenbroek task->common.magic = ISCAPI_TASK_MAGIC;
388*00b67f09SDavid van Moolenbroek task->common.impmagic = TASK_MAGIC;
389*00b67f09SDavid van Moolenbroek *taskp = (isc_task_t *)task;
390*00b67f09SDavid van Moolenbroek
391*00b67f09SDavid van Moolenbroek return (ISC_R_SUCCESS);
392*00b67f09SDavid van Moolenbroek }
393*00b67f09SDavid van Moolenbroek
394*00b67f09SDavid van Moolenbroek void
isc__task_attach(isc_task_t * source0,isc_task_t ** targetp)395*00b67f09SDavid van Moolenbroek isc__task_attach(isc_task_t *source0, isc_task_t **targetp) {
396*00b67f09SDavid van Moolenbroek isc__task_t *source = (isc__task_t *)source0;
397*00b67f09SDavid van Moolenbroek
398*00b67f09SDavid van Moolenbroek /*
399*00b67f09SDavid van Moolenbroek * Attach *targetp to source.
400*00b67f09SDavid van Moolenbroek */
401*00b67f09SDavid van Moolenbroek
402*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(source));
403*00b67f09SDavid van Moolenbroek REQUIRE(targetp != NULL && *targetp == NULL);
404*00b67f09SDavid van Moolenbroek
405*00b67f09SDavid van Moolenbroek XTTRACE(source, "isc_task_attach");
406*00b67f09SDavid van Moolenbroek
407*00b67f09SDavid van Moolenbroek LOCK(&source->lock);
408*00b67f09SDavid van Moolenbroek source->references++;
409*00b67f09SDavid van Moolenbroek UNLOCK(&source->lock);
410*00b67f09SDavid van Moolenbroek
411*00b67f09SDavid van Moolenbroek *targetp = (isc_task_t *)source;
412*00b67f09SDavid van Moolenbroek }
413*00b67f09SDavid van Moolenbroek
414*00b67f09SDavid van Moolenbroek static inline isc_boolean_t
task_shutdown(isc__task_t * task)415*00b67f09SDavid van Moolenbroek task_shutdown(isc__task_t *task) {
416*00b67f09SDavid van Moolenbroek isc_boolean_t was_idle = ISC_FALSE;
417*00b67f09SDavid van Moolenbroek isc_event_t *event, *prev;
418*00b67f09SDavid van Moolenbroek
419*00b67f09SDavid van Moolenbroek /*
420*00b67f09SDavid van Moolenbroek * Caller must be holding the task's lock.
421*00b67f09SDavid van Moolenbroek */
422*00b67f09SDavid van Moolenbroek
423*00b67f09SDavid van Moolenbroek XTRACE("task_shutdown");
424*00b67f09SDavid van Moolenbroek
425*00b67f09SDavid van Moolenbroek if (! TASK_SHUTTINGDOWN(task)) {
426*00b67f09SDavid van Moolenbroek XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
427*00b67f09SDavid van Moolenbroek ISC_MSG_SHUTTINGDOWN, "shutting down"));
428*00b67f09SDavid van Moolenbroek task->flags |= TASK_F_SHUTTINGDOWN;
429*00b67f09SDavid van Moolenbroek if (task->state == task_state_idle) {
430*00b67f09SDavid van Moolenbroek INSIST(EMPTY(task->events));
431*00b67f09SDavid van Moolenbroek task->state = task_state_ready;
432*00b67f09SDavid van Moolenbroek was_idle = ISC_TRUE;
433*00b67f09SDavid van Moolenbroek }
434*00b67f09SDavid van Moolenbroek INSIST(task->state == task_state_ready ||
435*00b67f09SDavid van Moolenbroek task->state == task_state_running);
436*00b67f09SDavid van Moolenbroek
437*00b67f09SDavid van Moolenbroek /*
438*00b67f09SDavid van Moolenbroek * Note that we post shutdown events LIFO.
439*00b67f09SDavid van Moolenbroek */
440*00b67f09SDavid van Moolenbroek for (event = TAIL(task->on_shutdown);
441*00b67f09SDavid van Moolenbroek event != NULL;
442*00b67f09SDavid van Moolenbroek event = prev) {
443*00b67f09SDavid van Moolenbroek prev = PREV(event, ev_link);
444*00b67f09SDavid van Moolenbroek DEQUEUE(task->on_shutdown, event, ev_link);
445*00b67f09SDavid van Moolenbroek ENQUEUE(task->events, event, ev_link);
446*00b67f09SDavid van Moolenbroek task->nevents++;
447*00b67f09SDavid van Moolenbroek }
448*00b67f09SDavid van Moolenbroek }
449*00b67f09SDavid van Moolenbroek
450*00b67f09SDavid van Moolenbroek return (was_idle);
451*00b67f09SDavid van Moolenbroek }
452*00b67f09SDavid van Moolenbroek
453*00b67f09SDavid van Moolenbroek /*
454*00b67f09SDavid van Moolenbroek * Moves a task onto the appropriate run queue.
455*00b67f09SDavid van Moolenbroek *
456*00b67f09SDavid van Moolenbroek * Caller must NOT hold manager lock.
457*00b67f09SDavid van Moolenbroek */
458*00b67f09SDavid van Moolenbroek static inline void
task_ready(isc__task_t * task)459*00b67f09SDavid van Moolenbroek task_ready(isc__task_t *task) {
460*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = task->manager;
461*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
462*00b67f09SDavid van Moolenbroek isc_boolean_t has_privilege = isc__task_privilege((isc_task_t *) task);
463*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
464*00b67f09SDavid van Moolenbroek
465*00b67f09SDavid van Moolenbroek REQUIRE(VALID_MANAGER(manager));
466*00b67f09SDavid van Moolenbroek REQUIRE(task->state == task_state_ready);
467*00b67f09SDavid van Moolenbroek
468*00b67f09SDavid van Moolenbroek XTRACE("task_ready");
469*00b67f09SDavid van Moolenbroek
470*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
471*00b67f09SDavid van Moolenbroek push_readyq(manager, task);
472*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
473*00b67f09SDavid van Moolenbroek if (manager->mode == isc_taskmgrmode_normal || has_privilege)
474*00b67f09SDavid van Moolenbroek SIGNAL(&manager->work_available);
475*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
476*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
477*00b67f09SDavid van Moolenbroek }
478*00b67f09SDavid van Moolenbroek
479*00b67f09SDavid van Moolenbroek static inline isc_boolean_t
task_detach(isc__task_t * task)480*00b67f09SDavid van Moolenbroek task_detach(isc__task_t *task) {
481*00b67f09SDavid van Moolenbroek
482*00b67f09SDavid van Moolenbroek /*
483*00b67f09SDavid van Moolenbroek * Caller must be holding the task lock.
484*00b67f09SDavid van Moolenbroek */
485*00b67f09SDavid van Moolenbroek
486*00b67f09SDavid van Moolenbroek REQUIRE(task->references > 0);
487*00b67f09SDavid van Moolenbroek
488*00b67f09SDavid van Moolenbroek XTRACE("detach");
489*00b67f09SDavid van Moolenbroek
490*00b67f09SDavid van Moolenbroek task->references--;
491*00b67f09SDavid van Moolenbroek if (task->references == 0 && task->state == task_state_idle) {
492*00b67f09SDavid van Moolenbroek INSIST(EMPTY(task->events));
493*00b67f09SDavid van Moolenbroek /*
494*00b67f09SDavid van Moolenbroek * There are no references to this task, and no
495*00b67f09SDavid van Moolenbroek * pending events. We could try to optimize and
496*00b67f09SDavid van Moolenbroek * either initiate shutdown or clean up the task,
497*00b67f09SDavid van Moolenbroek * depending on its state, but it's easier to just
498*00b67f09SDavid van Moolenbroek * make the task ready and allow run() or the event
499*00b67f09SDavid van Moolenbroek * loop to deal with shutting down and termination.
500*00b67f09SDavid van Moolenbroek */
501*00b67f09SDavid van Moolenbroek task->state = task_state_ready;
502*00b67f09SDavid van Moolenbroek return (ISC_TRUE);
503*00b67f09SDavid van Moolenbroek }
504*00b67f09SDavid van Moolenbroek
505*00b67f09SDavid van Moolenbroek return (ISC_FALSE);
506*00b67f09SDavid van Moolenbroek }
507*00b67f09SDavid van Moolenbroek
508*00b67f09SDavid van Moolenbroek void
isc__task_detach(isc_task_t ** taskp)509*00b67f09SDavid van Moolenbroek isc__task_detach(isc_task_t **taskp) {
510*00b67f09SDavid van Moolenbroek isc__task_t *task;
511*00b67f09SDavid van Moolenbroek isc_boolean_t was_idle;
512*00b67f09SDavid van Moolenbroek
513*00b67f09SDavid van Moolenbroek /*
514*00b67f09SDavid van Moolenbroek * Detach *taskp from its task.
515*00b67f09SDavid van Moolenbroek */
516*00b67f09SDavid van Moolenbroek
517*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL);
518*00b67f09SDavid van Moolenbroek task = (isc__task_t *)*taskp;
519*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
520*00b67f09SDavid van Moolenbroek
521*00b67f09SDavid van Moolenbroek XTRACE("isc_task_detach");
522*00b67f09SDavid van Moolenbroek
523*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
524*00b67f09SDavid van Moolenbroek was_idle = task_detach(task);
525*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
526*00b67f09SDavid van Moolenbroek
527*00b67f09SDavid van Moolenbroek if (was_idle)
528*00b67f09SDavid van Moolenbroek task_ready(task);
529*00b67f09SDavid van Moolenbroek
530*00b67f09SDavid van Moolenbroek *taskp = NULL;
531*00b67f09SDavid van Moolenbroek }
532*00b67f09SDavid van Moolenbroek
533*00b67f09SDavid van Moolenbroek static inline isc_boolean_t
task_send(isc__task_t * task,isc_event_t ** eventp)534*00b67f09SDavid van Moolenbroek task_send(isc__task_t *task, isc_event_t **eventp) {
535*00b67f09SDavid van Moolenbroek isc_boolean_t was_idle = ISC_FALSE;
536*00b67f09SDavid van Moolenbroek isc_event_t *event;
537*00b67f09SDavid van Moolenbroek
538*00b67f09SDavid van Moolenbroek /*
539*00b67f09SDavid van Moolenbroek * Caller must be holding the task lock.
540*00b67f09SDavid van Moolenbroek */
541*00b67f09SDavid van Moolenbroek
542*00b67f09SDavid van Moolenbroek REQUIRE(eventp != NULL);
543*00b67f09SDavid van Moolenbroek event = *eventp;
544*00b67f09SDavid van Moolenbroek REQUIRE(event != NULL);
545*00b67f09SDavid van Moolenbroek REQUIRE(event->ev_type > 0);
546*00b67f09SDavid van Moolenbroek REQUIRE(task->state != task_state_done);
547*00b67f09SDavid van Moolenbroek
548*00b67f09SDavid van Moolenbroek XTRACE("task_send");
549*00b67f09SDavid van Moolenbroek
550*00b67f09SDavid van Moolenbroek if (task->state == task_state_idle) {
551*00b67f09SDavid van Moolenbroek was_idle = ISC_TRUE;
552*00b67f09SDavid van Moolenbroek INSIST(EMPTY(task->events));
553*00b67f09SDavid van Moolenbroek task->state = task_state_ready;
554*00b67f09SDavid van Moolenbroek }
555*00b67f09SDavid van Moolenbroek INSIST(task->state == task_state_ready ||
556*00b67f09SDavid van Moolenbroek task->state == task_state_running);
557*00b67f09SDavid van Moolenbroek ENQUEUE(task->events, event, ev_link);
558*00b67f09SDavid van Moolenbroek task->nevents++;
559*00b67f09SDavid van Moolenbroek *eventp = NULL;
560*00b67f09SDavid van Moolenbroek
561*00b67f09SDavid van Moolenbroek return (was_idle);
562*00b67f09SDavid van Moolenbroek }
563*00b67f09SDavid van Moolenbroek
564*00b67f09SDavid van Moolenbroek void
isc__task_send(isc_task_t * task0,isc_event_t ** eventp)565*00b67f09SDavid van Moolenbroek isc__task_send(isc_task_t *task0, isc_event_t **eventp) {
566*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
567*00b67f09SDavid van Moolenbroek isc_boolean_t was_idle;
568*00b67f09SDavid van Moolenbroek
569*00b67f09SDavid van Moolenbroek /*
570*00b67f09SDavid van Moolenbroek * Send '*event' to 'task'.
571*00b67f09SDavid van Moolenbroek */
572*00b67f09SDavid van Moolenbroek
573*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
574*00b67f09SDavid van Moolenbroek
575*00b67f09SDavid van Moolenbroek XTRACE("isc_task_send");
576*00b67f09SDavid van Moolenbroek
577*00b67f09SDavid van Moolenbroek /*
578*00b67f09SDavid van Moolenbroek * We're trying hard to hold locks for as short a time as possible.
579*00b67f09SDavid van Moolenbroek * We're also trying to hold as few locks as possible. This is why
580*00b67f09SDavid van Moolenbroek * some processing is deferred until after the lock is released.
581*00b67f09SDavid van Moolenbroek */
582*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
583*00b67f09SDavid van Moolenbroek was_idle = task_send(task, eventp);
584*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
585*00b67f09SDavid van Moolenbroek
586*00b67f09SDavid van Moolenbroek if (was_idle) {
587*00b67f09SDavid van Moolenbroek /*
588*00b67f09SDavid van Moolenbroek * We need to add this task to the ready queue.
589*00b67f09SDavid van Moolenbroek *
590*00b67f09SDavid van Moolenbroek * We've waited until now to do it because making a task
591*00b67f09SDavid van Moolenbroek * ready requires locking the manager. If we tried to do
592*00b67f09SDavid van Moolenbroek * this while holding the task lock, we could deadlock.
593*00b67f09SDavid van Moolenbroek *
594*00b67f09SDavid van Moolenbroek * We've changed the state to ready, so no one else will
595*00b67f09SDavid van Moolenbroek * be trying to add this task to the ready queue. The
596*00b67f09SDavid van Moolenbroek * only way to leave the ready state is by executing the
597*00b67f09SDavid van Moolenbroek * task. It thus doesn't matter if events are added,
598*00b67f09SDavid van Moolenbroek * removed, or a shutdown is started in the interval
599*00b67f09SDavid van Moolenbroek * between the time we released the task lock, and the time
600*00b67f09SDavid van Moolenbroek * we add the task to the ready queue.
601*00b67f09SDavid van Moolenbroek */
602*00b67f09SDavid van Moolenbroek task_ready(task);
603*00b67f09SDavid van Moolenbroek }
604*00b67f09SDavid van Moolenbroek }
605*00b67f09SDavid van Moolenbroek
606*00b67f09SDavid van Moolenbroek void
isc__task_sendanddetach(isc_task_t ** taskp,isc_event_t ** eventp)607*00b67f09SDavid van Moolenbroek isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
608*00b67f09SDavid van Moolenbroek isc_boolean_t idle1, idle2;
609*00b67f09SDavid van Moolenbroek isc__task_t *task;
610*00b67f09SDavid van Moolenbroek
611*00b67f09SDavid van Moolenbroek /*
612*00b67f09SDavid van Moolenbroek * Send '*event' to '*taskp' and then detach '*taskp' from its
613*00b67f09SDavid van Moolenbroek * task.
614*00b67f09SDavid van Moolenbroek */
615*00b67f09SDavid van Moolenbroek
616*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL);
617*00b67f09SDavid van Moolenbroek task = (isc__task_t *)*taskp;
618*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
619*00b67f09SDavid van Moolenbroek
620*00b67f09SDavid van Moolenbroek XTRACE("isc_task_sendanddetach");
621*00b67f09SDavid van Moolenbroek
622*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
623*00b67f09SDavid van Moolenbroek idle1 = task_send(task, eventp);
624*00b67f09SDavid van Moolenbroek idle2 = task_detach(task);
625*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
626*00b67f09SDavid van Moolenbroek
627*00b67f09SDavid van Moolenbroek /*
628*00b67f09SDavid van Moolenbroek * If idle1, then idle2 shouldn't be true as well since we're holding
629*00b67f09SDavid van Moolenbroek * the task lock, and thus the task cannot switch from ready back to
630*00b67f09SDavid van Moolenbroek * idle.
631*00b67f09SDavid van Moolenbroek */
632*00b67f09SDavid van Moolenbroek INSIST(!(idle1 && idle2));
633*00b67f09SDavid van Moolenbroek
634*00b67f09SDavid van Moolenbroek if (idle1 || idle2)
635*00b67f09SDavid van Moolenbroek task_ready(task);
636*00b67f09SDavid van Moolenbroek
637*00b67f09SDavid van Moolenbroek *taskp = NULL;
638*00b67f09SDavid van Moolenbroek }
639*00b67f09SDavid van Moolenbroek
640*00b67f09SDavid van Moolenbroek #define PURGE_OK(event) (((event)->ev_attributes & ISC_EVENTATTR_NOPURGE) == 0)
641*00b67f09SDavid van Moolenbroek
642*00b67f09SDavid van Moolenbroek 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,isc_boolean_t purging)643*00b67f09SDavid van Moolenbroek dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first,
644*00b67f09SDavid van Moolenbroek isc_eventtype_t last, void *tag,
645*00b67f09SDavid van Moolenbroek isc_eventlist_t *events, isc_boolean_t purging)
646*00b67f09SDavid van Moolenbroek {
647*00b67f09SDavid van Moolenbroek isc_event_t *event, *next_event;
648*00b67f09SDavid van Moolenbroek unsigned int count = 0;
649*00b67f09SDavid van Moolenbroek
650*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
651*00b67f09SDavid van Moolenbroek REQUIRE(last >= first);
652*00b67f09SDavid van Moolenbroek
653*00b67f09SDavid van Moolenbroek XTRACE("dequeue_events");
654*00b67f09SDavid van Moolenbroek
655*00b67f09SDavid van Moolenbroek /*
656*00b67f09SDavid van Moolenbroek * Events matching 'sender', whose type is >= first and <= last, and
657*00b67f09SDavid van Moolenbroek * whose tag is 'tag' will be dequeued. If 'purging', matching events
658*00b67f09SDavid van Moolenbroek * which are marked as unpurgable will not be dequeued.
659*00b67f09SDavid van Moolenbroek *
660*00b67f09SDavid van Moolenbroek * sender == NULL means "any sender", and tag == NULL means "any tag".
661*00b67f09SDavid van Moolenbroek */
662*00b67f09SDavid van Moolenbroek
663*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
664*00b67f09SDavid van Moolenbroek
665*00b67f09SDavid van Moolenbroek for (event = HEAD(task->events); event != NULL; event = next_event) {
666*00b67f09SDavid van Moolenbroek next_event = NEXT(event, ev_link);
667*00b67f09SDavid van Moolenbroek if (event->ev_type >= first && event->ev_type <= last &&
668*00b67f09SDavid van Moolenbroek (sender == NULL || event->ev_sender == sender) &&
669*00b67f09SDavid van Moolenbroek (tag == NULL || event->ev_tag == tag) &&
670*00b67f09SDavid van Moolenbroek (!purging || PURGE_OK(event))) {
671*00b67f09SDavid van Moolenbroek DEQUEUE(task->events, event, ev_link);
672*00b67f09SDavid van Moolenbroek task->nevents--;
673*00b67f09SDavid van Moolenbroek ENQUEUE(*events, event, ev_link);
674*00b67f09SDavid van Moolenbroek count++;
675*00b67f09SDavid van Moolenbroek }
676*00b67f09SDavid van Moolenbroek }
677*00b67f09SDavid van Moolenbroek
678*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
679*00b67f09SDavid van Moolenbroek
680*00b67f09SDavid van Moolenbroek return (count);
681*00b67f09SDavid van Moolenbroek }
682*00b67f09SDavid van Moolenbroek
683*00b67f09SDavid van Moolenbroek unsigned int
isc__task_purgerange(isc_task_t * task0,void * sender,isc_eventtype_t first,isc_eventtype_t last,void * tag)684*00b67f09SDavid van Moolenbroek isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
685*00b67f09SDavid van Moolenbroek isc_eventtype_t last, void *tag)
686*00b67f09SDavid van Moolenbroek {
687*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
688*00b67f09SDavid van Moolenbroek unsigned int count;
689*00b67f09SDavid van Moolenbroek isc_eventlist_t events;
690*00b67f09SDavid van Moolenbroek isc_event_t *event, *next_event;
691*00b67f09SDavid van Moolenbroek
692*00b67f09SDavid van Moolenbroek /*
693*00b67f09SDavid van Moolenbroek * Purge events from a task's event queue.
694*00b67f09SDavid van Moolenbroek */
695*00b67f09SDavid van Moolenbroek
696*00b67f09SDavid van Moolenbroek XTRACE("isc_task_purgerange");
697*00b67f09SDavid van Moolenbroek
698*00b67f09SDavid van Moolenbroek ISC_LIST_INIT(events);
699*00b67f09SDavid van Moolenbroek
700*00b67f09SDavid van Moolenbroek count = dequeue_events(task, sender, first, last, tag, &events,
701*00b67f09SDavid van Moolenbroek ISC_TRUE);
702*00b67f09SDavid van Moolenbroek
703*00b67f09SDavid van Moolenbroek for (event = HEAD(events); event != NULL; event = next_event) {
704*00b67f09SDavid van Moolenbroek next_event = NEXT(event, ev_link);
705*00b67f09SDavid van Moolenbroek isc_event_free(&event);
706*00b67f09SDavid van Moolenbroek }
707*00b67f09SDavid van Moolenbroek
708*00b67f09SDavid van Moolenbroek /*
709*00b67f09SDavid van Moolenbroek * Note that purging never changes the state of the task.
710*00b67f09SDavid van Moolenbroek */
711*00b67f09SDavid van Moolenbroek
712*00b67f09SDavid van Moolenbroek return (count);
713*00b67f09SDavid van Moolenbroek }
714*00b67f09SDavid van Moolenbroek
715*00b67f09SDavid van Moolenbroek unsigned int
isc__task_purge(isc_task_t * task,void * sender,isc_eventtype_t type,void * tag)716*00b67f09SDavid van Moolenbroek isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
717*00b67f09SDavid van Moolenbroek void *tag)
718*00b67f09SDavid van Moolenbroek {
719*00b67f09SDavid van Moolenbroek /*
720*00b67f09SDavid van Moolenbroek * Purge events from a task's event queue.
721*00b67f09SDavid van Moolenbroek */
722*00b67f09SDavid van Moolenbroek
723*00b67f09SDavid van Moolenbroek XTRACE("isc_task_purge");
724*00b67f09SDavid van Moolenbroek
725*00b67f09SDavid van Moolenbroek return (isc__task_purgerange(task, sender, type, type, tag));
726*00b67f09SDavid van Moolenbroek }
727*00b67f09SDavid van Moolenbroek
728*00b67f09SDavid van Moolenbroek isc_boolean_t
isc_task_purgeevent(isc_task_t * task0,isc_event_t * event)729*00b67f09SDavid van Moolenbroek isc_task_purgeevent(isc_task_t *task0, isc_event_t *event) {
730*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
731*00b67f09SDavid van Moolenbroek isc_event_t *curr_event, *next_event;
732*00b67f09SDavid van Moolenbroek
733*00b67f09SDavid van Moolenbroek /*
734*00b67f09SDavid van Moolenbroek * Purge 'event' from a task's event queue.
735*00b67f09SDavid van Moolenbroek *
736*00b67f09SDavid van Moolenbroek * XXXRTH: WARNING: This method may be removed before beta.
737*00b67f09SDavid van Moolenbroek */
738*00b67f09SDavid van Moolenbroek
739*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
740*00b67f09SDavid van Moolenbroek
741*00b67f09SDavid van Moolenbroek /*
742*00b67f09SDavid van Moolenbroek * If 'event' is on the task's event queue, it will be purged,
743*00b67f09SDavid van Moolenbroek * unless it is marked as unpurgeable. 'event' does not have to be
744*00b67f09SDavid van Moolenbroek * on the task's event queue; in fact, it can even be an invalid
745*00b67f09SDavid van Moolenbroek * pointer. Purging only occurs if the event is actually on the task's
746*00b67f09SDavid van Moolenbroek * event queue.
747*00b67f09SDavid van Moolenbroek *
748*00b67f09SDavid van Moolenbroek * Purging never changes the state of the task.
749*00b67f09SDavid van Moolenbroek */
750*00b67f09SDavid van Moolenbroek
751*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
752*00b67f09SDavid van Moolenbroek for (curr_event = HEAD(task->events);
753*00b67f09SDavid van Moolenbroek curr_event != NULL;
754*00b67f09SDavid van Moolenbroek curr_event = next_event) {
755*00b67f09SDavid van Moolenbroek next_event = NEXT(curr_event, ev_link);
756*00b67f09SDavid van Moolenbroek if (curr_event == event && PURGE_OK(event)) {
757*00b67f09SDavid van Moolenbroek DEQUEUE(task->events, curr_event, ev_link);
758*00b67f09SDavid van Moolenbroek task->nevents--;
759*00b67f09SDavid van Moolenbroek break;
760*00b67f09SDavid van Moolenbroek }
761*00b67f09SDavid van Moolenbroek }
762*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
763*00b67f09SDavid van Moolenbroek
764*00b67f09SDavid van Moolenbroek if (curr_event == NULL)
765*00b67f09SDavid van Moolenbroek return (ISC_FALSE);
766*00b67f09SDavid van Moolenbroek
767*00b67f09SDavid van Moolenbroek isc_event_free(&curr_event);
768*00b67f09SDavid van Moolenbroek
769*00b67f09SDavid van Moolenbroek return (ISC_TRUE);
770*00b67f09SDavid van Moolenbroek }
771*00b67f09SDavid van Moolenbroek
772*00b67f09SDavid van Moolenbroek 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)773*00b67f09SDavid van Moolenbroek isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
774*00b67f09SDavid van Moolenbroek isc_eventtype_t last, void *tag,
775*00b67f09SDavid van Moolenbroek isc_eventlist_t *events)
776*00b67f09SDavid van Moolenbroek {
777*00b67f09SDavid van Moolenbroek /*
778*00b67f09SDavid van Moolenbroek * Remove events from a task's event queue.
779*00b67f09SDavid van Moolenbroek */
780*00b67f09SDavid van Moolenbroek
781*00b67f09SDavid van Moolenbroek XTRACE("isc_task_unsendrange");
782*00b67f09SDavid van Moolenbroek
783*00b67f09SDavid van Moolenbroek return (dequeue_events((isc__task_t *)task, sender, first,
784*00b67f09SDavid van Moolenbroek last, tag, events, ISC_FALSE));
785*00b67f09SDavid van Moolenbroek }
786*00b67f09SDavid van Moolenbroek
787*00b67f09SDavid van Moolenbroek unsigned int
isc__task_unsend(isc_task_t * task,void * sender,isc_eventtype_t type,void * tag,isc_eventlist_t * events)788*00b67f09SDavid van Moolenbroek isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
789*00b67f09SDavid van Moolenbroek void *tag, isc_eventlist_t *events)
790*00b67f09SDavid van Moolenbroek {
791*00b67f09SDavid van Moolenbroek /*
792*00b67f09SDavid van Moolenbroek * Remove events from a task's event queue.
793*00b67f09SDavid van Moolenbroek */
794*00b67f09SDavid van Moolenbroek
795*00b67f09SDavid van Moolenbroek XTRACE("isc_task_unsend");
796*00b67f09SDavid van Moolenbroek
797*00b67f09SDavid van Moolenbroek return (dequeue_events((isc__task_t *)task, sender, type,
798*00b67f09SDavid van Moolenbroek type, tag, events, ISC_FALSE));
799*00b67f09SDavid van Moolenbroek }
800*00b67f09SDavid van Moolenbroek
801*00b67f09SDavid van Moolenbroek isc_result_t
isc__task_onshutdown(isc_task_t * task0,isc_taskaction_t action,void * arg)802*00b67f09SDavid van Moolenbroek isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
803*00b67f09SDavid van Moolenbroek void *arg)
804*00b67f09SDavid van Moolenbroek {
805*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
806*00b67f09SDavid van Moolenbroek isc_boolean_t disallowed = ISC_FALSE;
807*00b67f09SDavid van Moolenbroek isc_result_t result = ISC_R_SUCCESS;
808*00b67f09SDavid van Moolenbroek isc_event_t *event;
809*00b67f09SDavid van Moolenbroek
810*00b67f09SDavid van Moolenbroek /*
811*00b67f09SDavid van Moolenbroek * Send a shutdown event with action 'action' and argument 'arg' when
812*00b67f09SDavid van Moolenbroek * 'task' is shutdown.
813*00b67f09SDavid van Moolenbroek */
814*00b67f09SDavid van Moolenbroek
815*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
816*00b67f09SDavid van Moolenbroek REQUIRE(action != NULL);
817*00b67f09SDavid van Moolenbroek
818*00b67f09SDavid van Moolenbroek event = isc_event_allocate(task->manager->mctx,
819*00b67f09SDavid van Moolenbroek NULL,
820*00b67f09SDavid van Moolenbroek ISC_TASKEVENT_SHUTDOWN,
821*00b67f09SDavid van Moolenbroek action,
822*00b67f09SDavid van Moolenbroek arg,
823*00b67f09SDavid van Moolenbroek sizeof(*event));
824*00b67f09SDavid van Moolenbroek if (event == NULL)
825*00b67f09SDavid van Moolenbroek return (ISC_R_NOMEMORY);
826*00b67f09SDavid van Moolenbroek
827*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
828*00b67f09SDavid van Moolenbroek if (TASK_SHUTTINGDOWN(task)) {
829*00b67f09SDavid van Moolenbroek disallowed = ISC_TRUE;
830*00b67f09SDavid van Moolenbroek result = ISC_R_SHUTTINGDOWN;
831*00b67f09SDavid van Moolenbroek } else
832*00b67f09SDavid van Moolenbroek ENQUEUE(task->on_shutdown, event, ev_link);
833*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
834*00b67f09SDavid van Moolenbroek
835*00b67f09SDavid van Moolenbroek if (disallowed)
836*00b67f09SDavid van Moolenbroek isc_mem_put(task->manager->mctx, event, sizeof(*event));
837*00b67f09SDavid van Moolenbroek
838*00b67f09SDavid van Moolenbroek return (result);
839*00b67f09SDavid van Moolenbroek }
840*00b67f09SDavid van Moolenbroek
841*00b67f09SDavid van Moolenbroek void
isc__task_shutdown(isc_task_t * task0)842*00b67f09SDavid van Moolenbroek isc__task_shutdown(isc_task_t *task0) {
843*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
844*00b67f09SDavid van Moolenbroek isc_boolean_t was_idle;
845*00b67f09SDavid van Moolenbroek
846*00b67f09SDavid van Moolenbroek /*
847*00b67f09SDavid van Moolenbroek * Shutdown 'task'.
848*00b67f09SDavid van Moolenbroek */
849*00b67f09SDavid van Moolenbroek
850*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
851*00b67f09SDavid van Moolenbroek
852*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
853*00b67f09SDavid van Moolenbroek was_idle = task_shutdown(task);
854*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
855*00b67f09SDavid van Moolenbroek
856*00b67f09SDavid van Moolenbroek if (was_idle)
857*00b67f09SDavid van Moolenbroek task_ready(task);
858*00b67f09SDavid van Moolenbroek }
859*00b67f09SDavid van Moolenbroek
860*00b67f09SDavid van Moolenbroek void
isc__task_destroy(isc_task_t ** taskp)861*00b67f09SDavid van Moolenbroek isc__task_destroy(isc_task_t **taskp) {
862*00b67f09SDavid van Moolenbroek
863*00b67f09SDavid van Moolenbroek /*
864*00b67f09SDavid van Moolenbroek * Destroy '*taskp'.
865*00b67f09SDavid van Moolenbroek */
866*00b67f09SDavid van Moolenbroek
867*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL);
868*00b67f09SDavid van Moolenbroek
869*00b67f09SDavid van Moolenbroek isc_task_shutdown(*taskp);
870*00b67f09SDavid van Moolenbroek isc_task_detach(taskp);
871*00b67f09SDavid van Moolenbroek }
872*00b67f09SDavid van Moolenbroek
873*00b67f09SDavid van Moolenbroek void
isc__task_setname(isc_task_t * task0,const char * name,void * tag)874*00b67f09SDavid van Moolenbroek isc__task_setname(isc_task_t *task0, const char *name, void *tag) {
875*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
876*00b67f09SDavid van Moolenbroek
877*00b67f09SDavid van Moolenbroek /*
878*00b67f09SDavid van Moolenbroek * Name 'task'.
879*00b67f09SDavid van Moolenbroek */
880*00b67f09SDavid van Moolenbroek
881*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
882*00b67f09SDavid van Moolenbroek
883*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
884*00b67f09SDavid van Moolenbroek memset(task->name, 0, sizeof(task->name));
885*00b67f09SDavid van Moolenbroek strncpy(task->name, name, sizeof(task->name) - 1);
886*00b67f09SDavid van Moolenbroek task->tag = tag;
887*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
888*00b67f09SDavid van Moolenbroek }
889*00b67f09SDavid van Moolenbroek
890*00b67f09SDavid van Moolenbroek const char *
isc__task_getname(isc_task_t * task0)891*00b67f09SDavid van Moolenbroek isc__task_getname(isc_task_t *task0) {
892*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
893*00b67f09SDavid van Moolenbroek
894*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
895*00b67f09SDavid van Moolenbroek
896*00b67f09SDavid van Moolenbroek return (task->name);
897*00b67f09SDavid van Moolenbroek }
898*00b67f09SDavid van Moolenbroek
899*00b67f09SDavid van Moolenbroek void *
isc__task_gettag(isc_task_t * task0)900*00b67f09SDavid van Moolenbroek isc__task_gettag(isc_task_t *task0) {
901*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
902*00b67f09SDavid van Moolenbroek
903*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
904*00b67f09SDavid van Moolenbroek
905*00b67f09SDavid van Moolenbroek return (task->tag);
906*00b67f09SDavid van Moolenbroek }
907*00b67f09SDavid van Moolenbroek
908*00b67f09SDavid van Moolenbroek void
isc__task_getcurrenttime(isc_task_t * task0,isc_stdtime_t * t)909*00b67f09SDavid van Moolenbroek isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
910*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
911*00b67f09SDavid van Moolenbroek
912*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
913*00b67f09SDavid van Moolenbroek REQUIRE(t != NULL);
914*00b67f09SDavid van Moolenbroek
915*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
916*00b67f09SDavid van Moolenbroek *t = task->now;
917*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
918*00b67f09SDavid van Moolenbroek }
919*00b67f09SDavid van Moolenbroek
920*00b67f09SDavid van Moolenbroek /***
921*00b67f09SDavid van Moolenbroek *** Task Manager.
922*00b67f09SDavid van Moolenbroek ***/
923*00b67f09SDavid van Moolenbroek
924*00b67f09SDavid van Moolenbroek /*
925*00b67f09SDavid van Moolenbroek * Return ISC_TRUE if the current ready list for the manager, which is
926*00b67f09SDavid van Moolenbroek * either ready_tasks or the ready_priority_tasks, depending on whether
927*00b67f09SDavid van Moolenbroek * the manager is currently in normal or privileged execution mode.
928*00b67f09SDavid van Moolenbroek *
929*00b67f09SDavid van Moolenbroek * Caller must hold the task manager lock.
930*00b67f09SDavid van Moolenbroek */
931*00b67f09SDavid van Moolenbroek static inline isc_boolean_t
empty_readyq(isc__taskmgr_t * manager)932*00b67f09SDavid van Moolenbroek empty_readyq(isc__taskmgr_t *manager) {
933*00b67f09SDavid van Moolenbroek isc__tasklist_t queue;
934*00b67f09SDavid van Moolenbroek
935*00b67f09SDavid van Moolenbroek if (manager->mode == isc_taskmgrmode_normal)
936*00b67f09SDavid van Moolenbroek queue = manager->ready_tasks;
937*00b67f09SDavid van Moolenbroek else
938*00b67f09SDavid van Moolenbroek queue = manager->ready_priority_tasks;
939*00b67f09SDavid van Moolenbroek
940*00b67f09SDavid van Moolenbroek return (ISC_TF(EMPTY(queue)));
941*00b67f09SDavid van Moolenbroek }
942*00b67f09SDavid van Moolenbroek
943*00b67f09SDavid van Moolenbroek /*
944*00b67f09SDavid van Moolenbroek * Dequeue and return a pointer to the first task on the current ready
945*00b67f09SDavid van Moolenbroek * list for the manager.
946*00b67f09SDavid van Moolenbroek * If the task is privileged, dequeue it from the other ready list
947*00b67f09SDavid van Moolenbroek * as well.
948*00b67f09SDavid van Moolenbroek *
949*00b67f09SDavid van Moolenbroek * Caller must hold the task manager lock.
950*00b67f09SDavid van Moolenbroek */
951*00b67f09SDavid van Moolenbroek static inline isc__task_t *
pop_readyq(isc__taskmgr_t * manager)952*00b67f09SDavid van Moolenbroek pop_readyq(isc__taskmgr_t *manager) {
953*00b67f09SDavid van Moolenbroek isc__task_t *task;
954*00b67f09SDavid van Moolenbroek
955*00b67f09SDavid van Moolenbroek if (manager->mode == isc_taskmgrmode_normal)
956*00b67f09SDavid van Moolenbroek task = HEAD(manager->ready_tasks);
957*00b67f09SDavid van Moolenbroek else
958*00b67f09SDavid van Moolenbroek task = HEAD(manager->ready_priority_tasks);
959*00b67f09SDavid van Moolenbroek
960*00b67f09SDavid van Moolenbroek if (task != NULL) {
961*00b67f09SDavid van Moolenbroek DEQUEUE(manager->ready_tasks, task, ready_link);
962*00b67f09SDavid van Moolenbroek if (ISC_LINK_LINKED(task, ready_priority_link))
963*00b67f09SDavid van Moolenbroek DEQUEUE(manager->ready_priority_tasks, task,
964*00b67f09SDavid van Moolenbroek ready_priority_link);
965*00b67f09SDavid van Moolenbroek }
966*00b67f09SDavid van Moolenbroek
967*00b67f09SDavid van Moolenbroek return (task);
968*00b67f09SDavid van Moolenbroek }
969*00b67f09SDavid van Moolenbroek
970*00b67f09SDavid van Moolenbroek /*
971*00b67f09SDavid van Moolenbroek * Push 'task' onto the ready_tasks queue. If 'task' has the privilege
972*00b67f09SDavid van Moolenbroek * flag set, then also push it onto the ready_priority_tasks queue.
973*00b67f09SDavid van Moolenbroek *
974*00b67f09SDavid van Moolenbroek * Caller must hold the task manager lock.
975*00b67f09SDavid van Moolenbroek */
976*00b67f09SDavid van Moolenbroek static inline void
push_readyq(isc__taskmgr_t * manager,isc__task_t * task)977*00b67f09SDavid van Moolenbroek push_readyq(isc__taskmgr_t *manager, isc__task_t *task) {
978*00b67f09SDavid van Moolenbroek ENQUEUE(manager->ready_tasks, task, ready_link);
979*00b67f09SDavid van Moolenbroek if ((task->flags & TASK_F_PRIVILEGED) != 0)
980*00b67f09SDavid van Moolenbroek ENQUEUE(manager->ready_priority_tasks, task,
981*00b67f09SDavid van Moolenbroek ready_priority_link);
982*00b67f09SDavid van Moolenbroek manager->tasks_ready++;
983*00b67f09SDavid van Moolenbroek }
984*00b67f09SDavid van Moolenbroek
985*00b67f09SDavid van Moolenbroek static void
dispatch(isc__taskmgr_t * manager)986*00b67f09SDavid van Moolenbroek dispatch(isc__taskmgr_t *manager) {
987*00b67f09SDavid van Moolenbroek isc__task_t *task;
988*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
989*00b67f09SDavid van Moolenbroek unsigned int total_dispatch_count = 0;
990*00b67f09SDavid van Moolenbroek isc__tasklist_t new_ready_tasks;
991*00b67f09SDavid van Moolenbroek isc__tasklist_t new_priority_tasks;
992*00b67f09SDavid van Moolenbroek unsigned int tasks_ready = 0;
993*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
994*00b67f09SDavid van Moolenbroek
995*00b67f09SDavid van Moolenbroek REQUIRE(VALID_MANAGER(manager));
996*00b67f09SDavid van Moolenbroek
997*00b67f09SDavid van Moolenbroek /*
998*00b67f09SDavid van Moolenbroek * Again we're trying to hold the lock for as short a time as possible
999*00b67f09SDavid van Moolenbroek * and to do as little locking and unlocking as possible.
1000*00b67f09SDavid van Moolenbroek *
1001*00b67f09SDavid van Moolenbroek * In both while loops, the appropriate lock must be held before the
1002*00b67f09SDavid van Moolenbroek * while body starts. Code which acquired the lock at the top of
1003*00b67f09SDavid van Moolenbroek * the loop would be more readable, but would result in a lot of
1004*00b67f09SDavid van Moolenbroek * extra locking. Compare:
1005*00b67f09SDavid van Moolenbroek *
1006*00b67f09SDavid van Moolenbroek * Straightforward:
1007*00b67f09SDavid van Moolenbroek *
1008*00b67f09SDavid van Moolenbroek * LOCK();
1009*00b67f09SDavid van Moolenbroek * ...
1010*00b67f09SDavid van Moolenbroek * UNLOCK();
1011*00b67f09SDavid van Moolenbroek * while (expression) {
1012*00b67f09SDavid van Moolenbroek * LOCK();
1013*00b67f09SDavid van Moolenbroek * ...
1014*00b67f09SDavid van Moolenbroek * UNLOCK();
1015*00b67f09SDavid van Moolenbroek *
1016*00b67f09SDavid van Moolenbroek * Unlocked part here...
1017*00b67f09SDavid van Moolenbroek *
1018*00b67f09SDavid van Moolenbroek * LOCK();
1019*00b67f09SDavid van Moolenbroek * ...
1020*00b67f09SDavid van Moolenbroek * UNLOCK();
1021*00b67f09SDavid van Moolenbroek * }
1022*00b67f09SDavid van Moolenbroek *
1023*00b67f09SDavid van Moolenbroek * Note how if the loop continues we unlock and then immediately lock.
1024*00b67f09SDavid van Moolenbroek * For N iterations of the loop, this code does 2N+1 locks and 2N+1
1025*00b67f09SDavid van Moolenbroek * unlocks. Also note that the lock is not held when the while
1026*00b67f09SDavid van Moolenbroek * condition is tested, which may or may not be important, depending
1027*00b67f09SDavid van Moolenbroek * on the expression.
1028*00b67f09SDavid van Moolenbroek *
1029*00b67f09SDavid van Moolenbroek * As written:
1030*00b67f09SDavid van Moolenbroek *
1031*00b67f09SDavid van Moolenbroek * LOCK();
1032*00b67f09SDavid van Moolenbroek * while (expression) {
1033*00b67f09SDavid van Moolenbroek * ...
1034*00b67f09SDavid van Moolenbroek * UNLOCK();
1035*00b67f09SDavid van Moolenbroek *
1036*00b67f09SDavid van Moolenbroek * Unlocked part here...
1037*00b67f09SDavid van Moolenbroek *
1038*00b67f09SDavid van Moolenbroek * LOCK();
1039*00b67f09SDavid van Moolenbroek * ...
1040*00b67f09SDavid van Moolenbroek * }
1041*00b67f09SDavid van Moolenbroek * UNLOCK();
1042*00b67f09SDavid van Moolenbroek *
1043*00b67f09SDavid van Moolenbroek * For N iterations of the loop, this code does N+1 locks and N+1
1044*00b67f09SDavid van Moolenbroek * unlocks. The while expression is always protected by the lock.
1045*00b67f09SDavid van Moolenbroek */
1046*00b67f09SDavid van Moolenbroek
1047*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
1048*00b67f09SDavid van Moolenbroek ISC_LIST_INIT(new_ready_tasks);
1049*00b67f09SDavid van Moolenbroek ISC_LIST_INIT(new_priority_tasks);
1050*00b67f09SDavid van Moolenbroek #endif
1051*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1052*00b67f09SDavid van Moolenbroek
1053*00b67f09SDavid van Moolenbroek while (!FINISHED(manager)) {
1054*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1055*00b67f09SDavid van Moolenbroek /*
1056*00b67f09SDavid van Moolenbroek * For reasons similar to those given in the comment in
1057*00b67f09SDavid van Moolenbroek * isc_task_send() above, it is safe for us to dequeue
1058*00b67f09SDavid van Moolenbroek * the task while only holding the manager lock, and then
1059*00b67f09SDavid van Moolenbroek * change the task to running state while only holding the
1060*00b67f09SDavid van Moolenbroek * task lock.
1061*00b67f09SDavid van Moolenbroek *
1062*00b67f09SDavid van Moolenbroek * If a pause has been requested, don't do any work
1063*00b67f09SDavid van Moolenbroek * until it's been released.
1064*00b67f09SDavid van Moolenbroek */
1065*00b67f09SDavid van Moolenbroek while ((empty_readyq(manager) || manager->pause_requested ||
1066*00b67f09SDavid van Moolenbroek manager->exclusive_requested) && !FINISHED(manager))
1067*00b67f09SDavid van Moolenbroek {
1068*00b67f09SDavid van Moolenbroek XTHREADTRACE(isc_msgcat_get(isc_msgcat,
1069*00b67f09SDavid van Moolenbroek ISC_MSGSET_GENERAL,
1070*00b67f09SDavid van Moolenbroek ISC_MSG_WAIT, "wait"));
1071*00b67f09SDavid van Moolenbroek WAIT(&manager->work_available, &manager->lock);
1072*00b67f09SDavid van Moolenbroek XTHREADTRACE(isc_msgcat_get(isc_msgcat,
1073*00b67f09SDavid van Moolenbroek ISC_MSGSET_TASK,
1074*00b67f09SDavid van Moolenbroek ISC_MSG_AWAKE, "awake"));
1075*00b67f09SDavid van Moolenbroek }
1076*00b67f09SDavid van Moolenbroek #else /* USE_WORKER_THREADS */
1077*00b67f09SDavid van Moolenbroek if (total_dispatch_count >= DEFAULT_TASKMGR_QUANTUM ||
1078*00b67f09SDavid van Moolenbroek empty_readyq(manager))
1079*00b67f09SDavid van Moolenbroek break;
1080*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1081*00b67f09SDavid van Moolenbroek XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TASK,
1082*00b67f09SDavid van Moolenbroek ISC_MSG_WORKING, "working"));
1083*00b67f09SDavid van Moolenbroek
1084*00b67f09SDavid van Moolenbroek task = pop_readyq(manager);
1085*00b67f09SDavid van Moolenbroek if (task != NULL) {
1086*00b67f09SDavid van Moolenbroek unsigned int dispatch_count = 0;
1087*00b67f09SDavid van Moolenbroek isc_boolean_t done = ISC_FALSE;
1088*00b67f09SDavid van Moolenbroek isc_boolean_t requeue = ISC_FALSE;
1089*00b67f09SDavid van Moolenbroek isc_boolean_t finished = ISC_FALSE;
1090*00b67f09SDavid van Moolenbroek isc_event_t *event;
1091*00b67f09SDavid van Moolenbroek
1092*00b67f09SDavid van Moolenbroek INSIST(VALID_TASK(task));
1093*00b67f09SDavid van Moolenbroek
1094*00b67f09SDavid van Moolenbroek /*
1095*00b67f09SDavid van Moolenbroek * Note we only unlock the manager lock if we actually
1096*00b67f09SDavid van Moolenbroek * have a task to do. We must reacquire the manager
1097*00b67f09SDavid van Moolenbroek * lock before exiting the 'if (task != NULL)' block.
1098*00b67f09SDavid van Moolenbroek */
1099*00b67f09SDavid van Moolenbroek manager->tasks_ready--;
1100*00b67f09SDavid van Moolenbroek manager->tasks_running++;
1101*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1102*00b67f09SDavid van Moolenbroek
1103*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1104*00b67f09SDavid van Moolenbroek INSIST(task->state == task_state_ready);
1105*00b67f09SDavid van Moolenbroek task->state = task_state_running;
1106*00b67f09SDavid van Moolenbroek XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1107*00b67f09SDavid van Moolenbroek ISC_MSG_RUNNING, "running"));
1108*00b67f09SDavid van Moolenbroek isc_stdtime_get(&task->now);
1109*00b67f09SDavid van Moolenbroek do {
1110*00b67f09SDavid van Moolenbroek if (!EMPTY(task->events)) {
1111*00b67f09SDavid van Moolenbroek event = HEAD(task->events);
1112*00b67f09SDavid van Moolenbroek DEQUEUE(task->events, event, ev_link);
1113*00b67f09SDavid van Moolenbroek task->nevents--;
1114*00b67f09SDavid van Moolenbroek
1115*00b67f09SDavid van Moolenbroek /*
1116*00b67f09SDavid van Moolenbroek * Execute the event action.
1117*00b67f09SDavid van Moolenbroek */
1118*00b67f09SDavid van Moolenbroek XTRACE(isc_msgcat_get(isc_msgcat,
1119*00b67f09SDavid van Moolenbroek ISC_MSGSET_TASK,
1120*00b67f09SDavid van Moolenbroek ISC_MSG_EXECUTE,
1121*00b67f09SDavid van Moolenbroek "execute action"));
1122*00b67f09SDavid van Moolenbroek if (event->ev_action != NULL) {
1123*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1124*00b67f09SDavid van Moolenbroek (event->ev_action)(
1125*00b67f09SDavid van Moolenbroek (isc_task_t *)task,
1126*00b67f09SDavid van Moolenbroek event);
1127*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1128*00b67f09SDavid van Moolenbroek }
1129*00b67f09SDavid van Moolenbroek dispatch_count++;
1130*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
1131*00b67f09SDavid van Moolenbroek total_dispatch_count++;
1132*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1133*00b67f09SDavid van Moolenbroek }
1134*00b67f09SDavid van Moolenbroek
1135*00b67f09SDavid van Moolenbroek if (task->references == 0 &&
1136*00b67f09SDavid van Moolenbroek EMPTY(task->events) &&
1137*00b67f09SDavid van Moolenbroek !TASK_SHUTTINGDOWN(task)) {
1138*00b67f09SDavid van Moolenbroek isc_boolean_t was_idle;
1139*00b67f09SDavid van Moolenbroek
1140*00b67f09SDavid van Moolenbroek /*
1141*00b67f09SDavid van Moolenbroek * There are no references and no
1142*00b67f09SDavid van Moolenbroek * pending events for this task,
1143*00b67f09SDavid van Moolenbroek * which means it will not become
1144*00b67f09SDavid van Moolenbroek * runnable again via an external
1145*00b67f09SDavid van Moolenbroek * action (such as sending an event
1146*00b67f09SDavid van Moolenbroek * or detaching).
1147*00b67f09SDavid van Moolenbroek *
1148*00b67f09SDavid van Moolenbroek * We initiate shutdown to prevent
1149*00b67f09SDavid van Moolenbroek * it from becoming a zombie.
1150*00b67f09SDavid van Moolenbroek *
1151*00b67f09SDavid van Moolenbroek * We do this here instead of in
1152*00b67f09SDavid van Moolenbroek * the "if EMPTY(task->events)" block
1153*00b67f09SDavid van Moolenbroek * below because:
1154*00b67f09SDavid van Moolenbroek *
1155*00b67f09SDavid van Moolenbroek * If we post no shutdown events,
1156*00b67f09SDavid van Moolenbroek * we want the task to finish.
1157*00b67f09SDavid van Moolenbroek *
1158*00b67f09SDavid van Moolenbroek * If we did post shutdown events,
1159*00b67f09SDavid van Moolenbroek * will still want the task's
1160*00b67f09SDavid van Moolenbroek * quantum to be applied.
1161*00b67f09SDavid van Moolenbroek */
1162*00b67f09SDavid van Moolenbroek was_idle = task_shutdown(task);
1163*00b67f09SDavid van Moolenbroek INSIST(!was_idle);
1164*00b67f09SDavid van Moolenbroek }
1165*00b67f09SDavid van Moolenbroek
1166*00b67f09SDavid van Moolenbroek if (EMPTY(task->events)) {
1167*00b67f09SDavid van Moolenbroek /*
1168*00b67f09SDavid van Moolenbroek * Nothing else to do for this task
1169*00b67f09SDavid van Moolenbroek * right now.
1170*00b67f09SDavid van Moolenbroek */
1171*00b67f09SDavid van Moolenbroek XTRACE(isc_msgcat_get(isc_msgcat,
1172*00b67f09SDavid van Moolenbroek ISC_MSGSET_TASK,
1173*00b67f09SDavid van Moolenbroek ISC_MSG_EMPTY,
1174*00b67f09SDavid van Moolenbroek "empty"));
1175*00b67f09SDavid van Moolenbroek if (task->references == 0 &&
1176*00b67f09SDavid van Moolenbroek TASK_SHUTTINGDOWN(task)) {
1177*00b67f09SDavid van Moolenbroek /*
1178*00b67f09SDavid van Moolenbroek * The task is done.
1179*00b67f09SDavid van Moolenbroek */
1180*00b67f09SDavid van Moolenbroek XTRACE(isc_msgcat_get(
1181*00b67f09SDavid van Moolenbroek isc_msgcat,
1182*00b67f09SDavid van Moolenbroek ISC_MSGSET_TASK,
1183*00b67f09SDavid van Moolenbroek ISC_MSG_DONE,
1184*00b67f09SDavid van Moolenbroek "done"));
1185*00b67f09SDavid van Moolenbroek finished = ISC_TRUE;
1186*00b67f09SDavid van Moolenbroek task->state = task_state_done;
1187*00b67f09SDavid van Moolenbroek } else
1188*00b67f09SDavid van Moolenbroek task->state = task_state_idle;
1189*00b67f09SDavid van Moolenbroek done = ISC_TRUE;
1190*00b67f09SDavid van Moolenbroek } else if (dispatch_count >= task->quantum) {
1191*00b67f09SDavid van Moolenbroek /*
1192*00b67f09SDavid van Moolenbroek * Our quantum has expired, but
1193*00b67f09SDavid van Moolenbroek * there is more work to be done.
1194*00b67f09SDavid van Moolenbroek * We'll requeue it to the ready
1195*00b67f09SDavid van Moolenbroek * queue later.
1196*00b67f09SDavid van Moolenbroek *
1197*00b67f09SDavid van Moolenbroek * We don't check quantum until
1198*00b67f09SDavid van Moolenbroek * dispatching at least one event,
1199*00b67f09SDavid van Moolenbroek * so the minimum quantum is one.
1200*00b67f09SDavid van Moolenbroek */
1201*00b67f09SDavid van Moolenbroek XTRACE(isc_msgcat_get(isc_msgcat,
1202*00b67f09SDavid van Moolenbroek ISC_MSGSET_TASK,
1203*00b67f09SDavid van Moolenbroek ISC_MSG_QUANTUM,
1204*00b67f09SDavid van Moolenbroek "quantum"));
1205*00b67f09SDavid van Moolenbroek task->state = task_state_ready;
1206*00b67f09SDavid van Moolenbroek requeue = ISC_TRUE;
1207*00b67f09SDavid van Moolenbroek done = ISC_TRUE;
1208*00b67f09SDavid van Moolenbroek }
1209*00b67f09SDavid van Moolenbroek } while (!done);
1210*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1211*00b67f09SDavid van Moolenbroek
1212*00b67f09SDavid van Moolenbroek if (finished)
1213*00b67f09SDavid van Moolenbroek task_finished(task);
1214*00b67f09SDavid van Moolenbroek
1215*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1216*00b67f09SDavid van Moolenbroek manager->tasks_running--;
1217*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1218*00b67f09SDavid van Moolenbroek if (manager->exclusive_requested &&
1219*00b67f09SDavid van Moolenbroek manager->tasks_running == 1) {
1220*00b67f09SDavid van Moolenbroek SIGNAL(&manager->exclusive_granted);
1221*00b67f09SDavid van Moolenbroek } else if (manager->pause_requested &&
1222*00b67f09SDavid van Moolenbroek manager->tasks_running == 0) {
1223*00b67f09SDavid van Moolenbroek SIGNAL(&manager->paused);
1224*00b67f09SDavid van Moolenbroek }
1225*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1226*00b67f09SDavid van Moolenbroek if (requeue) {
1227*00b67f09SDavid van Moolenbroek /*
1228*00b67f09SDavid van Moolenbroek * We know we're awake, so we don't have
1229*00b67f09SDavid van Moolenbroek * to wakeup any sleeping threads if the
1230*00b67f09SDavid van Moolenbroek * ready queue is empty before we requeue.
1231*00b67f09SDavid van Moolenbroek *
1232*00b67f09SDavid van Moolenbroek * A possible optimization if the queue is
1233*00b67f09SDavid van Moolenbroek * empty is to 'goto' the 'if (task != NULL)'
1234*00b67f09SDavid van Moolenbroek * block, avoiding the ENQUEUE of the task
1235*00b67f09SDavid van Moolenbroek * and the subsequent immediate DEQUEUE
1236*00b67f09SDavid van Moolenbroek * (since it is the only executable task).
1237*00b67f09SDavid van Moolenbroek * We don't do this because then we'd be
1238*00b67f09SDavid van Moolenbroek * skipping the exit_requested check. The
1239*00b67f09SDavid van Moolenbroek * cost of ENQUEUE is low anyway, especially
1240*00b67f09SDavid van Moolenbroek * when you consider that we'd have to do
1241*00b67f09SDavid van Moolenbroek * an extra EMPTY check to see if we could
1242*00b67f09SDavid van Moolenbroek * do the optimization. If the ready queue
1243*00b67f09SDavid van Moolenbroek * were usually nonempty, the 'optimization'
1244*00b67f09SDavid van Moolenbroek * might even hurt rather than help.
1245*00b67f09SDavid van Moolenbroek */
1246*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1247*00b67f09SDavid van Moolenbroek push_readyq(manager, task);
1248*00b67f09SDavid van Moolenbroek #else
1249*00b67f09SDavid van Moolenbroek ENQUEUE(new_ready_tasks, task, ready_link);
1250*00b67f09SDavid van Moolenbroek if ((task->flags & TASK_F_PRIVILEGED) != 0)
1251*00b67f09SDavid van Moolenbroek ENQUEUE(new_priority_tasks, task,
1252*00b67f09SDavid van Moolenbroek ready_priority_link);
1253*00b67f09SDavid van Moolenbroek tasks_ready++;
1254*00b67f09SDavid van Moolenbroek #endif
1255*00b67f09SDavid van Moolenbroek }
1256*00b67f09SDavid van Moolenbroek }
1257*00b67f09SDavid van Moolenbroek
1258*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1259*00b67f09SDavid van Moolenbroek /*
1260*00b67f09SDavid van Moolenbroek * If we are in privileged execution mode and there are no
1261*00b67f09SDavid van Moolenbroek * tasks remaining on the current ready queue, then
1262*00b67f09SDavid van Moolenbroek * we're stuck. Automatically drop privileges at that
1263*00b67f09SDavid van Moolenbroek * point and continue with the regular ready queue.
1264*00b67f09SDavid van Moolenbroek */
1265*00b67f09SDavid van Moolenbroek if (manager->tasks_running == 0 && empty_readyq(manager)) {
1266*00b67f09SDavid van Moolenbroek manager->mode = isc_taskmgrmode_normal;
1267*00b67f09SDavid van Moolenbroek if (!empty_readyq(manager))
1268*00b67f09SDavid van Moolenbroek BROADCAST(&manager->work_available);
1269*00b67f09SDavid van Moolenbroek }
1270*00b67f09SDavid van Moolenbroek #endif
1271*00b67f09SDavid van Moolenbroek }
1272*00b67f09SDavid van Moolenbroek
1273*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
1274*00b67f09SDavid van Moolenbroek ISC_LIST_APPENDLIST(manager->ready_tasks, new_ready_tasks, ready_link);
1275*00b67f09SDavid van Moolenbroek ISC_LIST_APPENDLIST(manager->ready_priority_tasks, new_priority_tasks,
1276*00b67f09SDavid van Moolenbroek ready_priority_link);
1277*00b67f09SDavid van Moolenbroek manager->tasks_ready += tasks_ready;
1278*00b67f09SDavid van Moolenbroek if (empty_readyq(manager))
1279*00b67f09SDavid van Moolenbroek manager->mode = isc_taskmgrmode_normal;
1280*00b67f09SDavid van Moolenbroek #endif
1281*00b67f09SDavid van Moolenbroek
1282*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1283*00b67f09SDavid van Moolenbroek }
1284*00b67f09SDavid van Moolenbroek
1285*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1286*00b67f09SDavid van Moolenbroek static isc_threadresult_t
1287*00b67f09SDavid van Moolenbroek #ifdef _WIN32
1288*00b67f09SDavid van Moolenbroek WINAPI
1289*00b67f09SDavid van Moolenbroek #endif
run(void * uap)1290*00b67f09SDavid van Moolenbroek run(void *uap) {
1291*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = uap;
1292*00b67f09SDavid van Moolenbroek
1293*00b67f09SDavid van Moolenbroek XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1294*00b67f09SDavid van Moolenbroek ISC_MSG_STARTING, "starting"));
1295*00b67f09SDavid van Moolenbroek
1296*00b67f09SDavid van Moolenbroek dispatch(manager);
1297*00b67f09SDavid van Moolenbroek
1298*00b67f09SDavid van Moolenbroek XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1299*00b67f09SDavid van Moolenbroek ISC_MSG_EXITING, "exiting"));
1300*00b67f09SDavid van Moolenbroek
1301*00b67f09SDavid van Moolenbroek #ifdef OPENSSL_LEAKS
1302*00b67f09SDavid van Moolenbroek ERR_remove_state(0);
1303*00b67f09SDavid van Moolenbroek #endif
1304*00b67f09SDavid van Moolenbroek
1305*00b67f09SDavid van Moolenbroek return ((isc_threadresult_t)0);
1306*00b67f09SDavid van Moolenbroek }
1307*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1308*00b67f09SDavid van Moolenbroek
1309*00b67f09SDavid van Moolenbroek static void
manager_free(isc__taskmgr_t * manager)1310*00b67f09SDavid van Moolenbroek manager_free(isc__taskmgr_t *manager) {
1311*00b67f09SDavid van Moolenbroek isc_mem_t *mctx;
1312*00b67f09SDavid van Moolenbroek
1313*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1314*00b67f09SDavid van Moolenbroek (void)isc_condition_destroy(&manager->exclusive_granted);
1315*00b67f09SDavid van Moolenbroek (void)isc_condition_destroy(&manager->work_available);
1316*00b67f09SDavid van Moolenbroek (void)isc_condition_destroy(&manager->paused);
1317*00b67f09SDavid van Moolenbroek isc_mem_free(manager->mctx, manager->threads);
1318*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1319*00b67f09SDavid van Moolenbroek DESTROYLOCK(&manager->lock);
1320*00b67f09SDavid van Moolenbroek manager->common.impmagic = 0;
1321*00b67f09SDavid van Moolenbroek manager->common.magic = 0;
1322*00b67f09SDavid van Moolenbroek mctx = manager->mctx;
1323*00b67f09SDavid van Moolenbroek isc_mem_put(mctx, manager, sizeof(*manager));
1324*00b67f09SDavid van Moolenbroek isc_mem_detach(&mctx);
1325*00b67f09SDavid van Moolenbroek
1326*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1327*00b67f09SDavid van Moolenbroek taskmgr = NULL;
1328*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
1329*00b67f09SDavid van Moolenbroek }
1330*00b67f09SDavid van Moolenbroek
1331*00b67f09SDavid van Moolenbroek isc_result_t
isc__taskmgr_create(isc_mem_t * mctx,unsigned int workers,unsigned int default_quantum,isc_taskmgr_t ** managerp)1332*00b67f09SDavid van Moolenbroek isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
1333*00b67f09SDavid van Moolenbroek unsigned int default_quantum, isc_taskmgr_t **managerp)
1334*00b67f09SDavid van Moolenbroek {
1335*00b67f09SDavid van Moolenbroek isc_result_t result;
1336*00b67f09SDavid van Moolenbroek unsigned int i, started = 0;
1337*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager;
1338*00b67f09SDavid van Moolenbroek
1339*00b67f09SDavid van Moolenbroek /*
1340*00b67f09SDavid van Moolenbroek * Create a new task manager.
1341*00b67f09SDavid van Moolenbroek */
1342*00b67f09SDavid van Moolenbroek
1343*00b67f09SDavid van Moolenbroek REQUIRE(workers > 0);
1344*00b67f09SDavid van Moolenbroek REQUIRE(managerp != NULL && *managerp == NULL);
1345*00b67f09SDavid van Moolenbroek
1346*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
1347*00b67f09SDavid van Moolenbroek UNUSED(i);
1348*00b67f09SDavid van Moolenbroek UNUSED(started);
1349*00b67f09SDavid van Moolenbroek #endif
1350*00b67f09SDavid van Moolenbroek
1351*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1352*00b67f09SDavid van Moolenbroek if (taskmgr != NULL) {
1353*00b67f09SDavid van Moolenbroek if (taskmgr->refs == 0)
1354*00b67f09SDavid van Moolenbroek return (ISC_R_SHUTTINGDOWN);
1355*00b67f09SDavid van Moolenbroek taskmgr->refs++;
1356*00b67f09SDavid van Moolenbroek *managerp = (isc_taskmgr_t *)taskmgr;
1357*00b67f09SDavid van Moolenbroek return (ISC_R_SUCCESS);
1358*00b67f09SDavid van Moolenbroek }
1359*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
1360*00b67f09SDavid van Moolenbroek
1361*00b67f09SDavid van Moolenbroek manager = isc_mem_get(mctx, sizeof(*manager));
1362*00b67f09SDavid van Moolenbroek if (manager == NULL)
1363*00b67f09SDavid van Moolenbroek return (ISC_R_NOMEMORY);
1364*00b67f09SDavid van Moolenbroek manager->common.methods = &taskmgrmethods;
1365*00b67f09SDavid van Moolenbroek manager->common.impmagic = TASK_MANAGER_MAGIC;
1366*00b67f09SDavid van Moolenbroek manager->common.magic = ISCAPI_TASKMGR_MAGIC;
1367*00b67f09SDavid van Moolenbroek manager->mode = isc_taskmgrmode_normal;
1368*00b67f09SDavid van Moolenbroek manager->mctx = NULL;
1369*00b67f09SDavid van Moolenbroek result = isc_mutex_init(&manager->lock);
1370*00b67f09SDavid van Moolenbroek if (result != ISC_R_SUCCESS)
1371*00b67f09SDavid van Moolenbroek goto cleanup_mgr;
1372*00b67f09SDavid van Moolenbroek
1373*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1374*00b67f09SDavid van Moolenbroek manager->workers = 0;
1375*00b67f09SDavid van Moolenbroek manager->threads = isc_mem_allocate(mctx,
1376*00b67f09SDavid van Moolenbroek workers * sizeof(isc_thread_t));
1377*00b67f09SDavid van Moolenbroek if (manager->threads == NULL) {
1378*00b67f09SDavid van Moolenbroek result = ISC_R_NOMEMORY;
1379*00b67f09SDavid van Moolenbroek goto cleanup_lock;
1380*00b67f09SDavid van Moolenbroek }
1381*00b67f09SDavid van Moolenbroek if (isc_condition_init(&manager->work_available) != ISC_R_SUCCESS) {
1382*00b67f09SDavid van Moolenbroek UNEXPECTED_ERROR(__FILE__, __LINE__,
1383*00b67f09SDavid van Moolenbroek "isc_condition_init() %s",
1384*00b67f09SDavid van Moolenbroek isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1385*00b67f09SDavid van Moolenbroek ISC_MSG_FAILED, "failed"));
1386*00b67f09SDavid van Moolenbroek result = ISC_R_UNEXPECTED;
1387*00b67f09SDavid van Moolenbroek goto cleanup_threads;
1388*00b67f09SDavid van Moolenbroek }
1389*00b67f09SDavid van Moolenbroek if (isc_condition_init(&manager->exclusive_granted) != ISC_R_SUCCESS) {
1390*00b67f09SDavid van Moolenbroek UNEXPECTED_ERROR(__FILE__, __LINE__,
1391*00b67f09SDavid van Moolenbroek "isc_condition_init() %s",
1392*00b67f09SDavid van Moolenbroek isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1393*00b67f09SDavid van Moolenbroek ISC_MSG_FAILED, "failed"));
1394*00b67f09SDavid van Moolenbroek result = ISC_R_UNEXPECTED;
1395*00b67f09SDavid van Moolenbroek goto cleanup_workavailable;
1396*00b67f09SDavid van Moolenbroek }
1397*00b67f09SDavid van Moolenbroek if (isc_condition_init(&manager->paused) != ISC_R_SUCCESS) {
1398*00b67f09SDavid van Moolenbroek UNEXPECTED_ERROR(__FILE__, __LINE__,
1399*00b67f09SDavid van Moolenbroek "isc_condition_init() %s",
1400*00b67f09SDavid van Moolenbroek isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1401*00b67f09SDavid van Moolenbroek ISC_MSG_FAILED, "failed"));
1402*00b67f09SDavid van Moolenbroek result = ISC_R_UNEXPECTED;
1403*00b67f09SDavid van Moolenbroek goto cleanup_exclusivegranted;
1404*00b67f09SDavid van Moolenbroek }
1405*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1406*00b67f09SDavid van Moolenbroek if (default_quantum == 0)
1407*00b67f09SDavid van Moolenbroek default_quantum = DEFAULT_DEFAULT_QUANTUM;
1408*00b67f09SDavid van Moolenbroek manager->default_quantum = default_quantum;
1409*00b67f09SDavid van Moolenbroek INIT_LIST(manager->tasks);
1410*00b67f09SDavid van Moolenbroek INIT_LIST(manager->ready_tasks);
1411*00b67f09SDavid van Moolenbroek INIT_LIST(manager->ready_priority_tasks);
1412*00b67f09SDavid van Moolenbroek manager->tasks_running = 0;
1413*00b67f09SDavid van Moolenbroek manager->tasks_ready = 0;
1414*00b67f09SDavid van Moolenbroek manager->exclusive_requested = ISC_FALSE;
1415*00b67f09SDavid van Moolenbroek manager->pause_requested = ISC_FALSE;
1416*00b67f09SDavid van Moolenbroek manager->exiting = ISC_FALSE;
1417*00b67f09SDavid van Moolenbroek manager->excl = NULL;
1418*00b67f09SDavid van Moolenbroek
1419*00b67f09SDavid van Moolenbroek isc_mem_attach(mctx, &manager->mctx);
1420*00b67f09SDavid van Moolenbroek
1421*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1422*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1423*00b67f09SDavid van Moolenbroek /*
1424*00b67f09SDavid van Moolenbroek * Start workers.
1425*00b67f09SDavid van Moolenbroek */
1426*00b67f09SDavid van Moolenbroek for (i = 0; i < workers; i++) {
1427*00b67f09SDavid van Moolenbroek if (isc_thread_create(run, manager,
1428*00b67f09SDavid van Moolenbroek &manager->threads[manager->workers]) ==
1429*00b67f09SDavid van Moolenbroek ISC_R_SUCCESS) {
1430*00b67f09SDavid van Moolenbroek manager->workers++;
1431*00b67f09SDavid van Moolenbroek started++;
1432*00b67f09SDavid van Moolenbroek }
1433*00b67f09SDavid van Moolenbroek }
1434*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1435*00b67f09SDavid van Moolenbroek
1436*00b67f09SDavid van Moolenbroek if (started == 0) {
1437*00b67f09SDavid van Moolenbroek manager_free(manager);
1438*00b67f09SDavid van Moolenbroek return (ISC_R_NOTHREADS);
1439*00b67f09SDavid van Moolenbroek }
1440*00b67f09SDavid van Moolenbroek isc_thread_setconcurrency(workers);
1441*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1442*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1443*00b67f09SDavid van Moolenbroek manager->refs = 1;
1444*00b67f09SDavid van Moolenbroek taskmgr = manager;
1445*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
1446*00b67f09SDavid van Moolenbroek
1447*00b67f09SDavid van Moolenbroek *managerp = (isc_taskmgr_t *)manager;
1448*00b67f09SDavid van Moolenbroek
1449*00b67f09SDavid van Moolenbroek return (ISC_R_SUCCESS);
1450*00b67f09SDavid van Moolenbroek
1451*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1452*00b67f09SDavid van Moolenbroek cleanup_exclusivegranted:
1453*00b67f09SDavid van Moolenbroek (void)isc_condition_destroy(&manager->exclusive_granted);
1454*00b67f09SDavid van Moolenbroek cleanup_workavailable:
1455*00b67f09SDavid van Moolenbroek (void)isc_condition_destroy(&manager->work_available);
1456*00b67f09SDavid van Moolenbroek cleanup_threads:
1457*00b67f09SDavid van Moolenbroek isc_mem_free(mctx, manager->threads);
1458*00b67f09SDavid van Moolenbroek cleanup_lock:
1459*00b67f09SDavid van Moolenbroek DESTROYLOCK(&manager->lock);
1460*00b67f09SDavid van Moolenbroek #endif
1461*00b67f09SDavid van Moolenbroek cleanup_mgr:
1462*00b67f09SDavid van Moolenbroek isc_mem_put(mctx, manager, sizeof(*manager));
1463*00b67f09SDavid van Moolenbroek return (result);
1464*00b67f09SDavid van Moolenbroek }
1465*00b67f09SDavid van Moolenbroek
1466*00b67f09SDavid van Moolenbroek void
isc__taskmgr_destroy(isc_taskmgr_t ** managerp)1467*00b67f09SDavid van Moolenbroek isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
1468*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager;
1469*00b67f09SDavid van Moolenbroek isc__task_t *task;
1470*00b67f09SDavid van Moolenbroek unsigned int i;
1471*00b67f09SDavid van Moolenbroek
1472*00b67f09SDavid van Moolenbroek /*
1473*00b67f09SDavid van Moolenbroek * Destroy '*managerp'.
1474*00b67f09SDavid van Moolenbroek */
1475*00b67f09SDavid van Moolenbroek
1476*00b67f09SDavid van Moolenbroek REQUIRE(managerp != NULL);
1477*00b67f09SDavid van Moolenbroek manager = (isc__taskmgr_t *)*managerp;
1478*00b67f09SDavid van Moolenbroek REQUIRE(VALID_MANAGER(manager));
1479*00b67f09SDavid van Moolenbroek
1480*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
1481*00b67f09SDavid van Moolenbroek UNUSED(i);
1482*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1483*00b67f09SDavid van Moolenbroek
1484*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1485*00b67f09SDavid van Moolenbroek manager->refs--;
1486*00b67f09SDavid van Moolenbroek if (manager->refs > 0) {
1487*00b67f09SDavid van Moolenbroek *managerp = NULL;
1488*00b67f09SDavid van Moolenbroek return;
1489*00b67f09SDavid van Moolenbroek }
1490*00b67f09SDavid van Moolenbroek #endif
1491*00b67f09SDavid van Moolenbroek
1492*00b67f09SDavid van Moolenbroek XTHREADTRACE("isc_taskmgr_destroy");
1493*00b67f09SDavid van Moolenbroek /*
1494*00b67f09SDavid van Moolenbroek * Only one non-worker thread may ever call this routine.
1495*00b67f09SDavid van Moolenbroek * If a worker thread wants to initiate shutdown of the
1496*00b67f09SDavid van Moolenbroek * task manager, it should ask some non-worker thread to call
1497*00b67f09SDavid van Moolenbroek * isc_taskmgr_destroy(), e.g. by signalling a condition variable
1498*00b67f09SDavid van Moolenbroek * that the startup thread is sleeping on.
1499*00b67f09SDavid van Moolenbroek */
1500*00b67f09SDavid van Moolenbroek
1501*00b67f09SDavid van Moolenbroek /*
1502*00b67f09SDavid van Moolenbroek * Detach the exclusive task before acquiring the manager lock
1503*00b67f09SDavid van Moolenbroek */
1504*00b67f09SDavid van Moolenbroek if (manager->excl != NULL)
1505*00b67f09SDavid van Moolenbroek isc__task_detach((isc_task_t **) &manager->excl);
1506*00b67f09SDavid van Moolenbroek
1507*00b67f09SDavid van Moolenbroek /*
1508*00b67f09SDavid van Moolenbroek * Unlike elsewhere, we're going to hold this lock a long time.
1509*00b67f09SDavid van Moolenbroek * We need to do so, because otherwise the list of tasks could
1510*00b67f09SDavid van Moolenbroek * change while we were traversing it.
1511*00b67f09SDavid van Moolenbroek *
1512*00b67f09SDavid van Moolenbroek * This is also the only function where we will hold both the
1513*00b67f09SDavid van Moolenbroek * task manager lock and a task lock at the same time.
1514*00b67f09SDavid van Moolenbroek */
1515*00b67f09SDavid van Moolenbroek
1516*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1517*00b67f09SDavid van Moolenbroek
1518*00b67f09SDavid van Moolenbroek /*
1519*00b67f09SDavid van Moolenbroek * Make sure we only get called once.
1520*00b67f09SDavid van Moolenbroek */
1521*00b67f09SDavid van Moolenbroek INSIST(!manager->exiting);
1522*00b67f09SDavid van Moolenbroek manager->exiting = ISC_TRUE;
1523*00b67f09SDavid van Moolenbroek
1524*00b67f09SDavid van Moolenbroek /*
1525*00b67f09SDavid van Moolenbroek * If privileged mode was on, turn it off.
1526*00b67f09SDavid van Moolenbroek */
1527*00b67f09SDavid van Moolenbroek manager->mode = isc_taskmgrmode_normal;
1528*00b67f09SDavid van Moolenbroek
1529*00b67f09SDavid van Moolenbroek /*
1530*00b67f09SDavid van Moolenbroek * Post shutdown event(s) to every task (if they haven't already been
1531*00b67f09SDavid van Moolenbroek * posted).
1532*00b67f09SDavid van Moolenbroek */
1533*00b67f09SDavid van Moolenbroek for (task = HEAD(manager->tasks);
1534*00b67f09SDavid van Moolenbroek task != NULL;
1535*00b67f09SDavid van Moolenbroek task = NEXT(task, link)) {
1536*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1537*00b67f09SDavid van Moolenbroek if (task_shutdown(task))
1538*00b67f09SDavid van Moolenbroek push_readyq(manager, task);
1539*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1540*00b67f09SDavid van Moolenbroek }
1541*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1542*00b67f09SDavid van Moolenbroek /*
1543*00b67f09SDavid van Moolenbroek * Wake up any sleeping workers. This ensures we get work done if
1544*00b67f09SDavid van Moolenbroek * there's work left to do, and if there are already no tasks left
1545*00b67f09SDavid van Moolenbroek * it will cause the workers to see manager->exiting.
1546*00b67f09SDavid van Moolenbroek */
1547*00b67f09SDavid van Moolenbroek BROADCAST(&manager->work_available);
1548*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1549*00b67f09SDavid van Moolenbroek
1550*00b67f09SDavid van Moolenbroek /*
1551*00b67f09SDavid van Moolenbroek * Wait for all the worker threads to exit.
1552*00b67f09SDavid van Moolenbroek */
1553*00b67f09SDavid van Moolenbroek for (i = 0; i < manager->workers; i++)
1554*00b67f09SDavid van Moolenbroek (void)isc_thread_join(manager->threads[i], NULL);
1555*00b67f09SDavid van Moolenbroek #else /* USE_WORKER_THREADS */
1556*00b67f09SDavid van Moolenbroek /*
1557*00b67f09SDavid van Moolenbroek * Dispatch the shutdown events.
1558*00b67f09SDavid van Moolenbroek */
1559*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1560*00b67f09SDavid van Moolenbroek while (isc__taskmgr_ready((isc_taskmgr_t *)manager))
1561*00b67f09SDavid van Moolenbroek (void)isc__taskmgr_dispatch((isc_taskmgr_t *)manager);
1562*00b67f09SDavid van Moolenbroek if (!ISC_LIST_EMPTY(manager->tasks))
1563*00b67f09SDavid van Moolenbroek isc_mem_printallactive(stderr);
1564*00b67f09SDavid van Moolenbroek INSIST(ISC_LIST_EMPTY(manager->tasks));
1565*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1566*00b67f09SDavid van Moolenbroek taskmgr = NULL;
1567*00b67f09SDavid van Moolenbroek #endif
1568*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1569*00b67f09SDavid van Moolenbroek
1570*00b67f09SDavid van Moolenbroek manager_free(manager);
1571*00b67f09SDavid van Moolenbroek
1572*00b67f09SDavid van Moolenbroek *managerp = NULL;
1573*00b67f09SDavid van Moolenbroek }
1574*00b67f09SDavid van Moolenbroek
1575*00b67f09SDavid van Moolenbroek void
isc__taskmgr_setmode(isc_taskmgr_t * manager0,isc_taskmgrmode_t mode)1576*00b67f09SDavid van Moolenbroek isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
1577*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
1578*00b67f09SDavid van Moolenbroek
1579*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1580*00b67f09SDavid van Moolenbroek manager->mode = mode;
1581*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1582*00b67f09SDavid van Moolenbroek }
1583*00b67f09SDavid van Moolenbroek
1584*00b67f09SDavid van Moolenbroek isc_taskmgrmode_t
isc__taskmgr_mode(isc_taskmgr_t * manager0)1585*00b67f09SDavid van Moolenbroek isc__taskmgr_mode(isc_taskmgr_t *manager0) {
1586*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
1587*00b67f09SDavid van Moolenbroek isc_taskmgrmode_t mode;
1588*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1589*00b67f09SDavid van Moolenbroek mode = manager->mode;
1590*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1591*00b67f09SDavid van Moolenbroek return (mode);
1592*00b67f09SDavid van Moolenbroek }
1593*00b67f09SDavid van Moolenbroek
1594*00b67f09SDavid van Moolenbroek #ifndef USE_WORKER_THREADS
1595*00b67f09SDavid van Moolenbroek isc_boolean_t
isc__taskmgr_ready(isc_taskmgr_t * manager0)1596*00b67f09SDavid van Moolenbroek isc__taskmgr_ready(isc_taskmgr_t *manager0) {
1597*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
1598*00b67f09SDavid van Moolenbroek isc_boolean_t is_ready;
1599*00b67f09SDavid van Moolenbroek
1600*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1601*00b67f09SDavid van Moolenbroek if (manager == NULL)
1602*00b67f09SDavid van Moolenbroek manager = taskmgr;
1603*00b67f09SDavid van Moolenbroek #endif
1604*00b67f09SDavid van Moolenbroek if (manager == NULL)
1605*00b67f09SDavid van Moolenbroek return (ISC_FALSE);
1606*00b67f09SDavid van Moolenbroek
1607*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1608*00b67f09SDavid van Moolenbroek is_ready = !empty_readyq(manager);
1609*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1610*00b67f09SDavid van Moolenbroek
1611*00b67f09SDavid van Moolenbroek return (is_ready);
1612*00b67f09SDavid van Moolenbroek }
1613*00b67f09SDavid van Moolenbroek
1614*00b67f09SDavid van Moolenbroek isc_result_t
isc__taskmgr_dispatch(isc_taskmgr_t * manager0)1615*00b67f09SDavid van Moolenbroek isc__taskmgr_dispatch(isc_taskmgr_t *manager0) {
1616*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
1617*00b67f09SDavid van Moolenbroek
1618*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1619*00b67f09SDavid van Moolenbroek if (manager == NULL)
1620*00b67f09SDavid van Moolenbroek manager = taskmgr;
1621*00b67f09SDavid van Moolenbroek #endif
1622*00b67f09SDavid van Moolenbroek if (manager == NULL)
1623*00b67f09SDavid van Moolenbroek return (ISC_R_NOTFOUND);
1624*00b67f09SDavid van Moolenbroek
1625*00b67f09SDavid van Moolenbroek dispatch(manager);
1626*00b67f09SDavid van Moolenbroek
1627*00b67f09SDavid van Moolenbroek return (ISC_R_SUCCESS);
1628*00b67f09SDavid van Moolenbroek }
1629*00b67f09SDavid van Moolenbroek
1630*00b67f09SDavid van Moolenbroek #else
1631*00b67f09SDavid van Moolenbroek void
isc__taskmgr_pause(isc_taskmgr_t * manager0)1632*00b67f09SDavid van Moolenbroek isc__taskmgr_pause(isc_taskmgr_t *manager0) {
1633*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
1634*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1635*00b67f09SDavid van Moolenbroek while (manager->tasks_running > 0) {
1636*00b67f09SDavid van Moolenbroek WAIT(&manager->paused, &manager->lock);
1637*00b67f09SDavid van Moolenbroek }
1638*00b67f09SDavid van Moolenbroek manager->pause_requested = ISC_TRUE;
1639*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1640*00b67f09SDavid van Moolenbroek }
1641*00b67f09SDavid van Moolenbroek
1642*00b67f09SDavid van Moolenbroek void
isc__taskmgr_resume(isc_taskmgr_t * manager0)1643*00b67f09SDavid van Moolenbroek isc__taskmgr_resume(isc_taskmgr_t *manager0) {
1644*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
1645*00b67f09SDavid van Moolenbroek
1646*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1647*00b67f09SDavid van Moolenbroek if (manager->pause_requested) {
1648*00b67f09SDavid van Moolenbroek manager->pause_requested = ISC_FALSE;
1649*00b67f09SDavid van Moolenbroek BROADCAST(&manager->work_available);
1650*00b67f09SDavid van Moolenbroek }
1651*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1652*00b67f09SDavid van Moolenbroek }
1653*00b67f09SDavid van Moolenbroek #endif /* USE_WORKER_THREADS */
1654*00b67f09SDavid van Moolenbroek
1655*00b67f09SDavid van Moolenbroek void
isc_taskmgr_setexcltask(isc_taskmgr_t * mgr0,isc_task_t * task0)1656*00b67f09SDavid van Moolenbroek isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0) {
1657*00b67f09SDavid van Moolenbroek isc__taskmgr_t *mgr = (isc__taskmgr_t *) mgr0;
1658*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *) task0;
1659*00b67f09SDavid van Moolenbroek
1660*00b67f09SDavid van Moolenbroek REQUIRE(VALID_MANAGER(mgr));
1661*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
1662*00b67f09SDavid van Moolenbroek if (mgr->excl != NULL)
1663*00b67f09SDavid van Moolenbroek isc__task_detach((isc_task_t **) &mgr->excl);
1664*00b67f09SDavid van Moolenbroek isc__task_attach(task0, (isc_task_t **) &mgr->excl);
1665*00b67f09SDavid van Moolenbroek }
1666*00b67f09SDavid van Moolenbroek
1667*00b67f09SDavid van Moolenbroek isc_result_t
isc_taskmgr_excltask(isc_taskmgr_t * mgr0,isc_task_t ** taskp)1668*00b67f09SDavid van Moolenbroek isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
1669*00b67f09SDavid van Moolenbroek isc__taskmgr_t *mgr = (isc__taskmgr_t *) mgr0;
1670*00b67f09SDavid van Moolenbroek
1671*00b67f09SDavid van Moolenbroek REQUIRE(VALID_MANAGER(mgr));
1672*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL && *taskp == NULL);
1673*00b67f09SDavid van Moolenbroek
1674*00b67f09SDavid van Moolenbroek if (mgr->excl == NULL)
1675*00b67f09SDavid van Moolenbroek return (ISC_R_NOTFOUND);
1676*00b67f09SDavid van Moolenbroek
1677*00b67f09SDavid van Moolenbroek isc__task_attach((isc_task_t *) mgr->excl, taskp);
1678*00b67f09SDavid van Moolenbroek return (ISC_R_SUCCESS);
1679*00b67f09SDavid van Moolenbroek }
1680*00b67f09SDavid van Moolenbroek
1681*00b67f09SDavid van Moolenbroek isc_result_t
isc__task_beginexclusive(isc_task_t * task0)1682*00b67f09SDavid van Moolenbroek isc__task_beginexclusive(isc_task_t *task0) {
1683*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1684*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
1685*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = task->manager;
1686*00b67f09SDavid van Moolenbroek
1687*00b67f09SDavid van Moolenbroek REQUIRE(task->state == task_state_running);
1688*00b67f09SDavid van Moolenbroek /* XXX: Require task == manager->excl? */
1689*00b67f09SDavid van Moolenbroek
1690*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1691*00b67f09SDavid van Moolenbroek if (manager->exclusive_requested) {
1692*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1693*00b67f09SDavid van Moolenbroek return (ISC_R_LOCKBUSY);
1694*00b67f09SDavid van Moolenbroek }
1695*00b67f09SDavid van Moolenbroek manager->exclusive_requested = ISC_TRUE;
1696*00b67f09SDavid van Moolenbroek while (manager->tasks_running > 1) {
1697*00b67f09SDavid van Moolenbroek WAIT(&manager->exclusive_granted, &manager->lock);
1698*00b67f09SDavid van Moolenbroek }
1699*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1700*00b67f09SDavid van Moolenbroek #else
1701*00b67f09SDavid van Moolenbroek UNUSED(task0);
1702*00b67f09SDavid van Moolenbroek #endif
1703*00b67f09SDavid van Moolenbroek return (ISC_R_SUCCESS);
1704*00b67f09SDavid van Moolenbroek }
1705*00b67f09SDavid van Moolenbroek
1706*00b67f09SDavid van Moolenbroek void
isc__task_endexclusive(isc_task_t * task0)1707*00b67f09SDavid van Moolenbroek isc__task_endexclusive(isc_task_t *task0) {
1708*00b67f09SDavid van Moolenbroek #ifdef USE_WORKER_THREADS
1709*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
1710*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = task->manager;
1711*00b67f09SDavid van Moolenbroek
1712*00b67f09SDavid van Moolenbroek REQUIRE(task->state == task_state_running);
1713*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1714*00b67f09SDavid van Moolenbroek REQUIRE(manager->exclusive_requested);
1715*00b67f09SDavid van Moolenbroek manager->exclusive_requested = ISC_FALSE;
1716*00b67f09SDavid van Moolenbroek BROADCAST(&manager->work_available);
1717*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1718*00b67f09SDavid van Moolenbroek #else
1719*00b67f09SDavid van Moolenbroek UNUSED(task0);
1720*00b67f09SDavid van Moolenbroek #endif
1721*00b67f09SDavid van Moolenbroek }
1722*00b67f09SDavid van Moolenbroek
1723*00b67f09SDavid van Moolenbroek void
isc__task_setprivilege(isc_task_t * task0,isc_boolean_t priv)1724*00b67f09SDavid van Moolenbroek isc__task_setprivilege(isc_task_t *task0, isc_boolean_t priv) {
1725*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
1726*00b67f09SDavid van Moolenbroek isc__taskmgr_t *manager = task->manager;
1727*00b67f09SDavid van Moolenbroek isc_boolean_t oldpriv;
1728*00b67f09SDavid van Moolenbroek
1729*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1730*00b67f09SDavid van Moolenbroek oldpriv = ISC_TF((task->flags & TASK_F_PRIVILEGED) != 0);
1731*00b67f09SDavid van Moolenbroek if (priv)
1732*00b67f09SDavid van Moolenbroek task->flags |= TASK_F_PRIVILEGED;
1733*00b67f09SDavid van Moolenbroek else
1734*00b67f09SDavid van Moolenbroek task->flags &= ~TASK_F_PRIVILEGED;
1735*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1736*00b67f09SDavid van Moolenbroek
1737*00b67f09SDavid van Moolenbroek if (priv == oldpriv)
1738*00b67f09SDavid van Moolenbroek return;
1739*00b67f09SDavid van Moolenbroek
1740*00b67f09SDavid van Moolenbroek LOCK(&manager->lock);
1741*00b67f09SDavid van Moolenbroek if (priv && ISC_LINK_LINKED(task, ready_link))
1742*00b67f09SDavid van Moolenbroek ENQUEUE(manager->ready_priority_tasks, task,
1743*00b67f09SDavid van Moolenbroek ready_priority_link);
1744*00b67f09SDavid van Moolenbroek else if (!priv && ISC_LINK_LINKED(task, ready_priority_link))
1745*00b67f09SDavid van Moolenbroek DEQUEUE(manager->ready_priority_tasks, task,
1746*00b67f09SDavid van Moolenbroek ready_priority_link);
1747*00b67f09SDavid van Moolenbroek UNLOCK(&manager->lock);
1748*00b67f09SDavid van Moolenbroek }
1749*00b67f09SDavid van Moolenbroek
1750*00b67f09SDavid van Moolenbroek isc_boolean_t
isc__task_privilege(isc_task_t * task0)1751*00b67f09SDavid van Moolenbroek isc__task_privilege(isc_task_t *task0) {
1752*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)task0;
1753*00b67f09SDavid van Moolenbroek isc_boolean_t priv;
1754*00b67f09SDavid van Moolenbroek
1755*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1756*00b67f09SDavid van Moolenbroek priv = ISC_TF((task->flags & TASK_F_PRIVILEGED) != 0);
1757*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1758*00b67f09SDavid van Moolenbroek return (priv);
1759*00b67f09SDavid van Moolenbroek }
1760*00b67f09SDavid van Moolenbroek
1761*00b67f09SDavid van Moolenbroek isc_result_t
isc__task_register(void)1762*00b67f09SDavid van Moolenbroek isc__task_register(void) {
1763*00b67f09SDavid van Moolenbroek return (isc_task_register(isc__taskmgr_create));
1764*00b67f09SDavid van Moolenbroek }
1765*00b67f09SDavid van Moolenbroek
1766*00b67f09SDavid van Moolenbroek isc_boolean_t
isc_task_exiting(isc_task_t * t)1767*00b67f09SDavid van Moolenbroek isc_task_exiting(isc_task_t *t) {
1768*00b67f09SDavid van Moolenbroek isc__task_t *task = (isc__task_t *)t;
1769*00b67f09SDavid van Moolenbroek
1770*00b67f09SDavid van Moolenbroek REQUIRE(VALID_TASK(task));
1771*00b67f09SDavid van Moolenbroek return (TASK_SHUTTINGDOWN(task));
1772*00b67f09SDavid van Moolenbroek }
1773*00b67f09SDavid van Moolenbroek
1774*00b67f09SDavid van Moolenbroek
1775*00b67f09SDavid van Moolenbroek #ifdef HAVE_LIBXML2
1776*00b67f09SDavid van Moolenbroek #define TRY0(a) do { xmlrc = (a); if (xmlrc < 0) goto error; } while(/*CONSTCOND*/0)
1777*00b67f09SDavid van Moolenbroek int
isc_taskmgr_renderxml(isc_taskmgr_t * mgr0,xmlTextWriterPtr writer)1778*00b67f09SDavid van Moolenbroek isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) {
1779*00b67f09SDavid van Moolenbroek isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
1780*00b67f09SDavid van Moolenbroek isc__task_t *task = NULL;
1781*00b67f09SDavid van Moolenbroek int xmlrc;
1782*00b67f09SDavid van Moolenbroek
1783*00b67f09SDavid van Moolenbroek LOCK(&mgr->lock);
1784*00b67f09SDavid van Moolenbroek
1785*00b67f09SDavid van Moolenbroek /*
1786*00b67f09SDavid van Moolenbroek * Write out the thread-model, and some details about each depending
1787*00b67f09SDavid van Moolenbroek * on which type is enabled.
1788*00b67f09SDavid van Moolenbroek */
1789*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "thread-model"));
1790*00b67f09SDavid van Moolenbroek #ifdef ISC_PLATFORM_USETHREADS
1791*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "type"));
1792*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR "threaded"));
1793*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* type */
1794*00b67f09SDavid van Moolenbroek
1795*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "worker-threads"));
1796*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->workers));
1797*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* worker-threads */
1798*00b67f09SDavid van Moolenbroek #else /* ISC_PLATFORM_USETHREADS */
1799*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "type"));
1800*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteString(writer, ISC_XMLCHAR "non-threaded"));
1801*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* type */
1802*00b67f09SDavid van Moolenbroek
1803*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "references"));
1804*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->refs));
1805*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* references */
1806*00b67f09SDavid van Moolenbroek #endif /* ISC_PLATFORM_USETHREADS */
1807*00b67f09SDavid van Moolenbroek
1808*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "default-quantum"));
1809*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d",
1810*00b67f09SDavid van Moolenbroek mgr->default_quantum));
1811*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* default-quantum */
1812*00b67f09SDavid van Moolenbroek
1813*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks-running"));
1814*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->tasks_running));
1815*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* tasks-running */
1816*00b67f09SDavid van Moolenbroek
1817*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks-ready"));
1818*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->tasks_ready));
1819*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* tasks-ready */
1820*00b67f09SDavid van Moolenbroek
1821*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* thread-model */
1822*00b67f09SDavid van Moolenbroek
1823*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks"));
1824*00b67f09SDavid van Moolenbroek task = ISC_LIST_HEAD(mgr->tasks);
1825*00b67f09SDavid van Moolenbroek while (task != NULL) {
1826*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1827*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "task"));
1828*00b67f09SDavid van Moolenbroek
1829*00b67f09SDavid van Moolenbroek if (task->name[0] != 0) {
1830*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer,
1831*00b67f09SDavid van Moolenbroek ISC_XMLCHAR "name"));
1832*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%s",
1833*00b67f09SDavid van Moolenbroek task->name));
1834*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* name */
1835*00b67f09SDavid van Moolenbroek }
1836*00b67f09SDavid van Moolenbroek
1837*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer,
1838*00b67f09SDavid van Moolenbroek ISC_XMLCHAR "references"));
1839*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d",
1840*00b67f09SDavid van Moolenbroek task->references));
1841*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* references */
1842*00b67f09SDavid van Moolenbroek
1843*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "id"));
1844*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%p", task));
1845*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* id */
1846*00b67f09SDavid van Moolenbroek
1847*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "state"));
1848*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%s",
1849*00b67f09SDavid van Moolenbroek statenames[task->state]));
1850*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* state */
1851*00b67f09SDavid van Moolenbroek
1852*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "quantum"));
1853*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d",
1854*00b67f09SDavid van Moolenbroek task->quantum));
1855*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* quantum */
1856*00b67f09SDavid van Moolenbroek
1857*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "events"));
1858*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterWriteFormatString(writer, "%d",
1859*00b67f09SDavid van Moolenbroek task->nevents));
1860*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* events */
1861*00b67f09SDavid van Moolenbroek
1862*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer));
1863*00b67f09SDavid van Moolenbroek
1864*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1865*00b67f09SDavid van Moolenbroek task = ISC_LIST_NEXT(task, link);
1866*00b67f09SDavid van Moolenbroek }
1867*00b67f09SDavid van Moolenbroek TRY0(xmlTextWriterEndElement(writer)); /* tasks */
1868*00b67f09SDavid van Moolenbroek
1869*00b67f09SDavid van Moolenbroek error:
1870*00b67f09SDavid van Moolenbroek if (task != NULL)
1871*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1872*00b67f09SDavid van Moolenbroek UNLOCK(&mgr->lock);
1873*00b67f09SDavid van Moolenbroek
1874*00b67f09SDavid van Moolenbroek return (xmlrc);
1875*00b67f09SDavid van Moolenbroek }
1876*00b67f09SDavid van Moolenbroek #endif /* HAVE_LIBXML2 */
1877*00b67f09SDavid van Moolenbroek
1878*00b67f09SDavid van Moolenbroek #ifdef HAVE_JSON
1879*00b67f09SDavid van Moolenbroek #define CHECKMEM(m) do { \
1880*00b67f09SDavid van Moolenbroek if (m == NULL) { \
1881*00b67f09SDavid van Moolenbroek result = ISC_R_NOMEMORY;\
1882*00b67f09SDavid van Moolenbroek goto error;\
1883*00b67f09SDavid van Moolenbroek } \
1884*00b67f09SDavid van Moolenbroek } while(/*CONSTCOND*/0)
1885*00b67f09SDavid van Moolenbroek
1886*00b67f09SDavid van Moolenbroek isc_result_t
isc_taskmgr_renderjson(isc_taskmgr_t * mgr0,json_object * tasks)1887*00b67f09SDavid van Moolenbroek isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
1888*00b67f09SDavid van Moolenbroek isc_result_t result = ISC_R_SUCCESS;
1889*00b67f09SDavid van Moolenbroek isc__taskmgr_t *mgr = (isc__taskmgr_t *)mgr0;
1890*00b67f09SDavid van Moolenbroek isc__task_t *task = NULL;
1891*00b67f09SDavid van Moolenbroek json_object *obj = NULL, *array = NULL, *taskobj = NULL;
1892*00b67f09SDavid van Moolenbroek
1893*00b67f09SDavid van Moolenbroek LOCK(&mgr->lock);
1894*00b67f09SDavid van Moolenbroek
1895*00b67f09SDavid van Moolenbroek /*
1896*00b67f09SDavid van Moolenbroek * Write out the thread-model, and some details about each depending
1897*00b67f09SDavid van Moolenbroek * on which type is enabled.
1898*00b67f09SDavid van Moolenbroek */
1899*00b67f09SDavid van Moolenbroek #ifdef ISC_PLATFORM_USETHREADS
1900*00b67f09SDavid van Moolenbroek obj = json_object_new_string("threaded");
1901*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1902*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "thread-model", obj);
1903*00b67f09SDavid van Moolenbroek
1904*00b67f09SDavid van Moolenbroek obj = json_object_new_int(mgr->workers);
1905*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1906*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "worker-threads", obj);
1907*00b67f09SDavid van Moolenbroek #else /* ISC_PLATFORM_USETHREADS */
1908*00b67f09SDavid van Moolenbroek obj = json_object_new_string("non-threaded");
1909*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1910*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "thread-model", obj);
1911*00b67f09SDavid van Moolenbroek
1912*00b67f09SDavid van Moolenbroek obj = json_object_new_int(mgr->refs);
1913*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1914*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "references", obj);
1915*00b67f09SDavid van Moolenbroek #endif /* ISC_PLATFORM_USETHREADS */
1916*00b67f09SDavid van Moolenbroek
1917*00b67f09SDavid van Moolenbroek obj = json_object_new_int(mgr->default_quantum);
1918*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1919*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "default-quantum", obj);
1920*00b67f09SDavid van Moolenbroek
1921*00b67f09SDavid van Moolenbroek obj = json_object_new_int(mgr->tasks_running);
1922*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1923*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "tasks-running", obj);
1924*00b67f09SDavid van Moolenbroek
1925*00b67f09SDavid van Moolenbroek obj = json_object_new_int(mgr->tasks_ready);
1926*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1927*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "tasks-ready", obj);
1928*00b67f09SDavid van Moolenbroek
1929*00b67f09SDavid van Moolenbroek array = json_object_new_array();
1930*00b67f09SDavid van Moolenbroek CHECKMEM(array);
1931*00b67f09SDavid van Moolenbroek
1932*00b67f09SDavid van Moolenbroek for (task = ISC_LIST_HEAD(mgr->tasks);
1933*00b67f09SDavid van Moolenbroek task != NULL;
1934*00b67f09SDavid van Moolenbroek task = ISC_LIST_NEXT(task, link))
1935*00b67f09SDavid van Moolenbroek {
1936*00b67f09SDavid van Moolenbroek char buf[255];
1937*00b67f09SDavid van Moolenbroek
1938*00b67f09SDavid van Moolenbroek LOCK(&task->lock);
1939*00b67f09SDavid van Moolenbroek
1940*00b67f09SDavid van Moolenbroek taskobj = json_object_new_object();
1941*00b67f09SDavid van Moolenbroek CHECKMEM(taskobj);
1942*00b67f09SDavid van Moolenbroek json_object_array_add(array, taskobj);
1943*00b67f09SDavid van Moolenbroek
1944*00b67f09SDavid van Moolenbroek sprintf(buf, "%p", task);
1945*00b67f09SDavid van Moolenbroek obj = json_object_new_string(buf);
1946*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1947*00b67f09SDavid van Moolenbroek json_object_object_add(taskobj, "id", obj);
1948*00b67f09SDavid van Moolenbroek
1949*00b67f09SDavid van Moolenbroek if (task->name[0] != 0) {
1950*00b67f09SDavid van Moolenbroek obj = json_object_new_string(task->name);
1951*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1952*00b67f09SDavid van Moolenbroek json_object_object_add(taskobj, "name", obj);
1953*00b67f09SDavid van Moolenbroek }
1954*00b67f09SDavid van Moolenbroek
1955*00b67f09SDavid van Moolenbroek obj = json_object_new_int(task->references);
1956*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1957*00b67f09SDavid van Moolenbroek json_object_object_add(taskobj, "references", obj);
1958*00b67f09SDavid van Moolenbroek
1959*00b67f09SDavid van Moolenbroek obj = json_object_new_string(statenames[task->state]);
1960*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1961*00b67f09SDavid van Moolenbroek json_object_object_add(taskobj, "state", obj);
1962*00b67f09SDavid van Moolenbroek
1963*00b67f09SDavid van Moolenbroek obj = json_object_new_int(task->quantum);
1964*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1965*00b67f09SDavid van Moolenbroek json_object_object_add(taskobj, "quantum", obj);
1966*00b67f09SDavid van Moolenbroek
1967*00b67f09SDavid van Moolenbroek obj = json_object_new_int(task->nevents);
1968*00b67f09SDavid van Moolenbroek CHECKMEM(obj);
1969*00b67f09SDavid van Moolenbroek json_object_object_add(taskobj, "events", obj);
1970*00b67f09SDavid van Moolenbroek
1971*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1972*00b67f09SDavid van Moolenbroek }
1973*00b67f09SDavid van Moolenbroek
1974*00b67f09SDavid van Moolenbroek json_object_object_add(tasks, "tasks", array);
1975*00b67f09SDavid van Moolenbroek array = NULL;
1976*00b67f09SDavid van Moolenbroek result = ISC_R_SUCCESS;
1977*00b67f09SDavid van Moolenbroek
1978*00b67f09SDavid van Moolenbroek error:
1979*00b67f09SDavid van Moolenbroek if (array != NULL)
1980*00b67f09SDavid van Moolenbroek json_object_put(array);
1981*00b67f09SDavid van Moolenbroek
1982*00b67f09SDavid van Moolenbroek if (task != NULL)
1983*00b67f09SDavid van Moolenbroek UNLOCK(&task->lock);
1984*00b67f09SDavid van Moolenbroek UNLOCK(&mgr->lock);
1985*00b67f09SDavid van Moolenbroek
1986*00b67f09SDavid van Moolenbroek return (result);
1987*00b67f09SDavid van Moolenbroek }
1988*00b67f09SDavid van Moolenbroek #endif
1989*00b67f09SDavid van Moolenbroek
1990*00b67f09SDavid van Moolenbroek
1991*00b67f09SDavid van Moolenbroek static isc_mutex_t createlock;
1992*00b67f09SDavid van Moolenbroek static isc_once_t once = ISC_ONCE_INIT;
1993*00b67f09SDavid van Moolenbroek static isc_taskmgrcreatefunc_t taskmgr_createfunc = NULL;
1994*00b67f09SDavid van Moolenbroek
1995*00b67f09SDavid van Moolenbroek static void
initialize(void)1996*00b67f09SDavid van Moolenbroek initialize(void) {
1997*00b67f09SDavid van Moolenbroek RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
1998*00b67f09SDavid van Moolenbroek }
1999*00b67f09SDavid van Moolenbroek
2000*00b67f09SDavid van Moolenbroek isc_result_t
isc_task_register(isc_taskmgrcreatefunc_t createfunc)2001*00b67f09SDavid van Moolenbroek isc_task_register(isc_taskmgrcreatefunc_t createfunc) {
2002*00b67f09SDavid van Moolenbroek isc_result_t result = ISC_R_SUCCESS;
2003*00b67f09SDavid van Moolenbroek
2004*00b67f09SDavid van Moolenbroek RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
2005*00b67f09SDavid van Moolenbroek
2006*00b67f09SDavid van Moolenbroek LOCK(&createlock);
2007*00b67f09SDavid van Moolenbroek if (taskmgr_createfunc == NULL)
2008*00b67f09SDavid van Moolenbroek taskmgr_createfunc = createfunc;
2009*00b67f09SDavid van Moolenbroek else
2010*00b67f09SDavid van Moolenbroek result = ISC_R_EXISTS;
2011*00b67f09SDavid van Moolenbroek UNLOCK(&createlock);
2012*00b67f09SDavid van Moolenbroek
2013*00b67f09SDavid van Moolenbroek return (result);
2014*00b67f09SDavid van Moolenbroek }
2015*00b67f09SDavid van Moolenbroek
2016*00b67f09SDavid van Moolenbroek isc_result_t
isc_taskmgr_createinctx(isc_mem_t * mctx,isc_appctx_t * actx,unsigned int workers,unsigned int default_quantum,isc_taskmgr_t ** managerp)2017*00b67f09SDavid van Moolenbroek isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
2018*00b67f09SDavid van Moolenbroek unsigned int workers, unsigned int default_quantum,
2019*00b67f09SDavid van Moolenbroek isc_taskmgr_t **managerp)
2020*00b67f09SDavid van Moolenbroek {
2021*00b67f09SDavid van Moolenbroek isc_result_t result;
2022*00b67f09SDavid van Moolenbroek
2023*00b67f09SDavid van Moolenbroek LOCK(&createlock);
2024*00b67f09SDavid van Moolenbroek
2025*00b67f09SDavid van Moolenbroek REQUIRE(taskmgr_createfunc != NULL);
2026*00b67f09SDavid van Moolenbroek result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
2027*00b67f09SDavid van Moolenbroek managerp);
2028*00b67f09SDavid van Moolenbroek
2029*00b67f09SDavid van Moolenbroek UNLOCK(&createlock);
2030*00b67f09SDavid van Moolenbroek
2031*00b67f09SDavid van Moolenbroek if (result == ISC_R_SUCCESS)
2032*00b67f09SDavid van Moolenbroek isc_appctx_settaskmgr(actx, *managerp);
2033*00b67f09SDavid van Moolenbroek
2034*00b67f09SDavid van Moolenbroek return (result);
2035*00b67f09SDavid van Moolenbroek }
2036*00b67f09SDavid van Moolenbroek
2037*00b67f09SDavid van Moolenbroek isc_result_t
isc_taskmgr_create(isc_mem_t * mctx,unsigned int workers,unsigned int default_quantum,isc_taskmgr_t ** managerp)2038*00b67f09SDavid van Moolenbroek isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
2039*00b67f09SDavid van Moolenbroek unsigned int default_quantum, isc_taskmgr_t **managerp)
2040*00b67f09SDavid van Moolenbroek {
2041*00b67f09SDavid van Moolenbroek isc_result_t result;
2042*00b67f09SDavid van Moolenbroek
2043*00b67f09SDavid van Moolenbroek if (isc_bind9)
2044*00b67f09SDavid van Moolenbroek return (isc__taskmgr_create(mctx, workers,
2045*00b67f09SDavid van Moolenbroek default_quantum, managerp));
2046*00b67f09SDavid van Moolenbroek LOCK(&createlock);
2047*00b67f09SDavid van Moolenbroek
2048*00b67f09SDavid van Moolenbroek REQUIRE(taskmgr_createfunc != NULL);
2049*00b67f09SDavid van Moolenbroek result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
2050*00b67f09SDavid van Moolenbroek managerp);
2051*00b67f09SDavid van Moolenbroek
2052*00b67f09SDavid van Moolenbroek UNLOCK(&createlock);
2053*00b67f09SDavid van Moolenbroek
2054*00b67f09SDavid van Moolenbroek return (result);
2055*00b67f09SDavid van Moolenbroek }
2056*00b67f09SDavid van Moolenbroek
2057*00b67f09SDavid van Moolenbroek void
isc_taskmgr_destroy(isc_taskmgr_t ** managerp)2058*00b67f09SDavid van Moolenbroek isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
2059*00b67f09SDavid van Moolenbroek REQUIRE(managerp != NULL && ISCAPI_TASKMGR_VALID(*managerp));
2060*00b67f09SDavid van Moolenbroek
2061*00b67f09SDavid van Moolenbroek if (isc_bind9)
2062*00b67f09SDavid van Moolenbroek isc__taskmgr_destroy(managerp);
2063*00b67f09SDavid van Moolenbroek else
2064*00b67f09SDavid van Moolenbroek (*managerp)->methods->destroy(managerp);
2065*00b67f09SDavid van Moolenbroek
2066*00b67f09SDavid van Moolenbroek ENSURE(*managerp == NULL);
2067*00b67f09SDavid van Moolenbroek }
2068*00b67f09SDavid van Moolenbroek
2069*00b67f09SDavid van Moolenbroek void
isc_taskmgr_setmode(isc_taskmgr_t * manager,isc_taskmgrmode_t mode)2070*00b67f09SDavid van Moolenbroek isc_taskmgr_setmode(isc_taskmgr_t *manager, isc_taskmgrmode_t mode) {
2071*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASKMGR_VALID(manager));
2072*00b67f09SDavid van Moolenbroek
2073*00b67f09SDavid van Moolenbroek if (isc_bind9)
2074*00b67f09SDavid van Moolenbroek isc__taskmgr_setmode(manager, mode);
2075*00b67f09SDavid van Moolenbroek else
2076*00b67f09SDavid van Moolenbroek manager->methods->setmode(manager, mode);
2077*00b67f09SDavid van Moolenbroek }
2078*00b67f09SDavid van Moolenbroek
2079*00b67f09SDavid van Moolenbroek isc_taskmgrmode_t
isc_taskmgr_mode(isc_taskmgr_t * manager)2080*00b67f09SDavid van Moolenbroek isc_taskmgr_mode(isc_taskmgr_t *manager) {
2081*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASKMGR_VALID(manager));
2082*00b67f09SDavid van Moolenbroek
2083*00b67f09SDavid van Moolenbroek if (isc_bind9)
2084*00b67f09SDavid van Moolenbroek return (isc__taskmgr_mode(manager));
2085*00b67f09SDavid van Moolenbroek
2086*00b67f09SDavid van Moolenbroek return (manager->methods->mode(manager));
2087*00b67f09SDavid van Moolenbroek }
2088*00b67f09SDavid van Moolenbroek
2089*00b67f09SDavid van Moolenbroek isc_result_t
isc_task_create(isc_taskmgr_t * manager,unsigned int quantum,isc_task_t ** taskp)2090*00b67f09SDavid van Moolenbroek isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
2091*00b67f09SDavid van Moolenbroek isc_task_t **taskp)
2092*00b67f09SDavid van Moolenbroek {
2093*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASKMGR_VALID(manager));
2094*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL && *taskp == NULL);
2095*00b67f09SDavid van Moolenbroek
2096*00b67f09SDavid van Moolenbroek if (isc_bind9)
2097*00b67f09SDavid van Moolenbroek return (isc__task_create(manager, quantum, taskp));
2098*00b67f09SDavid van Moolenbroek
2099*00b67f09SDavid van Moolenbroek return (manager->methods->taskcreate(manager, quantum, taskp));
2100*00b67f09SDavid van Moolenbroek }
2101*00b67f09SDavid van Moolenbroek
2102*00b67f09SDavid van Moolenbroek void
isc_task_attach(isc_task_t * source,isc_task_t ** targetp)2103*00b67f09SDavid van Moolenbroek isc_task_attach(isc_task_t *source, isc_task_t **targetp) {
2104*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(source));
2105*00b67f09SDavid van Moolenbroek REQUIRE(targetp != NULL && *targetp == NULL);
2106*00b67f09SDavid van Moolenbroek
2107*00b67f09SDavid van Moolenbroek if (isc_bind9)
2108*00b67f09SDavid van Moolenbroek isc__task_attach(source, targetp);
2109*00b67f09SDavid van Moolenbroek else
2110*00b67f09SDavid van Moolenbroek source->methods->attach(source, targetp);
2111*00b67f09SDavid van Moolenbroek
2112*00b67f09SDavid van Moolenbroek ENSURE(*targetp == source);
2113*00b67f09SDavid van Moolenbroek }
2114*00b67f09SDavid van Moolenbroek
2115*00b67f09SDavid van Moolenbroek void
isc_task_detach(isc_task_t ** taskp)2116*00b67f09SDavid van Moolenbroek isc_task_detach(isc_task_t **taskp) {
2117*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
2118*00b67f09SDavid van Moolenbroek
2119*00b67f09SDavid van Moolenbroek if (isc_bind9)
2120*00b67f09SDavid van Moolenbroek isc__task_detach(taskp);
2121*00b67f09SDavid van Moolenbroek else
2122*00b67f09SDavid van Moolenbroek (*taskp)->methods->detach(taskp);
2123*00b67f09SDavid van Moolenbroek
2124*00b67f09SDavid van Moolenbroek ENSURE(*taskp == NULL);
2125*00b67f09SDavid van Moolenbroek }
2126*00b67f09SDavid van Moolenbroek
2127*00b67f09SDavid van Moolenbroek void
isc_task_send(isc_task_t * task,isc_event_t ** eventp)2128*00b67f09SDavid van Moolenbroek isc_task_send(isc_task_t *task, isc_event_t **eventp) {
2129*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2130*00b67f09SDavid van Moolenbroek REQUIRE(eventp != NULL && *eventp != NULL);
2131*00b67f09SDavid van Moolenbroek
2132*00b67f09SDavid van Moolenbroek if (isc_bind9)
2133*00b67f09SDavid van Moolenbroek isc__task_send(task, eventp);
2134*00b67f09SDavid van Moolenbroek else {
2135*00b67f09SDavid van Moolenbroek task->methods->send(task, eventp);
2136*00b67f09SDavid van Moolenbroek ENSURE(*eventp == NULL);
2137*00b67f09SDavid van Moolenbroek }
2138*00b67f09SDavid van Moolenbroek }
2139*00b67f09SDavid van Moolenbroek
2140*00b67f09SDavid van Moolenbroek void
isc_task_sendanddetach(isc_task_t ** taskp,isc_event_t ** eventp)2141*00b67f09SDavid van Moolenbroek isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
2142*00b67f09SDavid van Moolenbroek REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
2143*00b67f09SDavid van Moolenbroek REQUIRE(eventp != NULL && *eventp != NULL);
2144*00b67f09SDavid van Moolenbroek
2145*00b67f09SDavid van Moolenbroek if (isc_bind9)
2146*00b67f09SDavid van Moolenbroek isc__task_sendanddetach(taskp, eventp);
2147*00b67f09SDavid van Moolenbroek else {
2148*00b67f09SDavid van Moolenbroek (*taskp)->methods->sendanddetach(taskp, eventp);
2149*00b67f09SDavid van Moolenbroek ENSURE(*eventp == NULL);
2150*00b67f09SDavid van Moolenbroek }
2151*00b67f09SDavid van Moolenbroek
2152*00b67f09SDavid van Moolenbroek ENSURE(*taskp == NULL);
2153*00b67f09SDavid van Moolenbroek }
2154*00b67f09SDavid van Moolenbroek
2155*00b67f09SDavid van Moolenbroek unsigned int
isc_task_unsend(isc_task_t * task,void * sender,isc_eventtype_t type,void * tag,isc_eventlist_t * events)2156*00b67f09SDavid van Moolenbroek isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
2157*00b67f09SDavid van Moolenbroek void *tag, isc_eventlist_t *events)
2158*00b67f09SDavid van Moolenbroek {
2159*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2160*00b67f09SDavid van Moolenbroek
2161*00b67f09SDavid van Moolenbroek if (isc_bind9)
2162*00b67f09SDavid van Moolenbroek return (isc__task_unsend(task, sender, type, tag, events));
2163*00b67f09SDavid van Moolenbroek
2164*00b67f09SDavid van Moolenbroek return (task->methods->unsend(task, sender, type, tag, events));
2165*00b67f09SDavid van Moolenbroek }
2166*00b67f09SDavid van Moolenbroek
2167*00b67f09SDavid van Moolenbroek isc_result_t
isc_task_onshutdown(isc_task_t * task,isc_taskaction_t action,void * arg)2168*00b67f09SDavid van Moolenbroek isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg)
2169*00b67f09SDavid van Moolenbroek {
2170*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2171*00b67f09SDavid van Moolenbroek
2172*00b67f09SDavid van Moolenbroek if (isc_bind9)
2173*00b67f09SDavid van Moolenbroek return (isc__task_onshutdown(task, action, arg));
2174*00b67f09SDavid van Moolenbroek
2175*00b67f09SDavid van Moolenbroek return (task->methods->onshutdown(task, action, arg));
2176*00b67f09SDavid van Moolenbroek }
2177*00b67f09SDavid van Moolenbroek
2178*00b67f09SDavid van Moolenbroek void
isc_task_shutdown(isc_task_t * task)2179*00b67f09SDavid van Moolenbroek isc_task_shutdown(isc_task_t *task) {
2180*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2181*00b67f09SDavid van Moolenbroek
2182*00b67f09SDavid van Moolenbroek if (isc_bind9)
2183*00b67f09SDavid van Moolenbroek isc__task_shutdown(task);
2184*00b67f09SDavid van Moolenbroek else
2185*00b67f09SDavid van Moolenbroek task->methods->shutdown(task);
2186*00b67f09SDavid van Moolenbroek }
2187*00b67f09SDavid van Moolenbroek
2188*00b67f09SDavid van Moolenbroek void
isc_task_destroy(isc_task_t ** taskp)2189*00b67f09SDavid van Moolenbroek isc_task_destroy(isc_task_t **taskp) {
2190*00b67f09SDavid van Moolenbroek if (!isc_bind9)
2191*00b67f09SDavid van Moolenbroek return;
2192*00b67f09SDavid van Moolenbroek
2193*00b67f09SDavid van Moolenbroek isc__task_destroy(taskp);
2194*00b67f09SDavid van Moolenbroek }
2195*00b67f09SDavid van Moolenbroek
2196*00b67f09SDavid van Moolenbroek void
isc_task_setname(isc_task_t * task,const char * name,void * tag)2197*00b67f09SDavid van Moolenbroek isc_task_setname(isc_task_t *task, const char *name, void *tag) {
2198*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2199*00b67f09SDavid van Moolenbroek
2200*00b67f09SDavid van Moolenbroek if (isc_bind9)
2201*00b67f09SDavid van Moolenbroek isc__task_setname(task, name, tag);
2202*00b67f09SDavid van Moolenbroek else
2203*00b67f09SDavid van Moolenbroek task->methods->setname(task, name, tag);
2204*00b67f09SDavid van Moolenbroek }
2205*00b67f09SDavid van Moolenbroek
2206*00b67f09SDavid van Moolenbroek unsigned int
isc_task_purge(isc_task_t * task,void * sender,isc_eventtype_t type,void * tag)2207*00b67f09SDavid van Moolenbroek isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type, void *tag)
2208*00b67f09SDavid van Moolenbroek {
2209*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2210*00b67f09SDavid van Moolenbroek
2211*00b67f09SDavid van Moolenbroek if (isc_bind9)
2212*00b67f09SDavid van Moolenbroek return (isc__task_purge(task, sender, type, tag));
2213*00b67f09SDavid van Moolenbroek
2214*00b67f09SDavid van Moolenbroek return (task->methods->purgeevents(task, sender, type, tag));
2215*00b67f09SDavid van Moolenbroek }
2216*00b67f09SDavid van Moolenbroek
2217*00b67f09SDavid van Moolenbroek isc_result_t
isc_task_beginexclusive(isc_task_t * task)2218*00b67f09SDavid van Moolenbroek isc_task_beginexclusive(isc_task_t *task) {
2219*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2220*00b67f09SDavid van Moolenbroek
2221*00b67f09SDavid van Moolenbroek if (isc_bind9)
2222*00b67f09SDavid van Moolenbroek return (isc__task_beginexclusive(task));
2223*00b67f09SDavid van Moolenbroek
2224*00b67f09SDavid van Moolenbroek return (task->methods->beginexclusive(task));
2225*00b67f09SDavid van Moolenbroek }
2226*00b67f09SDavid van Moolenbroek
2227*00b67f09SDavid van Moolenbroek void
isc_task_endexclusive(isc_task_t * task)2228*00b67f09SDavid van Moolenbroek isc_task_endexclusive(isc_task_t *task) {
2229*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2230*00b67f09SDavid van Moolenbroek
2231*00b67f09SDavid van Moolenbroek if (isc_bind9)
2232*00b67f09SDavid van Moolenbroek isc__task_endexclusive(task);
2233*00b67f09SDavid van Moolenbroek else
2234*00b67f09SDavid van Moolenbroek task->methods->endexclusive(task);
2235*00b67f09SDavid van Moolenbroek }
2236*00b67f09SDavid van Moolenbroek
2237*00b67f09SDavid van Moolenbroek void
isc_task_setprivilege(isc_task_t * task,isc_boolean_t priv)2238*00b67f09SDavid van Moolenbroek isc_task_setprivilege(isc_task_t *task, isc_boolean_t priv) {
2239*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2240*00b67f09SDavid van Moolenbroek
2241*00b67f09SDavid van Moolenbroek if (isc_bind9)
2242*00b67f09SDavid van Moolenbroek isc__task_setprivilege(task, priv);
2243*00b67f09SDavid van Moolenbroek else
2244*00b67f09SDavid van Moolenbroek task->methods->setprivilege(task, priv);
2245*00b67f09SDavid van Moolenbroek }
2246*00b67f09SDavid van Moolenbroek
2247*00b67f09SDavid van Moolenbroek isc_boolean_t
isc_task_privilege(isc_task_t * task)2248*00b67f09SDavid van Moolenbroek isc_task_privilege(isc_task_t *task) {
2249*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2250*00b67f09SDavid van Moolenbroek
2251*00b67f09SDavid van Moolenbroek if (isc_bind9)
2252*00b67f09SDavid van Moolenbroek return (isc__task_privilege(task));
2253*00b67f09SDavid van Moolenbroek
2254*00b67f09SDavid van Moolenbroek return (task->methods->privilege(task));
2255*00b67f09SDavid van Moolenbroek }
2256*00b67f09SDavid van Moolenbroek
2257*00b67f09SDavid van Moolenbroek void
isc_task_getcurrenttime(isc_task_t * task,isc_stdtime_t * t)2258*00b67f09SDavid van Moolenbroek isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) {
2259*00b67f09SDavid van Moolenbroek if (!isc_bind9)
2260*00b67f09SDavid van Moolenbroek return;
2261*00b67f09SDavid van Moolenbroek
2262*00b67f09SDavid van Moolenbroek isc__task_getcurrenttime(task, t);
2263*00b67f09SDavid van Moolenbroek }
2264*00b67f09SDavid van Moolenbroek
2265*00b67f09SDavid van Moolenbroek /*%
2266*00b67f09SDavid van Moolenbroek * This is necessary for libisc's internal timer implementation. Other
2267*00b67f09SDavid van Moolenbroek * implementation might skip implementing this.
2268*00b67f09SDavid van Moolenbroek */
2269*00b67f09SDavid van Moolenbroek unsigned int
isc_task_purgerange(isc_task_t * task,void * sender,isc_eventtype_t first,isc_eventtype_t last,void * tag)2270*00b67f09SDavid van Moolenbroek isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
2271*00b67f09SDavid van Moolenbroek isc_eventtype_t last, void *tag)
2272*00b67f09SDavid van Moolenbroek {
2273*00b67f09SDavid van Moolenbroek REQUIRE(ISCAPI_TASK_VALID(task));
2274*00b67f09SDavid van Moolenbroek
2275*00b67f09SDavid van Moolenbroek if (isc_bind9)
2276*00b67f09SDavid van Moolenbroek return (isc__task_purgerange(task, sender, first, last, tag));
2277*00b67f09SDavid van Moolenbroek
2278*00b67f09SDavid van Moolenbroek return (task->methods->purgerange(task, sender, first, last, tag));
2279*00b67f09SDavid van Moolenbroek }
2280