Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
TASKQUEUE(9)	       FreeBSD Kernel Developer's Manual	  TASKQUEUE(9)

NAME
     taskqueue -- asynchronous task execution

SYNOPSIS
     #include <sys/param.h>
     #include <sys/kernel.h>
     #include <sys/malloc.h>
     #include <sys/queue.h>
     #include <sys/taskqueue.h>

     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 */
	     u_short		     ta_pending;     /*	count times queued */
	     u_short		     ta_priority;    /*	priority of task in queue */
	     task_fn_t		     ta_func;	     /*	task handler */
	     void		     *ta_context;    /*	argument for handler */
     };

     enum taskqueue_callback_type {
	     TASKQUEUE_CALLBACK_TYPE_INIT,
	     TASKQUEUE_CALLBACK_TYPE_SHUTDOWN,
     };

     typedef void (*taskqueue_callback_fn)(void	*context);

     struct timeout_task;

     struct taskqueue *
     taskqueue_create(const char *name,	int mflags,
	 taskqueue_enqueue_fn enqueue, void *context);

     struct taskqueue *
     taskqueue_create_fast(const char *name, int mflags,
	 taskqueue_enqueue_fn enqueue, void *context);

     int
     taskqueue_start_threads(struct taskqueue **tqp, int count,	int pri,
	 const char *name, ...);

     int
     taskqueue_start_threads_pinned(struct taskqueue **tqp, int	count,
	 int pri, int cpu_id, const char *name,	...);

     void
     taskqueue_set_callback(struct taskqueue *queue,
	 enum taskqueue_callback_type cb_type, taskqueue_callback_fn callback,
	 void *context);

     void
     taskqueue_free(struct taskqueue *queue);

     int
     taskqueue_enqueue(struct taskqueue	*queue,	struct task *task);

     int
     taskqueue_enqueue_timeout(struct taskqueue	*queue,
	 struct	timeout_task *timeout_task, int	ticks);

     int
     taskqueue_enqueue_timeout_sbt(struct taskqueue *queue,
	 struct	timeout_task *timeout_task, sbintime_t sbt, sbintime_t pr,
	 int flags);

     int
     taskqueue_cancel(struct taskqueue *queue, struct task *task,
	 u_int *pendp);

     int
     taskqueue_cancel_timeout(struct taskqueue *queue,
	 struct	timeout_task *timeout_task, u_int *pendp);

     void
     taskqueue_drain(struct taskqueue *queue, struct task *task);

     void
     taskqueue_drain_timeout(struct taskqueue *queue,
	 struct	timeout_task *timeout_task);

     void
     taskqueue_drain_all(struct	taskqueue *queue);

     void
     taskqueue_block(struct taskqueue *queue);

     void
     taskqueue_unblock(struct taskqueue	*queue);

     int
     taskqueue_member(struct taskqueue *queue, struct thread *td);

     void
     taskqueue_run(struct taskqueue *queue);

     TASK_INIT(struct task *task, int priority,	task_fn_t func,
	 void *context);

     TASK_INITIALIZER(int priority, task_fn_t func, void *context);

     TASKQUEUE_DECLARE(name);

     TASKQUEUE_DEFINE(name, taskqueue_enqueue_fn enqueue, void *context,
	 init);

     TASKQUEUE_FAST_DEFINE(name, taskqueue_enqueue_fn enqueue, void *context,
	 init);

     TASKQUEUE_DEFINE_THREAD(name);

     TASKQUEUE_FAST_DEFINE_THREAD(name);

     TIMEOUT_TASK_INIT(struct taskqueue	*queue,
	 struct	timeout_task *timeout_task, int	priority, task_fn_t func,
	 void *context);

DESCRIPTION
     These functions provide a simple interface	for asynchronous execution of
     code.

     The function taskqueue_create() is	used to	create new queues.  The	argu-
     ments to taskqueue_create() include a name	that should be unique, a set
     of	malloc(9) flags	that specify whether the call to malloc() is allowed
     to	sleep, a function that is called from taskqueue_enqueue() when a task
     is	added to the queue, and	a pointer to the memory	location where the
     identity of the thread that services the queue is recorded.  The function
     called from taskqueue_enqueue() must arrange for the queue	to be pro-
     cessed (for instance by scheduling	a software interrupt or	waking a ker-
     nel thread).  The memory location where the thread	identity is recorded
     is	used to	signal the service thread(s) to	terminate--when	this value is
     set to zero and the thread	is signaled it will terminate.	If the queue
     is	intended for use in fast interrupt handlers taskqueue_create_fast()
     should be used in place of	taskqueue_create().

     The function taskqueue_free() should be used to free the memory used by
     the queue.	 Any tasks that	are on the queue will be executed at this time
     after which the thread servicing the queue	will be	signaled that it
     should exit.

     Once a taskqueue has been created,	its threads should be started using
     taskqueue_start_threads() or taskqueue_start_threads_pinned().
     taskqueue_start_threads_pinned() takes a cpu_id argument which will cause
     the threads which are started for the taskqueue to	be pinned to run on
     the given CPU.  Callbacks may optionally be registered using
     taskqueue_set_callback().	Currently, callbacks may be registered for the
     following purposes:

     TASKQUEUE_CALLBACK_TYPE_INIT      This callback is	called by every	thread
				       in the taskqueue, before	it executes
				       any tasks.  This	callback must be set
				       before the taskqueue's threads are
				       started.

     TASKQUEUE_CALLBACK_TYPE_SHUTDOWN  This callback is	called by every	thread
				       in the taskqueue, after it executes its
				       last task.  This	callback will always
				       be called before	the taskqueue struc-
				       ture is reclaimed.

     To	add a task to the list of tasks	queued on a taskqueue, call
     taskqueue_enqueue() with pointers to the queue and	task.  If the task's
     ta_pending	field is non-zero, then	it is simply incremented to reflect
     the number	of times the task was enqueued,	up to a	cap of USHRT_MAX.
     Otherwise,	the task is added to the list before the first task which has
     a lower 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 EPIPE	if the queue is	being freed.

     When a task is executed, first it is removed from the queue, the value of
     ta_pending	is recorded and	then the field is zeroed.  The function
     ta_func from the task structure is	called with the	value of the field
     ta_context	as its first argument and the value of ta_pending as its sec-
     ond argument.  After the function ta_func returns,	wakeup(9) is called on
     the task pointer passed to	taskqueue_enqueue().

     The taskqueue_enqueue_timeout() function is used to schedule the enqueue
     after the specified number	of ticks.  The taskqueue_enqueue_timeout_sbt()
     function provides finer control over the scheduling based on sbt, pr, and
     flags, as detailed	in timeout(9).	Only non-fast task queues can be used
     for timeout_task scheduling.  If the 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 ticks
     is	passed.	 This function returns -1 if the task is being drained.	 Oth-
     erwise, the number	of pending calls is returned.

     The taskqueue_cancel() function is	used to	cancel a task.	The ta_pending
     count is cleared, and the old value returned in the reference parameter
     pendp, if it is non-NULL.	If the task is currently running, EBUSY	is
     returned, otherwise 0.  To	implement a blocking taskqueue_cancel()	that
     waits for a running task to finish, it could look like:

	   while (taskqueue_cancel(tq, task, NULL) != 0)
		   taskqueue_drain(tq, task);

     Note that,	as with	taskqueue_drain(), the caller is responsible for
     ensuring that the task is not re-enqueued after being canceled.

     Similarly,	the taskqueue_cancel_timeout() function	is used	to cancel the
     scheduled task execution.

     The taskqueue_drain() function is used to wait for	the task to finish,
     and the taskqueue_drain_timeout() function	is used	to wait	for the	sched-
     uled task to finish.  There is no guarantee that the task will not	be
     enqueued after call to taskqueue_drain().	If the caller wants to put the
     task into a known state, then before calling taskqueue_drain() the	caller
     should use	out-of-band means to ensure that the task would	not be
     enqueued.	For example, if	the task is enqueued by	an interrupt filter,
     then the interrupt	could be disabled.

     The taskqueue_drain_all() function	is used	to wait	for all	pending	and
     running tasks that	are enqueued on	the taskqueue to finish.  Tasks	posted
     to	the taskqueue after taskqueue_drain_all() begins processing, including
     pending enqueues scheduled	by a previous call to
     taskqueue_enqueue_timeout(), do not extend	the wait time of
     taskqueue_drain_all() and may complete after taskqueue_drain_all()
     returns.

     The taskqueue_block() function blocks the taskqueue.  It prevents any
     enqueued but not running tasks from being executed.  Future calls to
     taskqueue_enqueue() will enqueue tasks, but the tasks will	not be run
     until taskqueue_unblock() is called.  Please note that taskqueue_block()
     does not wait for any currently running tasks to finish.  Thus, the
     taskqueue_block() does not	provide	a guarantee that taskqueue_run() is
     not running after taskqueue_block() returns, but it does provide a	guar-
     antee that	taskqueue_run()	will not be called again until
     taskqueue_unblock() is called.  If	the caller requires a guarantee	that
     taskqueue_run() is	not running, then this must be arranged	by the caller.
     Note that if taskqueue_drain() is called on a task	that is	enqueued on a
     taskqueue that is blocked by taskqueue_block(), then taskqueue_drain()
     can not return until the taskqueue	is unblocked.  This can	result in a
     deadlock if the thread blocked in taskqueue_drain() is the	thread that is
     supposed to call taskqueue_unblock().  Thus, use of taskqueue_drain()
     after taskqueue_block() is	discouraged, because the state of the task can
     not be known in advance.  The same	caveat applies to
     taskqueue_drain_all().

     The taskqueue_unblock() function unblocks the previously blocked
     taskqueue.	 All enqueued tasks can	be run after this call.

     The taskqueue_member() function returns 1 if the given thread td is part
     of	the given taskqueue queue and 0	otherwise.

     The taskqueue_run() function will run all pending tasks in	the specified
     queue.  Normally this function is only used internally.

     A convenience macro, TASK_INIT(task, priority, func, context) is provided
     to	initialise a task structure.  The TASK_INITIALIZER() macro generates
     an	initializer for	a task structure.  A macro TIMEOUT_TASK_INIT(queue,
     timeout_task, priority, func, context) initializes	the timeout_task
     structure.	 The values of priority, func, and context are simply copied
     into the task structure fields and	the ta_pending field is	cleared.

     Five macros TASKQUEUE_DECLARE(name), TASKQUEUE_DEFINE(name, enqueue,
     context, init), TASKQUEUE_FAST_DEFINE(name, enqueue, context, init), and
     TASKQUEUE_DEFINE_THREAD(name) TASKQUEUE_FAST_DEFINE_THREAD(name) are used
     to	declare	a reference to a global	queue, to define the implementation of
     the queue,	and declare a queue that uses its own thread.  The
     TASKQUEUE_DEFINE()	macro arranges to call taskqueue_create() with the
     values of its name, enqueue and context arguments during system initiali-
     sation.  After calling taskqueue_create(),	the 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.)

     The TASKQUEUE_DEFINE_THREAD() macro defines a new taskqueue with its own
     kernel thread to serve tasks.  The	variable struct	taskqueue
     *taskqueue_name is	used to	enqueue	tasks onto the queue.

     TASKQUEUE_FAST_DEFINE() and TASKQUEUE_FAST_DEFINE_THREAD()	act just like
     TASKQUEUE_DEFINE()	and TASKQUEUE_DEFINE_THREAD() respectively but
     taskqueue is created with taskqueue_create_fast().

   Predefined Task Queues
     The system	provides four global taskqueues, taskqueue_fast,
     taskqueue_swi, taskqueue_swi_giant, and taskqueue_thread.	The
     taskqueue_fast queue is for swi handlers dispatched from fast interrupt
     handlers, where sleep mutexes cannot be used.  The	swi taskqueues are run
     via a software interrupt mechanism.  The taskqueue_swi queue runs without
     the protection of the Giant kernel	lock, and the taskqueue_swi_giant
     queue runs	with the protection of the Giant kernel	lock.  The thread
     taskqueue taskqueue_thread	runs in	a kernel thread	context, and tasks run
     from this thread do not run under the Giant kernel	lock.  If the caller
     wants to run under	Giant, he should explicitly acquire and	release	Giant
     in	his taskqueue handler routine.

     To	use these queues, call taskqueue_enqueue() with	the value of the
     global taskqueue variable for the queue you wish to use.

     The software interrupt 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	dis-
     abled.

     The thread	queue can be used, for instance, by interrupt level routines
     that need to call kernel functions	that do	things that can	only be	done
     from a thread context.  (e.g., call malloc	with the M_WAITOK flag.)

     Note that tasks queued on shared taskqueues such as taskqueue_swi may be
     delayed an	indeterminate amount of	time before execution.	If queueing
     delays cannot be tolerated	then a private taskqueue should	be created
     with a dedicated processing thread.

SEE ALSO
     ithread(9), kthread(9), swi(9) timeout(9)

HISTORY
     This interface first appeared in FreeBSD 5.0.  There is a similar facil-
     ity called	work_queue in the Linux	kernel.

AUTHORS
     This manual page was written by Doug Rabson.

FreeBSD	11.2			 July 30, 2017			  FreeBSD 11.2

NAME | SYNOPSIS | DESCRIPTION | SEE ALSO | HISTORY | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=taskqueue&manpath=FreeBSD+11.2-RELEASE+and+Ports>

home | help