Lines Matching full:task
1 /* $NetBSD: task.c,v 1.1 2024/02/18 20:57:50 christos Exp $ */
19 * XXXRTH Need to document the states a task can be in, and the rules
39 #include <isc/task.h>
56 * Task manager is built around 'as little locking as possible' concept.
57 * Each thread has his own queue of tasks to be run, if a task is in running
58 * state it will stay on the runner it's currently on, if a task is in idle
62 * To make load even some tasks (from task pools) are bound to specific
69 fprintf(stderr, "task %p thread %zu: %s\n", task, isc_tid_v, (m))
71 fprintf(stderr, "task %p thread %zu: %s\n", (t), isc_tid_v, (m))
106 /* Locked by task lock. */
124 /* Locked by task manager lock. */
143 /* Locked by task manager lock. */
161 isc_task_purgeevent(isc_task_t *task, isc_event_t *event);
163 isc_taskmgr_setexcltask(isc_taskmgr_t *mgr, isc_task_t *task);
172 task_finished(isc_task_t *task) { in task_finished() argument
173 isc_taskmgr_t *manager = task->manager; in task_finished()
175 REQUIRE(EMPTY(task->events)); in task_finished()
176 REQUIRE(task->nevents == 0); in task_finished()
177 REQUIRE(EMPTY(task->on_shutdown)); in task_finished()
178 REQUIRE(task->state == task_state_done); in task_finished()
182 isc_refcount_destroy(&task->running); in task_finished()
183 isc_refcount_destroy(&task->references); in task_finished()
186 UNLINK(manager->tasks, task, link); in task_finished()
190 isc_mutex_destroy(&task->lock); in task_finished()
191 task->magic = 0; in task_finished()
192 isc_mem_put(mctx, task, sizeof(*task)); in task_finished()
206 isc_task_t *task = NULL; in isc_task_create_bound() local
214 task = isc_mem_get(manager->mctx, sizeof(*task)); in isc_task_create_bound()
215 *task = (isc_task_t){ 0 }; in isc_task_create_bound()
217 isc_taskmgr_attach(manager, &task->manager); in isc_task_create_bound()
221 * Task is not pinned to a queue, it's threadid will be in isc_task_create_bound()
222 * chosen when first task will be sent to it - either in isc_task_create_bound()
225 task->bound = false; in isc_task_create_bound()
226 task->threadid = -1; in isc_task_create_bound()
229 * Task is pinned to a queue, it'll always be run in isc_task_create_bound()
232 task->bound = true; in isc_task_create_bound()
233 task->threadid = threadid; in isc_task_create_bound()
236 isc_mutex_init(&task->lock); in isc_task_create_bound()
237 task->state = task_state_idle; in isc_task_create_bound()
238 task->pause_cnt = 0; in isc_task_create_bound()
240 isc_refcount_init(&task->references, 1); in isc_task_create_bound()
241 isc_refcount_init(&task->running, 0); in isc_task_create_bound()
242 INIT_LIST(task->events); in isc_task_create_bound()
243 INIT_LIST(task->on_shutdown); in isc_task_create_bound()
244 task->nevents = 0; in isc_task_create_bound()
245 task->quantum = (quantum > 0) ? quantum : manager->default_quantum; in isc_task_create_bound()
246 atomic_init(&task->shuttingdown, false); in isc_task_create_bound()
247 atomic_init(&task->privileged, false); in isc_task_create_bound()
248 task->now = 0; in isc_task_create_bound()
249 isc_time_settoepoch(&task->tnow); in isc_task_create_bound()
250 memset(task->name, 0, sizeof(task->name)); in isc_task_create_bound()
251 task->tag = NULL; in isc_task_create_bound()
252 INIT_LINK(task, link); in isc_task_create_bound()
253 task->magic = TASK_MAGIC; in isc_task_create_bound()
258 APPEND(manager->tasks, task, link); in isc_task_create_bound()
264 isc_refcount_destroy(&task->running); in isc_task_create_bound()
265 isc_refcount_decrement(&task->references); in isc_task_create_bound()
266 isc_refcount_destroy(&task->references); in isc_task_create_bound()
267 isc_mutex_destroy(&task->lock); in isc_task_create_bound()
268 isc_taskmgr_detach(&task->manager); in isc_task_create_bound()
269 isc_mem_put(manager->mctx, task, sizeof(*task)); in isc_task_create_bound()
273 *taskp = task; in isc_task_create_bound()
295 task_shutdown(isc_task_t *task) { in task_shutdown() argument
300 * Caller must be holding the task's lock. in task_shutdown()
305 if (atomic_compare_exchange_strong(&task->shuttingdown, in task_shutdown()
309 if (task->state == task_state_idle) { in task_shutdown()
310 INSIST(EMPTY(task->events)); in task_shutdown()
311 task->state = task_state_ready; in task_shutdown()
314 INSIST(task->state == task_state_ready || in task_shutdown()
315 task->state == task_state_paused || in task_shutdown()
316 task->state == task_state_pausing || in task_shutdown()
317 task->state == task_state_running); in task_shutdown()
322 for (event = TAIL(task->on_shutdown); event != NULL; in task_shutdown()
326 DEQUEUE(task->on_shutdown, event, ev_link); in task_shutdown()
327 ENQUEUE(task->events, event, ev_link); in task_shutdown()
328 task->nevents++; in task_shutdown()
336 * Moves a task onto the appropriate run queue.
341 task_ready(isc_task_t *task) { in task_ready() argument
342 isc_taskmgr_t *manager = task->manager; in task_ready()
347 isc_refcount_increment0(&task->running); in task_ready()
348 LOCK(&task->lock); in task_ready()
349 isc_nm_task_enqueue(manager->netmgr, task, task->threadid); in task_ready()
350 UNLOCK(&task->lock); in task_ready()
354 isc_task_ready(isc_task_t *task) { in isc_task_ready() argument
355 task_ready(task); in isc_task_ready()
359 task_detach(isc_task_t *task) { in task_detach() argument
361 * Caller must be holding the task lock. in task_detach()
366 if (isc_refcount_decrement(&task->references) == 1 && in task_detach()
367 task->state == task_state_idle) in task_detach()
369 INSIST(EMPTY(task->events)); in task_detach()
371 * There are no references to this task, and no in task_detach()
373 * either initiate shutdown or clean up the task, in task_detach()
375 * make the task ready and allow run() or the event in task_detach()
378 task->state = task_state_ready; in task_detach()
387 isc_task_t *task; in isc_task_detach() local
391 * Detach *taskp from its task. in isc_task_detach()
395 task = *taskp; in isc_task_detach()
396 REQUIRE(VALID_TASK(task)); in isc_task_detach()
400 LOCK(&task->lock); in isc_task_detach()
401 was_idle = task_detach(task); in isc_task_detach()
402 UNLOCK(&task->lock); in isc_task_detach()
405 task_ready(task); in isc_task_detach()
412 task_send(isc_task_t *task, isc_event_t **eventp, int c) { in task_send() argument
417 * Caller must be holding the task lock. in task_send()
425 REQUIRE(task->state != task_state_done); in task_send()
430 if (task->bound) { in task_send()
431 c = task->threadid; in task_send()
436 if (task->state == task_state_idle) { in task_send()
438 task->threadid = c; in task_send()
439 INSIST(EMPTY(task->events)); in task_send()
440 task->state = task_state_ready; in task_send()
442 INSIST(task->state == task_state_ready || in task_send()
443 task->state == task_state_running || in task_send()
444 task->state == task_state_paused || in task_send()
445 task->state == task_state_pausing); in task_send()
446 ENQUEUE(task->events, event, ev_link); in task_send()
447 task->nevents++; in task_send()
453 isc_task_send(isc_task_t *task, isc_event_t **eventp) { in isc_task_send() argument
454 isc_task_sendto(task, eventp, -1); in isc_task_send()
463 isc_task_sendto(isc_task_t *task, isc_event_t **eventp, int c) { in isc_task_sendto() argument
467 * Send '*event' to 'task'. in isc_task_sendto()
470 REQUIRE(VALID_TASK(task)); in isc_task_sendto()
478 LOCK(&task->lock); in isc_task_sendto()
479 was_idle = task_send(task, eventp, c); in isc_task_sendto()
480 UNLOCK(&task->lock); in isc_task_sendto()
484 * We need to add this task to the ready queue. in isc_task_sendto()
486 * We've waited until now to do it because making a task in isc_task_sendto()
488 * this while holding the task lock, we could deadlock. in isc_task_sendto()
491 * be trying to add this task to the ready queue. The in isc_task_sendto()
493 * task. It thus doesn't matter if events are added, in isc_task_sendto()
495 * between the time we released the task lock, and the time in isc_task_sendto()
496 * we add the task to the ready queue. in isc_task_sendto()
498 task_ready(task); in isc_task_sendto()
505 isc_task_t *task; in isc_task_sendtoanddetach() local
509 * task. in isc_task_sendtoanddetach()
513 task = *taskp; in isc_task_sendtoanddetach()
514 REQUIRE(VALID_TASK(task)); in isc_task_sendtoanddetach()
517 LOCK(&task->lock); in isc_task_sendtoanddetach()
518 idle1 = task_send(task, eventp, c); in isc_task_sendtoanddetach()
519 idle2 = task_detach(task); in isc_task_sendtoanddetach()
520 UNLOCK(&task->lock); in isc_task_sendtoanddetach()
524 * the task lock, and thus the task cannot switch from ready back to in isc_task_sendtoanddetach()
530 task_ready(task); in isc_task_sendtoanddetach()
539 dequeue_events(isc_task_t *task, void *sender, isc_eventtype_t first, in dequeue_events() argument
545 REQUIRE(VALID_TASK(task)); in dequeue_events()
558 LOCK(&task->lock); in dequeue_events()
560 for (event = HEAD(task->events); event != NULL; event = next_event) { in dequeue_events()
567 DEQUEUE(task->events, event, ev_link); in dequeue_events()
568 task->nevents--; in dequeue_events()
574 UNLOCK(&task->lock); in dequeue_events()
580 isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first, in isc_task_purgerange() argument
585 REQUIRE(VALID_TASK(task)); in isc_task_purgerange()
588 * Purge events from a task's event queue. in isc_task_purgerange()
595 count = dequeue_events(task, sender, first, last, tag, &events, true); in isc_task_purgerange()
604 * Note that purging never changes the state of the task. in isc_task_purgerange()
611 isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type, in isc_task_purge() argument
614 * Purge events from a task's event queue. in isc_task_purge()
616 REQUIRE(VALID_TASK(task)); in isc_task_purge()
620 return (isc_task_purgerange(task, sender, type, type, tag)); in isc_task_purge()
624 isc_task_purgeevent(isc_task_t *task, isc_event_t *event) { in isc_task_purgeevent() argument
628 * Purge 'event' from a task's event queue. in isc_task_purgeevent()
631 REQUIRE(VALID_TASK(task)); in isc_task_purgeevent()
634 * If 'event' is on the task's event queue, it will be purged, in isc_task_purgeevent()
636 * on the task's event queue; in fact, it can even be an invalid in isc_task_purgeevent()
637 * pointer. Purging only occurs if the event is actually on the task's in isc_task_purgeevent()
640 * Purging never changes the state of the task. in isc_task_purgeevent()
643 LOCK(&task->lock); in isc_task_purgeevent()
645 DEQUEUE(task->events, event, ev_link); in isc_task_purgeevent()
646 task->nevents--; in isc_task_purgeevent()
649 UNLOCK(&task->lock); in isc_task_purgeevent()
661 isc_task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first, in isc_task_unsendrange() argument
664 * Remove events from a task's event queue. in isc_task_unsendrange()
666 REQUIRE(VALID_TASK(task)); in isc_task_unsendrange()
670 return (dequeue_events(task, sender, first, last, tag, events, false)); in isc_task_unsendrange()
674 isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type, void *tag, in isc_task_unsend() argument
677 * Remove events from a task's event queue. in isc_task_unsend()
682 return (dequeue_events(task, sender, type, type, tag, events, false)); in isc_task_unsend()
686 isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg) { in isc_task_onshutdown() argument
693 * 'task' is shutdown. in isc_task_onshutdown()
696 REQUIRE(VALID_TASK(task)); in isc_task_onshutdown()
699 event = isc_event_allocate(task->manager->mctx, NULL, in isc_task_onshutdown()
703 if (TASK_SHUTTINGDOWN(task)) { in isc_task_onshutdown()
707 LOCK(&task->lock); in isc_task_onshutdown()
708 ENQUEUE(task->on_shutdown, event, ev_link); in isc_task_onshutdown()
709 UNLOCK(&task->lock); in isc_task_onshutdown()
713 isc_mem_put(task->manager->mctx, event, sizeof(*event)); in isc_task_onshutdown()
720 isc_task_shutdown(isc_task_t *task) { in isc_task_shutdown() argument
724 * Shutdown 'task'. in isc_task_shutdown()
727 REQUIRE(VALID_TASK(task)); in isc_task_shutdown()
729 LOCK(&task->lock); in isc_task_shutdown()
730 was_idle = task_shutdown(task); in isc_task_shutdown()
731 UNLOCK(&task->lock); in isc_task_shutdown()
734 task_ready(task); in isc_task_shutdown()
751 isc_task_setname(isc_task_t *task, const char *name, void *tag) { in isc_task_setname() argument
753 * Name 'task'. in isc_task_setname()
756 REQUIRE(VALID_TASK(task)); in isc_task_setname()
758 LOCK(&task->lock); in isc_task_setname()
759 strlcpy(task->name, name, sizeof(task->name)); in isc_task_setname()
760 task->tag = tag; in isc_task_setname()
761 UNLOCK(&task->lock); in isc_task_setname()
765 isc_task_getname(isc_task_t *task) { in isc_task_getname() argument
766 REQUIRE(VALID_TASK(task)); in isc_task_getname()
768 return (task->name); in isc_task_getname()
772 isc_task_gettag(isc_task_t *task) { in isc_task_gettag() argument
773 REQUIRE(VALID_TASK(task)); in isc_task_gettag()
775 return (task->tag); in isc_task_gettag()
779 isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) { in isc_task_getcurrenttime() argument
780 REQUIRE(VALID_TASK(task)); in isc_task_getcurrenttime()
783 LOCK(&task->lock); in isc_task_getcurrenttime()
784 *t = task->now; in isc_task_getcurrenttime()
785 UNLOCK(&task->lock); in isc_task_getcurrenttime()
789 isc_task_getcurrenttimex(isc_task_t *task, isc_time_t *t) { in isc_task_getcurrenttimex() argument
790 REQUIRE(VALID_TASK(task)); in isc_task_getcurrenttimex()
793 LOCK(&task->lock); in isc_task_getcurrenttimex()
794 *t = task->tnow; in isc_task_getcurrenttimex()
795 UNLOCK(&task->lock); in isc_task_getcurrenttimex()
799 isc_task_getnetmgr(isc_task_t *task) { in isc_task_getnetmgr() argument
800 REQUIRE(VALID_TASK(task)); in isc_task_getnetmgr()
802 return (task->manager->netmgr); in isc_task_getnetmgr()
806 isc_task_setquantum(isc_task_t *task, unsigned int quantum) { in isc_task_setquantum() argument
807 REQUIRE(VALID_TASK(task)); in isc_task_setquantum()
809 LOCK(&task->lock); in isc_task_setquantum()
810 task->quantum = (quantum > 0) ? quantum in isc_task_setquantum()
811 : task->manager->default_quantum; in isc_task_setquantum()
812 UNLOCK(&task->lock); in isc_task_setquantum()
816 *** Task Manager.
820 task_run(isc_task_t *task) { in task_run() argument
827 REQUIRE(VALID_TASK(task)); in task_run()
829 LOCK(&task->lock); in task_run()
830 quantum = task->quantum; in task_run()
833 * It is possible because that we have a paused task in the queue - it in task_run()
835 * and task lock to avoid deadlocks, just bail then. in task_run()
837 if (task->state != task_state_ready) { in task_run()
841 INSIST(task->state == task_state_ready); in task_run()
842 task->state = task_state_running; in task_run()
844 XTRACE(task->name); in task_run()
845 TIME_NOW(&task->tnow); in task_run()
846 task->now = isc_time_seconds(&task->tnow); in task_run()
849 if (!EMPTY(task->events)) { in task_run()
850 event = HEAD(task->events); in task_run()
851 DEQUEUE(task->events, event, ev_link); in task_run()
852 task->nevents--; in task_run()
858 XTRACE(task->name); in task_run()
860 UNLOCK(&task->lock); in task_run()
861 (event->ev_action)(task, event); in task_run()
862 LOCK(&task->lock); in task_run()
868 if (isc_refcount_current(&task->references) == 0 && in task_run()
869 EMPTY(task->events) && !TASK_SHUTTINGDOWN(task)) in task_run()
873 * this task, which means it will not become runnable in task_run()
881 * EMPTY(task->events)" block below because: in task_run()
883 * If we post no shutdown events, we want the task in task_run()
887 * the task's quantum to be applied. in task_run()
889 INSIST(!task_shutdown(task)); in task_run()
892 if (EMPTY(task->events)) { in task_run()
894 * Nothing else to do for this task right now. in task_run()
897 if (isc_refcount_current(&task->references) == 0 && in task_run()
898 TASK_SHUTTINGDOWN(task)) in task_run()
901 * The task is done. in task_run()
904 task->state = task_state_done; in task_run()
906 if (task->state == task_state_running) { in task_run()
908 task->state = task_state_idle; in task_run()
909 } else if (task->state == task_state_pausing) { in task_run()
911 task->state = task_state_paused; in task_run()
915 } else if (task->state == task_state_pausing) { in task_run()
917 * We got a pause request on this task, stop working on in task_run()
921 task->state = task_state_paused; in task_run()
932 task->state = task_state_ready; in task_run()
939 if (isc_refcount_decrement(&task->running) == 1 && in task_run()
940 task->state == task_state_done) in task_run()
944 UNLOCK(&task->lock); in task_run()
947 task_finished(task); in task_run()
954 isc_task_run(isc_task_t *task) { in isc_task_run() argument
955 return (task_run(task)); in isc_task_run()
997 * Create a new task manager. in isc__taskmgr_create()
1033 isc_task_t *task; in isc__taskmgr_shutdown() local
1041 * task manager, it should ask some non-worker thread to call in isc__taskmgr_shutdown()
1052 * task manager lock and a task lock at the same time. in isc__taskmgr_shutdown()
1066 * Post shutdown event(s) to every task (if they haven't already been in isc__taskmgr_shutdown()
1069 for (task = HEAD(manager->tasks); task != NULL; task = NEXT(task, link)) in isc__taskmgr_shutdown()
1073 LOCK(&task->lock); in isc__taskmgr_shutdown()
1074 was_idle = task_shutdown(task); in isc__taskmgr_shutdown()
1076 task->threadid = 0; in isc__taskmgr_shutdown()
1078 UNLOCK(&task->lock); in isc__taskmgr_shutdown()
1081 task_ready(task); in isc__taskmgr_shutdown()
1111 isc_taskmgr_setexcltask(isc_taskmgr_t *mgr, isc_task_t *task) { in isc_taskmgr_setexcltask() argument
1113 REQUIRE(VALID_TASK(task)); in isc_taskmgr_setexcltask()
1115 LOCK(&task->lock); in isc_taskmgr_setexcltask()
1116 REQUIRE(task->threadid == 0); in isc_taskmgr_setexcltask()
1117 UNLOCK(&task->lock); in isc_taskmgr_setexcltask()
1123 isc_task_attach(task, &mgr->excl); in isc_taskmgr_setexcltask()
1149 isc_task_beginexclusive(isc_task_t *task) { in isc_task_beginexclusive() argument
1152 REQUIRE(VALID_TASK(task)); in isc_task_beginexclusive()
1154 manager = task->manager; in isc_task_beginexclusive()
1156 REQUIRE(task->state == task_state_running); in isc_task_beginexclusive()
1159 REQUIRE(task == manager->excl || in isc_task_beginexclusive()
1172 "exclusive task mode: %s", "starting"); in isc_task_beginexclusive()
1180 "exclusive task mode: %s", "started"); in isc_task_beginexclusive()
1187 isc_task_endexclusive(isc_task_t *task) { in isc_task_endexclusive() argument
1190 REQUIRE(VALID_TASK(task)); in isc_task_endexclusive()
1191 REQUIRE(task->state == task_state_running); in isc_task_endexclusive()
1192 manager = task->manager; in isc_task_endexclusive()
1197 "exclusive task mode: %s", "ending"); in isc_task_endexclusive()
1205 "exclusive task mode: %s", "ended"); in isc_task_endexclusive()
1213 isc_task_pause(isc_task_t *task) { in isc_task_pause() argument
1214 REQUIRE(VALID_TASK(task)); in isc_task_pause()
1216 LOCK(&task->lock); in isc_task_pause()
1217 task->pause_cnt++; in isc_task_pause()
1218 if (task->pause_cnt > 1) { in isc_task_pause()
1220 * Someone already paused this task, just increase in isc_task_pause()
1223 UNLOCK(&task->lock); in isc_task_pause()
1227 INSIST(task->state == task_state_idle || in isc_task_pause()
1228 task->state == task_state_ready || in isc_task_pause()
1229 task->state == task_state_running); in isc_task_pause()
1230 if (task->state == task_state_running) { in isc_task_pause()
1231 task->state = task_state_pausing; in isc_task_pause()
1233 task->state = task_state_paused; in isc_task_pause()
1235 UNLOCK(&task->lock); in isc_task_pause()
1239 isc_task_unpause(isc_task_t *task) { in isc_task_unpause() argument
1242 REQUIRE(VALID_TASK(task)); in isc_task_unpause()
1244 LOCK(&task->lock); in isc_task_unpause()
1245 task->pause_cnt--; in isc_task_unpause()
1246 INSIST(task->pause_cnt >= 0); in isc_task_unpause()
1247 if (task->pause_cnt > 0) { in isc_task_unpause()
1248 UNLOCK(&task->lock); in isc_task_unpause()
1252 INSIST(task->state == task_state_paused || in isc_task_unpause()
1253 task->state == task_state_pausing); in isc_task_unpause()
1254 /* If the task was pausing we can't reschedule it */ in isc_task_unpause()
1255 if (task->state == task_state_pausing) { in isc_task_unpause()
1256 task->state = task_state_running; in isc_task_unpause()
1258 task->state = task_state_idle; in isc_task_unpause()
1260 if (task->state == task_state_idle && !EMPTY(task->events)) { in isc_task_unpause()
1261 task->state = task_state_ready; in isc_task_unpause()
1264 UNLOCK(&task->lock); in isc_task_unpause()
1267 task_ready(task); in isc_task_unpause()
1282 isc_task_setprivilege(isc_task_t *task, bool priv) { in isc_task_setprivilege() argument
1283 REQUIRE(VALID_TASK(task)); in isc_task_setprivilege()
1285 atomic_store_release(&task->privileged, priv); in isc_task_setprivilege()
1289 isc_task_getprivilege(isc_task_t *task) { in isc_task_getprivilege() argument
1290 REQUIRE(VALID_TASK(task)); in isc_task_getprivilege()
1292 return (TASK_PRIVILEGED(task)); in isc_task_getprivilege()
1296 isc_task_privileged(isc_task_t *task) { in isc_task_privileged() argument
1297 REQUIRE(VALID_TASK(task)); in isc_task_privileged()
1299 return (isc_taskmgr_mode(task->manager) && TASK_PRIVILEGED(task)); in isc_task_privileged()
1303 isc_task_exiting(isc_task_t *task) { in isc_task_exiting() argument
1304 REQUIRE(VALID_TASK(task)); in isc_task_exiting()
1306 return (TASK_SHUTTINGDOWN(task)); in isc_task_exiting()
1318 isc_task_t *task = NULL; in isc_taskmgr_renderxml() local
1341 task = ISC_LIST_HEAD(mgr->tasks); in isc_taskmgr_renderxml()
1342 while (task != NULL) { in isc_taskmgr_renderxml()
1343 LOCK(&task->lock); in isc_taskmgr_renderxml()
1344 TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "task")); in isc_taskmgr_renderxml()
1346 if (task->name[0] != 0) { in isc_taskmgr_renderxml()
1350 task->name)); in isc_taskmgr_renderxml()
1358 isc_refcount_current(&task->references))); in isc_taskmgr_renderxml()
1362 TRY0(xmlTextWriterWriteFormatString(writer, "%p", task)); in isc_taskmgr_renderxml()
1367 statenames[task->state])); in isc_taskmgr_renderxml()
1372 task->quantum)); in isc_taskmgr_renderxml()
1377 task->nevents)); in isc_taskmgr_renderxml()
1382 UNLOCK(&task->lock); in isc_taskmgr_renderxml()
1383 task = ISC_LIST_NEXT(task, link); in isc_taskmgr_renderxml()
1388 if (task != NULL) { in isc_taskmgr_renderxml()
1389 UNLOCK(&task->lock); in isc_taskmgr_renderxml()
1409 isc_task_t *task = NULL; in isc_taskmgr_renderjson() local
1430 for (task = ISC_LIST_HEAD(mgr->tasks); task != NULL; in isc_taskmgr_renderjson()
1431 task = ISC_LIST_NEXT(task, link)) in isc_taskmgr_renderjson()
1435 LOCK(&task->lock); in isc_taskmgr_renderjson()
1441 snprintf(buf, sizeof(buf), "%p", task); in isc_taskmgr_renderjson()
1446 if (task->name[0] != 0) { in isc_taskmgr_renderjson()
1447 obj = json_object_new_string(task->name); in isc_taskmgr_renderjson()
1453 isc_refcount_current(&task->references)); in isc_taskmgr_renderjson()
1457 obj = json_object_new_string(statenames[task->state]); in isc_taskmgr_renderjson()
1461 obj = json_object_new_int(task->quantum); in isc_taskmgr_renderjson()
1465 obj = json_object_new_int(task->nevents); in isc_taskmgr_renderjson()
1469 UNLOCK(&task->lock); in isc_taskmgr_renderjson()
1481 if (task != NULL) { in isc_taskmgr_renderjson()
1482 UNLOCK(&task->lock); in isc_taskmgr_renderjson()