ddi_taskq_create man page on SmartOS

Man page or keyword search:  
man Server   16655 pages
apropos Keyword Search (all sections)
Output format
SmartOS logo
[printable version]

TASKQ(9F)							     TASKQ(9F)

       taskq,	 ddi_taskq_create,    ddi_taskq_destroy,   ddi_taskq_dispatch,
       ddi_taskq_wait, ddi_taskq_suspend, taskq_suspended, ddi_taskq_resume  -
       Kernel task queue operations

       #include <sys/sunddi.h>

       ddi_taskq_t *ddi_taskq_create(dev_info_t *dip, const char *name,
	    int nthreads, pri_t	 pri, uint_t  cflags);

       void ddi_taskq_destroy(ddi_taskq_t *tq);

       int ddi_taskq_dispatch(ddi_taskq_t *tq, void (* func)(void *),
	    void *arg, uint_t dflags);

       void ddi_taskq_wait(ddi_taskq_t *tq);

       void ddi_taskq_suspend(ddi_taskq_t *tq);

       boolean_t ddi_taskq_suspended(ddi_taskq_t *tq);

       void ddi_taskq_resume(ddi_taskq_t *tq);

       Solaris DDI specific (Solaris DDI)

		   Pointer to the device's dev_info structure. May be NULL for
		   kernel modules that do  not	have  an  associated  dev_info

		   Descriptive	string.	 Only  alphanumeric  characters can be
		   used		   in name and spaces  are  not	 allowed.  The
		   name should be unique.

		   Number  of  threads servicing the task queue. Note that the
		   request ordering is guaranteed (tasks are processed in  the
		   order scheduled) if the taskq is created with a single ser‐
		   vicing thread.

		   Priority of threads servicing the task queue.  Drivers  and
		   modules should specify TASKQ_DEFAULTPRI.

		   Should pass 0 as flags.

		   Callback function to call.

		   Argument to the callback function.

		   Possible dflags are:

				  Allow	 sleeping  (blocking)  until memory is

				  Return DDI_FAILURE immediately if memory  is
				  not  available.

		   Pointer to a task queue (ddi_taskq_t *).

		   Pointer to a thread structure.

       A  kernel  task	queue  is a mechanism for general-purpose asynchronous
       task scheduling that enables tasks to be performed at a later  time  by
       another thread. There are several reasons why you may utilize asynchro‐
       nous task scheduling:

	   1.	  You have a task that isn't time-critical, but a current code
		  path that is.

	   2.	  You  have  a	task  that  may	 require grabbing locks that a
		  thread already holds.

	   3.	  You have a task that needs to block (for  example,  to  wait
		  for  memory),	 but  a have a thread that cannot block in its
		  current context.

	   4.	  You have a code path that can't complete because of  a  spe‐
		  cific condition, but also can't sleep or fail. In this case,
		  the task is immediately queued and then  is  executed	 after
		  the condition disappears.

	   5.	  A  task  queue is just a simple way to launch multiple tasks
		  in parallel.

       A task queue consists of a list of tasks, together  with	 one  or  more
       threads	to  service  the  list.	 If  a task queue has a single service
       thread, all tasks are guaranteed to execute in the order they were dis‐
       patched.	 Otherwise  they can be executed in any order. Note that since
       tasks are placed on a list, execution of one task and should not depend
       on  the execution of another task or a deadlock may occur. A taskq cre‐
       ated with a single servicing thread guarantees that all the  tasks  are
       serviced in the order in which they are scheduled.

       The ddi_taskq_create() function creates a task queue instance.

       The  ddi_taskq_dispatch()  function  places taskq on the list for later
       execution. The dflag argument specifies whether	it  is	allowed	 sleep
       waiting	 for memory. DDI_SLEEP dispatches can sleep and are guaranteed
       to succeed. DDI_NOSLEEP dispatches are guaranteed not to sleep but  may
       fail (return DDI_FAILURE) if resources are not available.

       The  ddi_taskq_destroy() function waits for any scheduled tasks to com‐
       plete, then destroys the taskq. The caller should guarantee that no new
       tasks are scheduled for the closing taskq.

       The  ddi_taskq_wait() function waits for all previously scheduled tasks
       to complete. Note that this function does not stop any  new  task  dis‐

       The  ddi_taskq_suspend()	 function  suspends  all  task execution until
       ddi_taskq_resume() is called. Although ddi_taskq_suspend() attempts  to
       suspend	pending	 tasks, there are no guarantees that they will be sus‐
       pended.	 The  only  guarantee  is  that	 all  tasks  dispatched	 after
       ddi_taskq_suspend()  will  not  be  executed. Because it will trigger a
       deadlock, the ddi_taskq_suspend() function should never be called by  a
       task executing on a taskq.

       The  ddi_taskq_suspended()  function  returns  B_TRUE  if taskq is sus‐
       pended, and B_FALSE otherwise. It is intended to ASSERT that  the  task
       queue is suspended.

       The ddi_taskq_resume() function resumes task queue execution.

       The  ddi_taskq_create()	function creates an opaque handle that is used
       for all other taskq operations. It returns a taskq pointer  on  success
       and NULL on failure.

       The  ddi_taskq_dispatch() function returns DDI_FAILURE if it can't dis‐
       patch a task and returns DDI_SUCCESS if dispatch succeeded.

       The ddi_taskq_suspended() function returns  B_TRUE  if  taskq  is  sus‐
       pended. Otherwise B_FALSE is returned.

       All functions may be called from the user or kernel contexts.

       Addtionally,  the  ddi_taskq_dispatch  function	may be called from the
       interrupt context only if the DDI_NOSLEEP flag is set.

				  Mar 1, 2005			     TASKQ(9F)

List of man pages available for SmartOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net