man/man9/taskqueue.9

.\"
.\" Copyright (c) 2000 Doug Rabson
.\"
.\" All rights reserved.
.\"
.\" This program is free software.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY EXPRESS OR
.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
.\" IN NO EVENT SHALL THE DEVELOPERS BE LIABLE FOR ANY DIRECT, INDIRECT,
.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
.\"
.\" $FreeBSD: src/share/man/man9/taskqueue.9,v 1.21 2007/07/09 06:24:10 jmg Exp $
.\"
.Dd July 24, 2013
.Dt TASKQUEUE 9
.Os
.Sh NAME
.Nm taskqueue_block ,
.Nm taskqueue_cancel ,
.Nm taskqueue_cancel_timeout ,
.Nm taskqueue_create ,
.Nm taskqueue_drain ,
.Nm taskqueue_drain_timeout ,
.Nm taskqueue_enqueue ,
.Nm taskqueue_enqueue_timeout ,
.Nm taskqueue_free ,
.Nm taskqueue_find ,
.Nm taskqueue_run ,
.Nm taskqueue_start_threads ,
.Nm taskqueue_unblock ,
.Nm TASK_INIT ,
.Nm TASKQUEUE_DECLARE ,
.Nm TASKQUEUE_DEFINE
.Nd asynchronous task execution
.Sh SYNOPSIS
.In sys/param.h
.In sys/kernel.h
.In sys/malloc.h
.In sys/queue.h
.In sys/taskqueue.h
.Bd -literal
typedef void (*task_fn_t)(void *context, int pending);

typedef void (*taskqueue_enqueue_fn)(void *context);

struct task {
	STAILQ_ENTRY(task)	ta_link;	/* link for queue */
	int			ta_pending;	/* count times queued */
	int			ta_priority;	/* priority of task in queue */
	task_fn_t		ta_func;	/* task handler */
	void			*ta_context;	/* argument for handler */
};
.Ed
.Ft struct taskqueue *
.Fn taskqueue_create "const char *name" "int mflags" "taskqueue_enqueue_fn enqueue" "void *context"
.Ft void
.Fn taskqueue_free "struct taskqueue *queue"
.Ft struct taskqueue *
.Fn taskqueue_find "const char *name"
.Ft int
.Fn taskqueue_enqueue "struct taskqueue *queue" "struct task *task"
.Ft int
.Fn taskqueue_enqueue_timeout "struct taskqueue *queue" "struct timeout_task *timeout_task" "int ticks"
.Ft int
.Fn taskqueue_cancel "struct taskqueue *queue" "struct task *task" "u_int *pendp"
.Ft int
.Fn taskqueue_cancel_timeout "struct taskqueue *queue" "struct timeout_task *timeout_task" "u_int *pendp"
.Ft void
.Fn taskqueue_run "struct taskqueue *queue"
.Ft void
.Fn taskqueue_drain "struct taskqueue *queue" "struct task *task"
.Ft void
.Fn taskqueue_drain_timeout "struct taskqueue *queue" "struct timeout_task *timeout_task"
.Ft void
.Fn taskqueue_block "struct taskqueue *queue"
.Ft void
.Fn taskqueue_unblock "struct taskqueue *queue"
.Ft int
.Fn taskqueue_start_threads "struct taskqueue **tqp" "int count" "int pri" "int ncpu" "const char *fmt" "..."
.Fn TASK_INIT "struct task *task" "int priority" "task_fn_t *func" "void *context"
.Fn TASKQUEUE_DECLARE "name"
.Fn TASKQUEUE_DEFINE "name" "taskqueue_enqueue_fn enqueue" "void *context" "init"
.Sh DESCRIPTION
These functions provide a simple interface for asynchronous execution
of code.
.Pp
The function
.Fn taskqueue_create
is used to create new queues.
The arguments to
.Fn taskqueue_create
include a name that should be unique,
a set of
.Xr kmalloc 9
flags that specify whether the call to
.Fn malloc
is allowed to sleep,
and a function which is called from
.Fn taskqueue_enqueue
when a task is added to the queue
.\" XXX	The rest of the sentence gets lots in relation to the first part.
to allow the queue to arrange to be run later
(for instance by scheduling a software interrupt or waking a kernel
thread).
.Pp
The function
.Fn taskqueue_free
should be used to remove the queue from the global list of queues
and free the memory used by the queue.
Any tasks that are on the queue will be executed at this time.
.Pp
The system maintains a list of all queues which can be searched using
.Fn taskqueue_find .
The first queue whose name matches is returned, otherwise
.Dv NULL .
.Pp
To add a task to the list of tasks queued on a taskqueue, call
.Fn taskqueue_enqueue
with pointers to the queue and task.
If the task's
.Fa ta_pending
field is non-zero,
then it is simply incremented to reflect the number of times the task
was enqueued.
Otherwise,
the task is added to the list before the first task which has a lower
.Fa ta_priority
value or at the end of the list if no tasks have a lower priority.
Enqueueing a task does not perform any memory allocation which makes
it suitable for calling from an interrupt handler.
This function will return
.Er EPIPE
if the queue is being freed.
.Pp
To execute all the tasks on a queue,
call
.Fn taskqueue_run .
When a task is executed,
first it is removed from the queue,
the value of
.Fa ta_pending
is recorded and then the field is zeroed.
The function
.Fa ta_func
from the task structure is called with the value of the field
.Fa ta_context
as its first argument
and the value of
.Fa ta_pending
as its second argument.
.Pp
The
.Fn taskqueue_enqueue_timeout
is used to schedule the enqueue after the specified amount of
.Va ticks .
If the
.Va ticks
argument is negative, the already scheduled enqueueing is not re-scheduled.
Otherwise, the task is scheduled for enqueueing in the future,
after the absolute value of
.Va ticks
is passed.
.Pp
The
.Fn taskqueue_cancel
function is used to cancel a task.
The
.Va ta_pending
count is cleared, and the old value returned in the reference
parameter
.Fa pendp ,
if it is
.Pf non- Dv NULL .
If the task is currently running,
.Er EBUSY
is returned, otherwise 0.
To implement a blocking
.Fn taskqueue_cancel
that waits for a running task to finish, it could look like:
.Bd -literal -offset indent
while (taskqueue_cancel(tq, task, NULL) != 0)
	taskqueue_drain(tq, task);
.Ed
.Pp
Note that, as with
.Fn taskqueue_drain ,
the caller is responsible for ensuring that the task is not re-enqueued
after being canceled.
.Pp
Similarly, the
.Fn taskqueue_cancel_timeout
function is used to cancel the scheduled task execution.
.Pp
The
.Fn taskqueue_drain
function is used to wait for the task to finish, and
the
.Fn taskqueue_drain_timeout
function is used to wait for the scheduled task to finish.
There is no guarantee that the task will not be
enqueued after call to
.Fn taskqueue_drain .
.Pp
The
.Fn taskqueue_block
function is used to block a taskqueue.
When a taskqueue is blocked, calls to
.Fn taskqueue_enqueue
will still enqueue tasks but
they will not be run until the taskqueue is unblocked by calling
.Fn taskqueue_unblock .
.Pp
The
.Fn taskqueue_start_threads
function is used to create and start
.Fa count
dedicated threads for the taskqueue specified by
.Fa tqp .
These threads will be created with the priority specified by
.Fa pri
and the name given by
.Fa fmt
with _N appended to it, where N is the number of the thread.
If
.Fa count
\*(Gt 1 and
.Fa ncpu
is -1, each of the
.Fa count
threads will be allocated to a different
CPU among all available CPUs in a round robin fashion.
The taskqueue specified by
.Fa tqp
must be created previously by calling
.Fn taskqueue_create
with the argument
.Fa enqueue
set to
.Fa taskqueue_thread_enqueue .
.Pp
A convenience macro,
.Fn TASK_INIT
is provided to initialise a
.Vt task
structure.
The values of
.Fa priority ,
.Fa func ,
and
.Fa context
are simply copied into the task structure fields and the
.Fa ta_pending
field is cleared.
.Pp
Two macros,
.Fn TASKQUEUE_DECLARE
and
.Fn TASKQUEUE_DEFINE
are used to declare a reference to a global queue,
and to define the implementation of the queue.
The
.Fn TASKQUEUE_DEFINE
macro arranges to call
.Fn taskqueue_create
with the values of its
.Fa name ,
.Fa enqueue
and
.Fa context
arguments during system initialisation.
After calling
.Fn taskqueue_create ,
the
.Fa init
argument to the macro is executed as a C statement,
allowing any further initialisation to be performed
(such as registering an interrupt handler etc.)
.Pp
The system provides two global taskqueues,
.Va taskqueue_swi
and
.Va taskqueue_swi_mp ,
which are run via a software interrupt mechanism.
To use these queues, call
.Fn taskqueue_enqueue
with the value of the global variable
.Va taskqueue_swi
or
.Va taskqueue_swi_mp .
.Pp
While
.Va taskqueue_swi
acquires the mplock for its tasks,
.Va taskqueue_swi_mp
is intended for mpsafe tasks and no mplock will be acquired for them.
These queues can be used,
for instance, for implementing interrupt handlers which must perform a
significant amount of processing in the handler.
The hardware interrupt handler would perform minimal processing of the
interrupt and then enqueue a task to finish the work.
This reduces to a minimum
the amount of time spent with interrupts disabled.
.\".Sh SEE ALSO
.\".Xr ithread 9 ,
.\".Xr kthread 9 ,
.\".Xr swi 9
.Sh HISTORY
This interface first appeared in
.Fx 5.0 .
There is a similar facility called work_queue in the Linux kernel.
.Sh AUTHORS
This manual page was written by
.An Doug Rabson .