2000-05-28 15:45:30 +00:00
|
|
|
/*-
|
2017-11-27 15:20:12 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
|
|
*
|
2000-05-28 15:45:30 +00:00
|
|
|
* Copyright (c) 2000 Doug Rabson
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* 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 AUTHOR AND CONTRIBUTORS ``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 AUTHOR OR CONTRIBUTORS 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.
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2001-10-26 06:32:21 +00:00
|
|
|
#include <sys/bus.h>
|
2014-05-24 20:37:15 +00:00
|
|
|
#include <sys/cpuset.h>
|
2001-10-26 18:46:48 +00:00
|
|
|
#include <sys/interrupt.h>
|
2000-05-28 15:45:30 +00:00
|
|
|
#include <sys/kernel.h>
|
2003-12-17 21:13:04 +00:00
|
|
|
#include <sys/kthread.h>
|
2016-05-18 04:35:58 +00:00
|
|
|
#include <sys/libkern.h>
|
2011-09-15 08:42:06 +00:00
|
|
|
#include <sys/limits.h>
|
2001-10-26 06:32:21 +00:00
|
|
|
#include <sys/lock.h>
|
2000-05-28 15:45:30 +00:00
|
|
|
#include <sys/malloc.h>
|
2001-10-26 06:32:21 +00:00
|
|
|
#include <sys/mutex.h>
|
2005-05-01 00:38:11 +00:00
|
|
|
#include <sys/proc.h>
|
2006-01-14 01:55:24 +00:00
|
|
|
#include <sys/sched.h>
|
2016-05-18 04:35:58 +00:00
|
|
|
#include <sys/smp.h>
|
2001-10-26 06:32:21 +00:00
|
|
|
#include <sys/taskqueue.h>
|
Move dynamic sysctl(8) variable creation for the cd(4) and da(4) drivers
out of cdregister() and daregister(), which are run from interrupt context.
The sysctl code does blocking mallocs (M_WAITOK), which causes problems
if malloc(9) actually needs to sleep.
The eventual fix for this issue will involve moving the CAM probe process
inside a kernel thread. For now, though, I have fixed the issue by moving
dynamic sysctl variable creation for these two drivers to a task queue
running in a kernel thread.
The existing task queues (taskqueue_swi and taskqueue_swi_giant) run in
software interrupt handlers, which wouldn't fix the problem at hand. So I
have created a new task queue, taskqueue_thread, that runs inside a kernel
thread. (It also runs outside of Giant -- clients must explicitly acquire
and release Giant in their taskqueue functions.)
scsi_cd.c: Remove sysctl variable creation code from cdregister(), and
move it to a new function, cdsysctlinit(). Queue
cdsysctlinit() to the taskqueue_thread taskqueue once we
have fully registered the cd(4) driver instance.
scsi_da.c: Remove sysctl variable creation code from daregister(), and
move it to move it to a new function, dasysctlinit().
Queue dasysctlinit() to the taskqueue_thread taskqueue once
we have fully registered the da(4) instance.
taskqueue.h: Declare the new taskqueue_thread taskqueue, update some
comments.
subr_taskqueue.c:
Create the new kernel thread taskqueue. This taskqueue
runs outside of Giant, so any functions queued to it would
need to explicitly acquire/release Giant if they need it.
cd.4: Update the cd(4) man page to talk about the minimum command
size sysctl/loader tunable. Also note that the changer
variables are available as loader tunables as well.
da.4: Update the da(4) man page to cover the retry_count,
default_timeout and minimum_cmd_size sysctl variables/loader
tunables. Remove references to /dev/r???, they aren't used
any longer.
cd.9: Update the cd(9) man page to describe the CD_Q_10_BYTE_ONLY
quirk.
taskqueue.9: Update the taskqueue(9) man page to describe the new thread
task queue, and the taskqueue_swi_giant queue.
MFC after: 3 days
2003-09-03 04:46:28 +00:00
|
|
|
#include <sys/unistd.h>
|
2006-01-14 01:55:24 +00:00
|
|
|
#include <machine/stdarg.h>
|
2000-05-28 15:45:30 +00:00
|
|
|
|
2000-12-08 20:09:00 +00:00
|
|
|
static MALLOC_DEFINE(M_TASKQUEUE, "taskqueue", "Task Queues");
|
2003-02-26 03:15:42 +00:00
|
|
|
static void *taskqueue_giant_ih;
|
2003-12-17 21:13:04 +00:00
|
|
|
static void *taskqueue_ih;
|
2013-10-16 09:52:59 +00:00
|
|
|
static void taskqueue_fast_enqueue(void *);
|
|
|
|
static void taskqueue_swi_enqueue(void *);
|
|
|
|
static void taskqueue_swi_giant_enqueue(void *);
|
2000-10-25 05:19:40 +00:00
|
|
|
|
2010-10-13 22:59:04 +00:00
|
|
|
struct taskqueue_busy {
|
|
|
|
struct task *tb_running;
|
|
|
|
TAILQ_ENTRY(taskqueue_busy) tb_link;
|
|
|
|
};
|
|
|
|
|
2015-01-04 19:55:44 +00:00
|
|
|
struct task * const TB_DRAIN_WAITER = (struct task *)0x1;
|
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
struct taskqueue {
|
|
|
|
STAILQ_HEAD(, task) tq_queue;
|
|
|
|
taskqueue_enqueue_fn tq_enqueue;
|
|
|
|
void *tq_context;
|
2016-05-18 04:35:58 +00:00
|
|
|
char *tq_name;
|
2010-10-13 22:59:04 +00:00
|
|
|
TAILQ_HEAD(, taskqueue_busy) tq_active;
|
2001-10-26 06:32:21 +00:00
|
|
|
struct mtx tq_mutex;
|
2008-04-08 17:48:02 +00:00
|
|
|
struct thread **tq_threads;
|
|
|
|
int tq_tcount;
|
2008-07-18 07:10:33 +00:00
|
|
|
int tq_spin;
|
2006-01-14 01:55:24 +00:00
|
|
|
int tq_flags;
|
2011-04-26 11:39:56 +00:00
|
|
|
int tq_callouts;
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
taskqueue_callback_fn tq_callbacks[TASKQUEUE_NUM_CALLBACKS];
|
|
|
|
void *tq_cb_contexts[TASKQUEUE_NUM_CALLBACKS];
|
2000-05-28 15:45:30 +00:00
|
|
|
};
|
|
|
|
|
2006-01-14 01:55:24 +00:00
|
|
|
#define TQ_FLAGS_ACTIVE (1 << 0)
|
2008-03-25 22:38:45 +00:00
|
|
|
#define TQ_FLAGS_BLOCKED (1 << 1)
|
2013-10-16 09:52:59 +00:00
|
|
|
#define TQ_FLAGS_UNLOCKED_ENQUEUE (1 << 2)
|
2006-01-14 01:55:24 +00:00
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
#define DT_CALLOUT_ARMED (1 << 0)
|
2016-09-29 10:38:20 +00:00
|
|
|
#define DT_DRAIN_IN_PROGRESS (1 << 1)
|
2011-04-26 11:39:56 +00:00
|
|
|
|
2010-11-08 22:12:25 +00:00
|
|
|
#define TQ_LOCK(tq) \
|
|
|
|
do { \
|
|
|
|
if ((tq)->tq_spin) \
|
|
|
|
mtx_lock_spin(&(tq)->tq_mutex); \
|
|
|
|
else \
|
|
|
|
mtx_lock(&(tq)->tq_mutex); \
|
|
|
|
} while (0)
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
#define TQ_ASSERT_LOCKED(tq) mtx_assert(&(tq)->tq_mutex, MA_OWNED)
|
2008-07-18 07:10:33 +00:00
|
|
|
|
2010-11-08 22:12:25 +00:00
|
|
|
#define TQ_UNLOCK(tq) \
|
|
|
|
do { \
|
|
|
|
if ((tq)->tq_spin) \
|
|
|
|
mtx_unlock_spin(&(tq)->tq_mutex); \
|
|
|
|
else \
|
|
|
|
mtx_unlock(&(tq)->tq_mutex); \
|
|
|
|
} while (0)
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
#define TQ_ASSERT_UNLOCKED(tq) mtx_assert(&(tq)->tq_mutex, MA_NOTOWNED)
|
2006-01-10 06:31:12 +00:00
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
void
|
|
|
|
_timeout_task_init(struct taskqueue *queue, struct timeout_task *timeout_task,
|
|
|
|
int priority, task_fn_t func, void *context)
|
|
|
|
{
|
|
|
|
|
|
|
|
TASK_INIT(&timeout_task->t, priority, func, context);
|
2013-10-16 09:52:59 +00:00
|
|
|
callout_init_mtx(&timeout_task->c, &queue->tq_mutex,
|
|
|
|
CALLOUT_RETURNUNLOCKED);
|
2011-04-26 11:39:56 +00:00
|
|
|
timeout_task->q = queue;
|
|
|
|
timeout_task->f = 0;
|
|
|
|
}
|
|
|
|
|
2006-01-10 06:31:12 +00:00
|
|
|
static __inline int
|
|
|
|
TQ_SLEEP(struct taskqueue *tq, void *p, struct mtx *m, int pri, const char *wm,
|
|
|
|
int t)
|
|
|
|
{
|
2008-07-18 07:10:33 +00:00
|
|
|
if (tq->tq_spin)
|
2006-01-10 06:31:12 +00:00
|
|
|
return (msleep_spin(p, m, wm, t));
|
|
|
|
return (msleep(p, m, pri, wm, t));
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct taskqueue *
|
2016-05-18 04:35:58 +00:00
|
|
|
_taskqueue_create(const char *name, int mflags,
|
2005-05-01 00:38:11 +00:00
|
|
|
taskqueue_enqueue_fn enqueue, void *context,
|
2016-05-18 04:35:58 +00:00
|
|
|
int mtxflags, const char *mtxname __unused)
|
2000-05-28 15:45:30 +00:00
|
|
|
{
|
|
|
|
struct taskqueue *queue;
|
2016-05-19 17:14:24 +00:00
|
|
|
char *tq_name;
|
2016-05-18 04:35:58 +00:00
|
|
|
|
2016-05-19 17:14:24 +00:00
|
|
|
tq_name = malloc(TASKQUEUE_NAMELEN, M_TASKQUEUE, mflags | M_ZERO);
|
2016-06-02 15:52:34 +00:00
|
|
|
if (tq_name == NULL)
|
2016-05-19 17:14:24 +00:00
|
|
|
return (NULL);
|
|
|
|
|
2001-10-26 06:32:21 +00:00
|
|
|
queue = malloc(sizeof(struct taskqueue), M_TASKQUEUE, mflags | M_ZERO);
|
2016-06-02 15:52:34 +00:00
|
|
|
if (queue == NULL) {
|
|
|
|
free(tq_name, M_TASKQUEUE);
|
2016-05-19 17:14:24 +00:00
|
|
|
return (NULL);
|
2016-06-02 15:52:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(tq_name, TASKQUEUE_NAMELEN, "%s", (name) ? name : "taskqueue");
|
2008-07-18 07:10:33 +00:00
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
STAILQ_INIT(&queue->tq_queue);
|
2010-10-13 22:59:04 +00:00
|
|
|
TAILQ_INIT(&queue->tq_active);
|
2000-05-28 15:45:30 +00:00
|
|
|
queue->tq_enqueue = enqueue;
|
|
|
|
queue->tq_context = context;
|
2016-05-18 04:35:58 +00:00
|
|
|
queue->tq_name = tq_name;
|
2008-07-18 07:10:33 +00:00
|
|
|
queue->tq_spin = (mtxflags & MTX_SPIN) != 0;
|
|
|
|
queue->tq_flags |= TQ_FLAGS_ACTIVE;
|
2013-10-16 09:52:59 +00:00
|
|
|
if (enqueue == taskqueue_fast_enqueue ||
|
|
|
|
enqueue == taskqueue_swi_enqueue ||
|
|
|
|
enqueue == taskqueue_swi_giant_enqueue ||
|
|
|
|
enqueue == taskqueue_thread_enqueue)
|
|
|
|
queue->tq_flags |= TQ_FLAGS_UNLOCKED_ENQUEUE;
|
2016-05-18 04:35:58 +00:00
|
|
|
mtx_init(&queue->tq_mutex, tq_name, NULL, mtxflags);
|
2000-05-28 15:45:30 +00:00
|
|
|
|
2016-05-19 17:14:24 +00:00
|
|
|
return (queue);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
2006-01-10 06:31:12 +00:00
|
|
|
struct taskqueue *
|
|
|
|
taskqueue_create(const char *name, int mflags,
|
2006-01-14 01:55:24 +00:00
|
|
|
taskqueue_enqueue_fn enqueue, void *context)
|
2006-01-10 06:31:12 +00:00
|
|
|
{
|
2016-05-18 04:35:58 +00:00
|
|
|
|
2006-01-14 01:55:24 +00:00
|
|
|
return _taskqueue_create(name, mflags, enqueue, context,
|
2016-05-18 04:35:58 +00:00
|
|
|
MTX_DEF, name);
|
2006-01-10 06:31:12 +00:00
|
|
|
}
|
|
|
|
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
void
|
|
|
|
taskqueue_set_callback(struct taskqueue *queue,
|
|
|
|
enum taskqueue_callback_type cb_type, taskqueue_callback_fn callback,
|
|
|
|
void *context)
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT(((cb_type >= TASKQUEUE_CALLBACK_TYPE_MIN) &&
|
|
|
|
(cb_type <= TASKQUEUE_CALLBACK_TYPE_MAX)),
|
|
|
|
("Callback type %d not valid, must be %d-%d", cb_type,
|
|
|
|
TASKQUEUE_CALLBACK_TYPE_MIN, TASKQUEUE_CALLBACK_TYPE_MAX));
|
|
|
|
KASSERT((queue->tq_callbacks[cb_type] == NULL),
|
|
|
|
("Re-initialization of taskqueue callback?"));
|
|
|
|
|
|
|
|
queue->tq_callbacks[cb_type] = callback;
|
|
|
|
queue->tq_cb_contexts[cb_type] = context;
|
|
|
|
}
|
|
|
|
|
2005-05-01 00:38:11 +00:00
|
|
|
/*
|
|
|
|
* Signal a taskqueue thread to terminate.
|
|
|
|
*/
|
|
|
|
static void
|
2008-04-08 17:48:02 +00:00
|
|
|
taskqueue_terminate(struct thread **pp, struct taskqueue *tq)
|
2005-05-01 00:38:11 +00:00
|
|
|
{
|
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
while (tq->tq_tcount > 0 || tq->tq_callouts > 0) {
|
2006-01-14 01:55:24 +00:00
|
|
|
wakeup(tq);
|
|
|
|
TQ_SLEEP(tq, pp, &tq->tq_mutex, PWAIT, "taskqueue_destroy", 0);
|
2005-05-01 00:38:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
void
|
|
|
|
taskqueue_free(struct taskqueue *queue)
|
|
|
|
{
|
2001-10-26 06:32:21 +00:00
|
|
|
|
2006-01-10 06:31:12 +00:00
|
|
|
TQ_LOCK(queue);
|
2006-01-14 01:55:24 +00:00
|
|
|
queue->tq_flags &= ~TQ_FLAGS_ACTIVE;
|
2008-04-08 17:48:02 +00:00
|
|
|
taskqueue_terminate(queue->tq_threads, queue);
|
2010-10-13 22:59:04 +00:00
|
|
|
KASSERT(TAILQ_EMPTY(&queue->tq_active), ("Tasks still running?"));
|
2011-04-26 11:39:56 +00:00
|
|
|
KASSERT(queue->tq_callouts == 0, ("Armed timeout tasks"));
|
2001-10-26 06:32:21 +00:00
|
|
|
mtx_destroy(&queue->tq_mutex);
|
2008-04-08 17:48:02 +00:00
|
|
|
free(queue->tq_threads, M_TASKQUEUE);
|
2016-05-18 04:35:58 +00:00
|
|
|
free(queue->tq_name, M_TASKQUEUE);
|
2000-05-28 15:45:30 +00:00
|
|
|
free(queue, M_TASKQUEUE);
|
|
|
|
}
|
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
static int
|
|
|
|
taskqueue_enqueue_locked(struct taskqueue *queue, struct task *task)
|
2000-05-28 15:45:30 +00:00
|
|
|
{
|
|
|
|
struct task *ins;
|
|
|
|
struct task *prev;
|
|
|
|
|
2016-05-18 04:35:58 +00:00
|
|
|
KASSERT(task->ta_func != NULL, ("enqueueing task with NULL func"));
|
2000-05-28 15:45:30 +00:00
|
|
|
/*
|
|
|
|
* Count multiple enqueues.
|
|
|
|
*/
|
2008-07-18 07:10:33 +00:00
|
|
|
if (task->ta_pending) {
|
2016-05-21 14:51:49 +00:00
|
|
|
if (task->ta_pending < USHRT_MAX)
|
2011-09-15 08:42:06 +00:00
|
|
|
task->ta_pending++;
|
2013-10-16 09:52:59 +00:00
|
|
|
TQ_UNLOCK(queue);
|
2011-04-26 11:39:56 +00:00
|
|
|
return (0);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Optimise the case when all tasks have the same priority.
|
|
|
|
*/
|
2000-08-03 16:37:46 +00:00
|
|
|
prev = STAILQ_LAST(&queue->tq_queue, task, ta_link);
|
2000-05-28 15:45:30 +00:00
|
|
|
if (!prev || prev->ta_priority >= task->ta_priority) {
|
|
|
|
STAILQ_INSERT_TAIL(&queue->tq_queue, task, ta_link);
|
|
|
|
} else {
|
2009-02-03 07:51:41 +00:00
|
|
|
prev = NULL;
|
2000-05-28 15:45:30 +00:00
|
|
|
for (ins = STAILQ_FIRST(&queue->tq_queue); ins;
|
|
|
|
prev = ins, ins = STAILQ_NEXT(ins, ta_link))
|
|
|
|
if (ins->ta_priority < task->ta_priority)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (prev)
|
|
|
|
STAILQ_INSERT_AFTER(&queue->tq_queue, prev, task, ta_link);
|
|
|
|
else
|
|
|
|
STAILQ_INSERT_HEAD(&queue->tq_queue, task, ta_link);
|
|
|
|
}
|
|
|
|
|
|
|
|
task->ta_pending = 1;
|
2013-10-16 09:52:59 +00:00
|
|
|
if ((queue->tq_flags & TQ_FLAGS_UNLOCKED_ENQUEUE) != 0)
|
|
|
|
TQ_UNLOCK(queue);
|
2008-07-18 07:10:33 +00:00
|
|
|
if ((queue->tq_flags & TQ_FLAGS_BLOCKED) == 0)
|
2008-03-25 22:38:45 +00:00
|
|
|
queue->tq_enqueue(queue->tq_context);
|
2013-10-16 09:52:59 +00:00
|
|
|
if ((queue->tq_flags & TQ_FLAGS_UNLOCKED_ENQUEUE) == 0)
|
|
|
|
TQ_UNLOCK(queue);
|
2001-10-26 18:46:48 +00:00
|
|
|
|
2013-10-21 21:16:50 +00:00
|
|
|
/* Return with lock released. */
|
2011-04-26 11:39:56 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2015-01-04 19:55:44 +00:00
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
int
|
|
|
|
taskqueue_enqueue(struct taskqueue *queue, struct task *task)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
res = taskqueue_enqueue_locked(queue, task);
|
2013-10-21 21:16:50 +00:00
|
|
|
/* The lock is released inside. */
|
2001-10-26 18:46:48 +00:00
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
return (res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
taskqueue_timeout_func(void *arg)
|
|
|
|
{
|
|
|
|
struct taskqueue *queue;
|
|
|
|
struct timeout_task *timeout_task;
|
|
|
|
|
|
|
|
timeout_task = arg;
|
|
|
|
queue = timeout_task->q;
|
|
|
|
KASSERT((timeout_task->f & DT_CALLOUT_ARMED) != 0, ("Stray timeout"));
|
|
|
|
timeout_task->f &= ~DT_CALLOUT_ARMED;
|
|
|
|
queue->tq_callouts--;
|
|
|
|
taskqueue_enqueue_locked(timeout_task->q, &timeout_task->t);
|
2013-10-21 21:16:50 +00:00
|
|
|
/* The lock is released inside. */
|
2011-04-26 11:39:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2017-07-31 00:54:50 +00:00
|
|
|
taskqueue_enqueue_timeout_sbt(struct taskqueue *queue,
|
|
|
|
struct timeout_task *timeout_task, sbintime_t sbt, sbintime_t pr, int flags)
|
2011-04-26 11:39:56 +00:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
KASSERT(timeout_task->q == NULL || timeout_task->q == queue,
|
|
|
|
("Migrated queue"));
|
|
|
|
KASSERT(!queue->tq_spin, ("Timeout for spin-queue"));
|
|
|
|
timeout_task->q = queue;
|
|
|
|
res = timeout_task->t.ta_pending;
|
2016-09-29 10:38:20 +00:00
|
|
|
if (timeout_task->f & DT_DRAIN_IN_PROGRESS) {
|
|
|
|
/* Do nothing */
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
res = -1;
|
2017-07-31 00:54:50 +00:00
|
|
|
} else if (sbt == 0) {
|
2011-04-26 11:39:56 +00:00
|
|
|
taskqueue_enqueue_locked(queue, &timeout_task->t);
|
2013-10-21 21:16:50 +00:00
|
|
|
/* The lock is released inside. */
|
2011-04-26 11:39:56 +00:00
|
|
|
} else {
|
|
|
|
if ((timeout_task->f & DT_CALLOUT_ARMED) != 0) {
|
|
|
|
res++;
|
|
|
|
} else {
|
|
|
|
queue->tq_callouts++;
|
|
|
|
timeout_task->f |= DT_CALLOUT_ARMED;
|
2017-07-31 00:54:50 +00:00
|
|
|
if (sbt < 0)
|
|
|
|
sbt = -sbt; /* Ignore overflow. */
|
2012-11-20 15:33:48 +00:00
|
|
|
}
|
2017-07-31 00:54:50 +00:00
|
|
|
if (sbt > 0) {
|
|
|
|
callout_reset_sbt(&timeout_task->c, sbt, pr,
|
|
|
|
taskqueue_timeout_func, timeout_task, flags);
|
2011-04-26 11:39:56 +00:00
|
|
|
}
|
2013-10-16 09:52:59 +00:00
|
|
|
TQ_UNLOCK(queue);
|
2011-04-26 11:39:56 +00:00
|
|
|
}
|
|
|
|
return (res);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
2017-07-31 00:54:50 +00:00
|
|
|
int
|
|
|
|
taskqueue_enqueue_timeout(struct taskqueue *queue,
|
|
|
|
struct timeout_task *ttask, int ticks)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (taskqueue_enqueue_timeout_sbt(queue, ttask, ticks * tick_sbt,
|
|
|
|
0, 0));
|
|
|
|
}
|
|
|
|
|
2013-11-28 18:56:34 +00:00
|
|
|
static void
|
2015-01-04 19:55:44 +00:00
|
|
|
taskqueue_task_nop_fn(void *context, int pending)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Block until all currently queued tasks in this taskqueue
|
|
|
|
* have begun execution. Tasks queued during execution of
|
|
|
|
* this function are ignored.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
taskqueue_drain_tq_queue(struct taskqueue *queue)
|
2013-11-28 18:56:34 +00:00
|
|
|
{
|
2015-01-04 19:55:44 +00:00
|
|
|
struct task t_barrier;
|
2013-11-28 18:56:34 +00:00
|
|
|
|
2015-01-04 19:55:44 +00:00
|
|
|
if (STAILQ_EMPTY(&queue->tq_queue))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
2015-05-26 01:40:33 +00:00
|
|
|
* Enqueue our barrier after all current tasks, but with
|
|
|
|
* the highest priority so that newly queued tasks cannot
|
|
|
|
* pass it. Because of the high priority, we can not use
|
|
|
|
* taskqueue_enqueue_locked directly (which drops the lock
|
|
|
|
* anyway) so just insert it at tail while we have the
|
|
|
|
* queue lock.
|
2015-01-04 19:55:44 +00:00
|
|
|
*/
|
2015-05-26 01:40:33 +00:00
|
|
|
TASK_INIT(&t_barrier, USHRT_MAX, taskqueue_task_nop_fn, &t_barrier);
|
|
|
|
STAILQ_INSERT_TAIL(&queue->tq_queue, &t_barrier, ta_link);
|
|
|
|
t_barrier.ta_pending = 1;
|
2015-01-04 19:55:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Once the barrier has executed, all previously queued tasks
|
|
|
|
* have completed or are currently executing.
|
|
|
|
*/
|
|
|
|
while (t_barrier.ta_pending != 0)
|
|
|
|
TQ_SLEEP(queue, &t_barrier, &queue->tq_mutex, PWAIT, "-", 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Block until all currently executing tasks for this taskqueue
|
|
|
|
* complete. Tasks that begin execution during the execution
|
|
|
|
* of this function are ignored.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
taskqueue_drain_tq_active(struct taskqueue *queue)
|
|
|
|
{
|
|
|
|
struct taskqueue_busy tb_marker, *tb_first;
|
|
|
|
|
|
|
|
if (TAILQ_EMPTY(&queue->tq_active))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Block taskq_terminate().*/
|
|
|
|
queue->tq_callouts++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for all currently executing taskqueue threads
|
|
|
|
* to go idle.
|
|
|
|
*/
|
|
|
|
tb_marker.tb_running = TB_DRAIN_WAITER;
|
|
|
|
TAILQ_INSERT_TAIL(&queue->tq_active, &tb_marker, tb_link);
|
|
|
|
while (TAILQ_FIRST(&queue->tq_active) != &tb_marker)
|
|
|
|
TQ_SLEEP(queue, &tb_marker, &queue->tq_mutex, PWAIT, "-", 0);
|
|
|
|
TAILQ_REMOVE(&queue->tq_active, &tb_marker, tb_link);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wakeup any other drain waiter that happened to queue up
|
|
|
|
* without any intervening active thread.
|
|
|
|
*/
|
|
|
|
tb_first = TAILQ_FIRST(&queue->tq_active);
|
|
|
|
if (tb_first != NULL && tb_first->tb_running == TB_DRAIN_WAITER)
|
|
|
|
wakeup(tb_first);
|
|
|
|
|
|
|
|
/* Release taskqueue_terminate(). */
|
|
|
|
queue->tq_callouts--;
|
|
|
|
if ((queue->tq_flags & TQ_FLAGS_ACTIVE) == 0)
|
|
|
|
wakeup_one(queue->tq_threads);
|
2013-11-28 18:56:34 +00:00
|
|
|
}
|
|
|
|
|
2008-03-25 22:38:45 +00:00
|
|
|
void
|
|
|
|
taskqueue_block(struct taskqueue *queue)
|
|
|
|
{
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
queue->tq_flags |= TQ_FLAGS_BLOCKED;
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
taskqueue_unblock(struct taskqueue *queue)
|
|
|
|
{
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
queue->tq_flags &= ~TQ_FLAGS_BLOCKED;
|
2013-10-16 09:48:23 +00:00
|
|
|
if (!STAILQ_EMPTY(&queue->tq_queue))
|
2008-03-25 22:38:45 +00:00
|
|
|
queue->tq_enqueue(queue->tq_context);
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
}
|
|
|
|
|
2010-10-13 22:59:04 +00:00
|
|
|
static void
|
|
|
|
taskqueue_run_locked(struct taskqueue *queue)
|
2000-05-28 15:45:30 +00:00
|
|
|
{
|
2010-10-13 22:59:04 +00:00
|
|
|
struct taskqueue_busy tb;
|
2015-01-04 19:55:44 +00:00
|
|
|
struct taskqueue_busy *tb_first;
|
2010-07-22 17:23:43 +00:00
|
|
|
struct task *task;
|
2010-07-22 16:41:09 +00:00
|
|
|
int pending;
|
2000-05-28 15:45:30 +00:00
|
|
|
|
2016-05-18 04:35:58 +00:00
|
|
|
KASSERT(queue != NULL, ("tq is NULL"));
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
TQ_ASSERT_LOCKED(queue);
|
2010-10-13 22:59:04 +00:00
|
|
|
tb.tb_running = NULL;
|
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
while (STAILQ_FIRST(&queue->tq_queue)) {
|
2015-01-04 19:55:44 +00:00
|
|
|
TAILQ_INSERT_TAIL(&queue->tq_active, &tb, tb_link);
|
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
/*
|
|
|
|
* Carefully remove the first task from the queue and
|
|
|
|
* zero its pending count.
|
|
|
|
*/
|
|
|
|
task = STAILQ_FIRST(&queue->tq_queue);
|
2016-05-18 04:35:58 +00:00
|
|
|
KASSERT(task != NULL, ("task is NULL"));
|
2000-05-28 15:45:30 +00:00
|
|
|
STAILQ_REMOVE_HEAD(&queue->tq_queue, ta_link);
|
|
|
|
pending = task->ta_pending;
|
|
|
|
task->ta_pending = 0;
|
2010-10-13 22:59:04 +00:00
|
|
|
tb.tb_running = task;
|
2006-01-10 06:31:12 +00:00
|
|
|
TQ_UNLOCK(queue);
|
2000-05-28 15:45:30 +00:00
|
|
|
|
2016-05-18 04:35:58 +00:00
|
|
|
KASSERT(task->ta_func != NULL, ("task->ta_func is NULL"));
|
2001-10-26 18:46:48 +00:00
|
|
|
task->ta_func(task->ta_context, pending);
|
2000-05-28 15:45:30 +00:00
|
|
|
|
2006-01-10 06:31:12 +00:00
|
|
|
TQ_LOCK(queue);
|
2010-10-13 22:59:04 +00:00
|
|
|
tb.tb_running = NULL;
|
2016-05-21 14:51:49 +00:00
|
|
|
wakeup(task);
|
2015-01-04 19:55:44 +00:00
|
|
|
|
|
|
|
TAILQ_REMOVE(&queue->tq_active, &tb, tb_link);
|
|
|
|
tb_first = TAILQ_FIRST(&queue->tq_active);
|
|
|
|
if (tb_first != NULL &&
|
|
|
|
tb_first->tb_running == TB_DRAIN_WAITER)
|
|
|
|
wakeup(tb_first);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
2010-10-13 22:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
taskqueue_run(struct taskqueue *queue)
|
|
|
|
{
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
taskqueue_run_locked(queue);
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
task_is_running(struct taskqueue *queue, struct task *task)
|
|
|
|
{
|
|
|
|
struct taskqueue_busy *tb;
|
|
|
|
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
TQ_ASSERT_LOCKED(queue);
|
2010-10-13 22:59:04 +00:00
|
|
|
TAILQ_FOREACH(tb, &queue->tq_active, tb_link) {
|
|
|
|
if (tb->tb_running == task)
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
return (0);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
2017-03-02 12:20:23 +00:00
|
|
|
/*
|
|
|
|
* Only use this function in single threaded contexts. It returns
|
|
|
|
* non-zero if the given task is either pending or running. Else the
|
|
|
|
* task is idle and can be queued again or freed.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
taskqueue_poll_is_busy(struct taskqueue *queue, struct task *task)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
retval = task->ta_pending > 0 || task_is_running(queue, task);
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
static int
|
|
|
|
taskqueue_cancel_locked(struct taskqueue *queue, struct task *task,
|
|
|
|
u_int *pendp)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (task->ta_pending > 0)
|
|
|
|
STAILQ_REMOVE(&queue->tq_queue, task, task, ta_link);
|
|
|
|
if (pendp != NULL)
|
|
|
|
*pendp = task->ta_pending;
|
|
|
|
task->ta_pending = 0;
|
|
|
|
return (task_is_running(queue, task) ? EBUSY : 0);
|
|
|
|
}
|
|
|
|
|
2010-11-08 20:56:31 +00:00
|
|
|
int
|
|
|
|
taskqueue_cancel(struct taskqueue *queue, struct task *task, u_int *pendp)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
2011-04-26 11:39:56 +00:00
|
|
|
error = taskqueue_cancel_locked(queue, task, pendp);
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
taskqueue_cancel_timeout(struct taskqueue *queue,
|
|
|
|
struct timeout_task *timeout_task, u_int *pendp)
|
|
|
|
{
|
|
|
|
u_int pending, pending1;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
2015-11-13 22:51:35 +00:00
|
|
|
pending = !!(callout_stop(&timeout_task->c) > 0);
|
2011-04-26 11:39:56 +00:00
|
|
|
error = taskqueue_cancel_locked(queue, &timeout_task->t, &pending1);
|
|
|
|
if ((timeout_task->f & DT_CALLOUT_ARMED) != 0) {
|
|
|
|
timeout_task->f &= ~DT_CALLOUT_ARMED;
|
|
|
|
queue->tq_callouts--;
|
|
|
|
}
|
2010-11-08 20:56:31 +00:00
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
|
|
|
|
if (pendp != NULL)
|
2011-04-26 11:39:56 +00:00
|
|
|
*pendp = pending + pending1;
|
2010-11-08 20:56:31 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2004-10-05 04:16:01 +00:00
|
|
|
void
|
|
|
|
taskqueue_drain(struct taskqueue *queue, struct task *task)
|
|
|
|
{
|
2010-08-13 19:20:35 +00:00
|
|
|
|
|
|
|
if (!queue->tq_spin)
|
2006-01-10 06:31:12 +00:00
|
|
|
WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, __func__);
|
2005-05-01 00:38:11 +00:00
|
|
|
|
2010-08-13 19:20:35 +00:00
|
|
|
TQ_LOCK(queue);
|
2010-10-13 22:59:04 +00:00
|
|
|
while (task->ta_pending != 0 || task_is_running(queue, task))
|
2010-08-13 19:20:35 +00:00
|
|
|
TQ_SLEEP(queue, task, &queue->tq_mutex, PWAIT, "-", 0);
|
|
|
|
TQ_UNLOCK(queue);
|
2004-10-05 04:16:01 +00:00
|
|
|
}
|
|
|
|
|
2013-11-28 18:56:34 +00:00
|
|
|
void
|
|
|
|
taskqueue_drain_all(struct taskqueue *queue)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!queue->tq_spin)
|
|
|
|
WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, __func__);
|
|
|
|
|
|
|
|
TQ_LOCK(queue);
|
2015-01-04 19:55:44 +00:00
|
|
|
taskqueue_drain_tq_queue(queue);
|
|
|
|
taskqueue_drain_tq_active(queue);
|
2013-11-28 18:56:34 +00:00
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
}
|
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
void
|
|
|
|
taskqueue_drain_timeout(struct taskqueue *queue,
|
|
|
|
struct timeout_task *timeout_task)
|
|
|
|
{
|
|
|
|
|
2016-09-29 10:38:20 +00:00
|
|
|
/*
|
|
|
|
* Set flag to prevent timer from re-starting during drain:
|
|
|
|
*/
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
KASSERT((timeout_task->f & DT_DRAIN_IN_PROGRESS) == 0,
|
|
|
|
("Drain already in progress"));
|
|
|
|
timeout_task->f |= DT_DRAIN_IN_PROGRESS;
|
|
|
|
TQ_UNLOCK(queue);
|
|
|
|
|
2011-04-26 11:39:56 +00:00
|
|
|
callout_drain(&timeout_task->c);
|
|
|
|
taskqueue_drain(queue, &timeout_task->t);
|
2016-09-29 10:38:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear flag to allow timer to re-start:
|
|
|
|
*/
|
|
|
|
TQ_LOCK(queue);
|
|
|
|
timeout_task->f &= ~DT_DRAIN_IN_PROGRESS;
|
|
|
|
TQ_UNLOCK(queue);
|
2011-04-26 11:39:56 +00:00
|
|
|
}
|
|
|
|
|
2000-05-28 15:45:30 +00:00
|
|
|
static void
|
|
|
|
taskqueue_swi_enqueue(void *context)
|
|
|
|
{
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(taskqueue_ih, 0);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-10-25 05:19:40 +00:00
|
|
|
taskqueue_swi_run(void *dummy)
|
2000-05-28 15:45:30 +00:00
|
|
|
{
|
2010-10-13 22:59:04 +00:00
|
|
|
taskqueue_run(taskqueue_swi);
|
2000-05-28 15:45:30 +00:00
|
|
|
}
|
|
|
|
|
2003-02-26 03:15:42 +00:00
|
|
|
static void
|
|
|
|
taskqueue_swi_giant_enqueue(void *context)
|
|
|
|
{
|
|
|
|
swi_sched(taskqueue_giant_ih, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
taskqueue_swi_giant_run(void *dummy)
|
|
|
|
{
|
2010-10-13 22:59:04 +00:00
|
|
|
taskqueue_run(taskqueue_swi_giant);
|
2003-02-26 03:15:42 +00:00
|
|
|
}
|
|
|
|
|
2014-05-24 20:37:15 +00:00
|
|
|
static int
|
|
|
|
_taskqueue_start_threads(struct taskqueue **tqp, int count, int pri,
|
2015-02-17 02:35:06 +00:00
|
|
|
cpuset_t *mask, const char *name, va_list ap)
|
2006-01-14 01:55:24 +00:00
|
|
|
{
|
2015-02-17 02:35:06 +00:00
|
|
|
char ktname[MAXCOMLEN + 1];
|
2006-05-24 22:11:07 +00:00
|
|
|
struct thread *td;
|
2008-04-08 17:48:02 +00:00
|
|
|
struct taskqueue *tq;
|
2006-03-30 23:06:59 +00:00
|
|
|
int i, error;
|
2006-01-14 01:55:24 +00:00
|
|
|
|
|
|
|
if (count <= 0)
|
|
|
|
return (EINVAL);
|
2008-04-08 17:48:02 +00:00
|
|
|
|
2015-02-17 02:35:06 +00:00
|
|
|
vsnprintf(ktname, sizeof(ktname), name, ap);
|
2006-01-14 01:55:24 +00:00
|
|
|
tq = *tqp;
|
|
|
|
|
2018-01-21 15:42:36 +00:00
|
|
|
tq->tq_threads = malloc(sizeof(struct thread *) * count, M_TASKQUEUE,
|
|
|
|
M_NOWAIT | M_ZERO);
|
2008-04-08 17:48:02 +00:00
|
|
|
if (tq->tq_threads == NULL) {
|
2006-03-30 23:06:59 +00:00
|
|
|
printf("%s: no memory for %s threads\n", __func__, ktname);
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
|
2006-01-14 01:55:24 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
if (count == 1)
|
2008-04-08 17:48:02 +00:00
|
|
|
error = kthread_add(taskqueue_thread_loop, tqp, NULL,
|
2010-06-11 19:27:21 +00:00
|
|
|
&tq->tq_threads[i], RFSTOPPED, 0, "%s", ktname);
|
2006-01-14 01:55:24 +00:00
|
|
|
else
|
2008-04-08 17:48:02 +00:00
|
|
|
error = kthread_add(taskqueue_thread_loop, tqp, NULL,
|
|
|
|
&tq->tq_threads[i], RFSTOPPED, 0,
|
|
|
|
"%s_%d", ktname, i);
|
2006-05-24 22:11:07 +00:00
|
|
|
if (error) {
|
2006-03-30 23:06:59 +00:00
|
|
|
/* should be ok to continue, taskqueue_free will dtrt */
|
2008-04-08 17:48:02 +00:00
|
|
|
printf("%s: kthread_add(%s): error %d", __func__,
|
|
|
|
ktname, error);
|
|
|
|
tq->tq_threads[i] = NULL; /* paranoid */
|
2006-05-24 22:11:07 +00:00
|
|
|
} else
|
2008-04-08 17:48:02 +00:00
|
|
|
tq->tq_tcount++;
|
2006-05-24 22:11:07 +00:00
|
|
|
}
|
2016-09-01 02:05:46 +00:00
|
|
|
if (tq->tq_tcount == 0) {
|
|
|
|
free(tq->tq_threads, M_TASKQUEUE);
|
|
|
|
tq->tq_threads = NULL;
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
2006-05-24 22:11:07 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
2008-04-08 17:48:02 +00:00
|
|
|
if (tq->tq_threads[i] == NULL)
|
2006-05-24 22:11:07 +00:00
|
|
|
continue;
|
2008-04-08 17:48:02 +00:00
|
|
|
td = tq->tq_threads[i];
|
2014-05-24 20:37:15 +00:00
|
|
|
if (mask) {
|
2014-08-07 14:32:28 +00:00
|
|
|
error = cpuset_setthread(td->td_tid, mask);
|
2014-05-24 20:37:15 +00:00
|
|
|
/*
|
|
|
|
* Failing to pin is rarely an actual fatal error;
|
|
|
|
* it'll just affect performance.
|
|
|
|
*/
|
|
|
|
if (error)
|
|
|
|
printf("%s: curthread=%llu: can't pin; "
|
|
|
|
"error=%d\n",
|
|
|
|
__func__,
|
|
|
|
(unsigned long long) td->td_tid,
|
|
|
|
error);
|
|
|
|
}
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
thread_lock(td);
|
2006-05-24 22:11:07 +00:00
|
|
|
sched_prio(td, pri);
|
2007-01-23 08:46:51 +00:00
|
|
|
sched_add(td, SRQ_BORING);
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
thread_unlock(td);
|
2006-01-14 01:55:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2014-05-24 20:37:15 +00:00
|
|
|
int
|
|
|
|
taskqueue_start_threads(struct taskqueue **tqp, int count, int pri,
|
|
|
|
const char *name, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
2015-02-17 02:35:06 +00:00
|
|
|
int error;
|
2014-05-24 20:37:15 +00:00
|
|
|
|
|
|
|
va_start(ap, name);
|
2015-02-17 02:35:06 +00:00
|
|
|
error = _taskqueue_start_threads(tqp, count, pri, NULL, name, ap);
|
2014-05-24 20:37:15 +00:00
|
|
|
va_end(ap);
|
2015-02-17 02:35:06 +00:00
|
|
|
return (error);
|
2014-05-24 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2015-02-17 02:35:06 +00:00
|
|
|
taskqueue_start_threads_cpuset(struct taskqueue **tqp, int count, int pri,
|
|
|
|
cpuset_t *mask, const char *name, ...)
|
2014-05-24 20:37:15 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
2015-02-17 02:35:06 +00:00
|
|
|
int error;
|
2014-05-24 20:37:15 +00:00
|
|
|
|
|
|
|
va_start(ap, name);
|
2015-02-17 02:35:06 +00:00
|
|
|
error = _taskqueue_start_threads(tqp, count, pri, mask, name, ap);
|
2014-05-24 20:37:15 +00:00
|
|
|
va_end(ap);
|
2015-02-17 02:35:06 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
static inline void
|
|
|
|
taskqueue_run_callback(struct taskqueue *tq,
|
|
|
|
enum taskqueue_callback_type cb_type)
|
|
|
|
{
|
|
|
|
taskqueue_callback_fn tq_callback;
|
|
|
|
|
|
|
|
TQ_ASSERT_UNLOCKED(tq);
|
|
|
|
tq_callback = tq->tq_callbacks[cb_type];
|
|
|
|
if (tq_callback != NULL)
|
|
|
|
tq_callback(tq->tq_cb_contexts[cb_type]);
|
|
|
|
}
|
|
|
|
|
2004-08-08 02:37:22 +00:00
|
|
|
void
|
|
|
|
taskqueue_thread_loop(void *arg)
|
Move dynamic sysctl(8) variable creation for the cd(4) and da(4) drivers
out of cdregister() and daregister(), which are run from interrupt context.
The sysctl code does blocking mallocs (M_WAITOK), which causes problems
if malloc(9) actually needs to sleep.
The eventual fix for this issue will involve moving the CAM probe process
inside a kernel thread. For now, though, I have fixed the issue by moving
dynamic sysctl variable creation for these two drivers to a task queue
running in a kernel thread.
The existing task queues (taskqueue_swi and taskqueue_swi_giant) run in
software interrupt handlers, which wouldn't fix the problem at hand. So I
have created a new task queue, taskqueue_thread, that runs inside a kernel
thread. (It also runs outside of Giant -- clients must explicitly acquire
and release Giant in their taskqueue functions.)
scsi_cd.c: Remove sysctl variable creation code from cdregister(), and
move it to a new function, cdsysctlinit(). Queue
cdsysctlinit() to the taskqueue_thread taskqueue once we
have fully registered the cd(4) driver instance.
scsi_da.c: Remove sysctl variable creation code from daregister(), and
move it to move it to a new function, dasysctlinit().
Queue dasysctlinit() to the taskqueue_thread taskqueue once
we have fully registered the da(4) instance.
taskqueue.h: Declare the new taskqueue_thread taskqueue, update some
comments.
subr_taskqueue.c:
Create the new kernel thread taskqueue. This taskqueue
runs outside of Giant, so any functions queued to it would
need to explicitly acquire/release Giant if they need it.
cd.4: Update the cd(4) man page to talk about the minimum command
size sysctl/loader tunable. Also note that the changer
variables are available as loader tunables as well.
da.4: Update the da(4) man page to cover the retry_count,
default_timeout and minimum_cmd_size sysctl variables/loader
tunables. Remove references to /dev/r???, they aren't used
any longer.
cd.9: Update the cd(9) man page to describe the CD_Q_10_BYTE_ONLY
quirk.
taskqueue.9: Update the taskqueue(9) man page to describe the new thread
task queue, and the taskqueue_swi_giant queue.
MFC after: 3 days
2003-09-03 04:46:28 +00:00
|
|
|
{
|
2004-08-08 02:37:22 +00:00
|
|
|
struct taskqueue **tqp, *tq;
|
2004-06-28 16:28:23 +00:00
|
|
|
|
2004-08-08 02:37:22 +00:00
|
|
|
tqp = arg;
|
|
|
|
tq = *tqp;
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
taskqueue_run_callback(tq, TASKQUEUE_CALLBACK_TYPE_INIT);
|
2006-01-10 06:31:12 +00:00
|
|
|
TQ_LOCK(tq);
|
2009-02-13 01:16:51 +00:00
|
|
|
while ((tq->tq_flags & TQ_FLAGS_ACTIVE) != 0) {
|
2016-05-18 04:35:58 +00:00
|
|
|
/* XXX ? */
|
2010-10-13 22:59:04 +00:00
|
|
|
taskqueue_run_locked(tq);
|
2009-08-17 08:42:34 +00:00
|
|
|
/*
|
|
|
|
* Because taskqueue_run() can drop tq_mutex, we need to
|
|
|
|
* check if the TQ_FLAGS_ACTIVE flag wasn't removed in the
|
|
|
|
* meantime, which means we missed a wakeup.
|
|
|
|
*/
|
|
|
|
if ((tq->tq_flags & TQ_FLAGS_ACTIVE) == 0)
|
|
|
|
break;
|
2006-04-17 18:20:38 +00:00
|
|
|
TQ_SLEEP(tq, tq, &tq->tq_mutex, 0, "-", 0);
|
2009-02-13 18:51:39 +00:00
|
|
|
}
|
2010-10-13 22:59:04 +00:00
|
|
|
taskqueue_run_locked(tq);
|
Extend taskqueue(9) to enable per-taskqueue callbacks.
The scope of these callbacks is primarily to support actions that affect the
taskqueue's thread environments. They are entirely optional, and
consequently are introduced as a new API: taskqueue_set_callback().
This interface allows the caller to specify that a taskqueue requires a
callback and optional context pointer for a given callback type.
The callback types included in this commit can be used to register a
constructor and destructor for thread-local storage using osd(9). This
allows a particular taskqueue to define that its threads require a specific
type of TLS, without the need for a specially-orchestrated task-based
mechanism for startup and shutdown in order to accomplish it.
Two callback types are supported at this point:
- TASKQUEUE_CALLBACK_TYPE_INIT, called by every thread when it starts, prior
to processing any tasks.
- TASKQUEUE_CALLBACK_TYPE_SHUTDOWN, called by every thread when it exits,
after it has processed its last task but before the taskqueue is
reclaimed.
While I'm here:
- Add two new macros, TQ_ASSERT_LOCKED and TQ_ASSERT_UNLOCKED, and use them
in appropriate locations.
- Fix taskqueue.9 to mention taskqueue_start_threads(), which is a required
interface for all consumers of taskqueue(9).
Reviewed by: kib (all), eadler (taskqueue.9), brd (taskqueue.9)
Approved by: ken (mentor)
Sponsored by: Spectra Logic
MFC after: 1 month
2013-03-23 15:11:53 +00:00
|
|
|
/*
|
|
|
|
* This thread is on its way out, so just drop the lock temporarily
|
|
|
|
* in order to call the shutdown callback. This allows the callback
|
|
|
|
* to look at the taskqueue, even just before it dies.
|
|
|
|
*/
|
|
|
|
TQ_UNLOCK(tq);
|
|
|
|
taskqueue_run_callback(tq, TASKQUEUE_CALLBACK_TYPE_SHUTDOWN);
|
|
|
|
TQ_LOCK(tq);
|
|
|
|
|
2005-05-01 00:38:11 +00:00
|
|
|
/* rendezvous with thread that asked us to terminate */
|
2008-04-08 17:48:02 +00:00
|
|
|
tq->tq_tcount--;
|
|
|
|
wakeup_one(tq->tq_threads);
|
2006-01-10 06:31:12 +00:00
|
|
|
TQ_UNLOCK(tq);
|
2008-04-11 17:35:54 +00:00
|
|
|
kthread_exit();
|
Move dynamic sysctl(8) variable creation for the cd(4) and da(4) drivers
out of cdregister() and daregister(), which are run from interrupt context.
The sysctl code does blocking mallocs (M_WAITOK), which causes problems
if malloc(9) actually needs to sleep.
The eventual fix for this issue will involve moving the CAM probe process
inside a kernel thread. For now, though, I have fixed the issue by moving
dynamic sysctl variable creation for these two drivers to a task queue
running in a kernel thread.
The existing task queues (taskqueue_swi and taskqueue_swi_giant) run in
software interrupt handlers, which wouldn't fix the problem at hand. So I
have created a new task queue, taskqueue_thread, that runs inside a kernel
thread. (It also runs outside of Giant -- clients must explicitly acquire
and release Giant in their taskqueue functions.)
scsi_cd.c: Remove sysctl variable creation code from cdregister(), and
move it to a new function, cdsysctlinit(). Queue
cdsysctlinit() to the taskqueue_thread taskqueue once we
have fully registered the cd(4) driver instance.
scsi_da.c: Remove sysctl variable creation code from daregister(), and
move it to move it to a new function, dasysctlinit().
Queue dasysctlinit() to the taskqueue_thread taskqueue once
we have fully registered the da(4) instance.
taskqueue.h: Declare the new taskqueue_thread taskqueue, update some
comments.
subr_taskqueue.c:
Create the new kernel thread taskqueue. This taskqueue
runs outside of Giant, so any functions queued to it would
need to explicitly acquire/release Giant if they need it.
cd.4: Update the cd(4) man page to talk about the minimum command
size sysctl/loader tunable. Also note that the changer
variables are available as loader tunables as well.
da.4: Update the da(4) man page to cover the retry_count,
default_timeout and minimum_cmd_size sysctl variables/loader
tunables. Remove references to /dev/r???, they aren't used
any longer.
cd.9: Update the cd(9) man page to describe the CD_Q_10_BYTE_ONLY
quirk.
taskqueue.9: Update the taskqueue(9) man page to describe the new thread
task queue, and the taskqueue_swi_giant queue.
MFC after: 3 days
2003-09-03 04:46:28 +00:00
|
|
|
}
|
|
|
|
|
2004-08-08 02:37:22 +00:00
|
|
|
void
|
Move dynamic sysctl(8) variable creation for the cd(4) and da(4) drivers
out of cdregister() and daregister(), which are run from interrupt context.
The sysctl code does blocking mallocs (M_WAITOK), which causes problems
if malloc(9) actually needs to sleep.
The eventual fix for this issue will involve moving the CAM probe process
inside a kernel thread. For now, though, I have fixed the issue by moving
dynamic sysctl variable creation for these two drivers to a task queue
running in a kernel thread.
The existing task queues (taskqueue_swi and taskqueue_swi_giant) run in
software interrupt handlers, which wouldn't fix the problem at hand. So I
have created a new task queue, taskqueue_thread, that runs inside a kernel
thread. (It also runs outside of Giant -- clients must explicitly acquire
and release Giant in their taskqueue functions.)
scsi_cd.c: Remove sysctl variable creation code from cdregister(), and
move it to a new function, cdsysctlinit(). Queue
cdsysctlinit() to the taskqueue_thread taskqueue once we
have fully registered the cd(4) driver instance.
scsi_da.c: Remove sysctl variable creation code from daregister(), and
move it to move it to a new function, dasysctlinit().
Queue dasysctlinit() to the taskqueue_thread taskqueue once
we have fully registered the da(4) instance.
taskqueue.h: Declare the new taskqueue_thread taskqueue, update some
comments.
subr_taskqueue.c:
Create the new kernel thread taskqueue. This taskqueue
runs outside of Giant, so any functions queued to it would
need to explicitly acquire/release Giant if they need it.
cd.4: Update the cd(4) man page to talk about the minimum command
size sysctl/loader tunable. Also note that the changer
variables are available as loader tunables as well.
da.4: Update the da(4) man page to cover the retry_count,
default_timeout and minimum_cmd_size sysctl variables/loader
tunables. Remove references to /dev/r???, they aren't used
any longer.
cd.9: Update the cd(9) man page to describe the CD_Q_10_BYTE_ONLY
quirk.
taskqueue.9: Update the taskqueue(9) man page to describe the new thread
task queue, and the taskqueue_swi_giant queue.
MFC after: 3 days
2003-09-03 04:46:28 +00:00
|
|
|
taskqueue_thread_enqueue(void *context)
|
|
|
|
{
|
2004-08-08 02:37:22 +00:00
|
|
|
struct taskqueue **tqp, *tq;
|
|
|
|
|
|
|
|
tqp = context;
|
|
|
|
tq = *tqp;
|
2016-05-21 14:51:49 +00:00
|
|
|
wakeup_one(tq);
|
Move dynamic sysctl(8) variable creation for the cd(4) and da(4) drivers
out of cdregister() and daregister(), which are run from interrupt context.
The sysctl code does blocking mallocs (M_WAITOK), which causes problems
if malloc(9) actually needs to sleep.
The eventual fix for this issue will involve moving the CAM probe process
inside a kernel thread. For now, though, I have fixed the issue by moving
dynamic sysctl variable creation for these two drivers to a task queue
running in a kernel thread.
The existing task queues (taskqueue_swi and taskqueue_swi_giant) run in
software interrupt handlers, which wouldn't fix the problem at hand. So I
have created a new task queue, taskqueue_thread, that runs inside a kernel
thread. (It also runs outside of Giant -- clients must explicitly acquire
and release Giant in their taskqueue functions.)
scsi_cd.c: Remove sysctl variable creation code from cdregister(), and
move it to a new function, cdsysctlinit(). Queue
cdsysctlinit() to the taskqueue_thread taskqueue once we
have fully registered the cd(4) driver instance.
scsi_da.c: Remove sysctl variable creation code from daregister(), and
move it to move it to a new function, dasysctlinit().
Queue dasysctlinit() to the taskqueue_thread taskqueue once
we have fully registered the da(4) instance.
taskqueue.h: Declare the new taskqueue_thread taskqueue, update some
comments.
subr_taskqueue.c:
Create the new kernel thread taskqueue. This taskqueue
runs outside of Giant, so any functions queued to it would
need to explicitly acquire/release Giant if they need it.
cd.4: Update the cd(4) man page to talk about the minimum command
size sysctl/loader tunable. Also note that the changer
variables are available as loader tunables as well.
da.4: Update the da(4) man page to cover the retry_count,
default_timeout and minimum_cmd_size sysctl variables/loader
tunables. Remove references to /dev/r???, they aren't used
any longer.
cd.9: Update the cd(9) man page to describe the CD_Q_10_BYTE_ONLY
quirk.
taskqueue.9: Update the taskqueue(9) man page to describe the new thread
task queue, and the taskqueue_swi_giant queue.
MFC after: 3 days
2003-09-03 04:46:28 +00:00
|
|
|
}
|
|
|
|
|
2009-02-03 07:51:41 +00:00
|
|
|
TASKQUEUE_DEFINE(swi, taskqueue_swi_enqueue, NULL,
|
2003-02-26 03:15:42 +00:00
|
|
|
swi_add(NULL, "task queue", taskqueue_swi_run, NULL, SWI_TQ,
|
2014-11-30 19:32:00 +00:00
|
|
|
INTR_MPSAFE, &taskqueue_ih));
|
2003-02-26 03:15:42 +00:00
|
|
|
|
2009-02-03 07:51:41 +00:00
|
|
|
TASKQUEUE_DEFINE(swi_giant, taskqueue_swi_giant_enqueue, NULL,
|
2005-10-25 19:29:02 +00:00
|
|
|
swi_add(NULL, "Giant taskq", taskqueue_swi_giant_run,
|
2014-11-30 19:32:00 +00:00
|
|
|
NULL, SWI_TQ_GIANT, 0, &taskqueue_giant_ih));
|
Move dynamic sysctl(8) variable creation for the cd(4) and da(4) drivers
out of cdregister() and daregister(), which are run from interrupt context.
The sysctl code does blocking mallocs (M_WAITOK), which causes problems
if malloc(9) actually needs to sleep.
The eventual fix for this issue will involve moving the CAM probe process
inside a kernel thread. For now, though, I have fixed the issue by moving
dynamic sysctl variable creation for these two drivers to a task queue
running in a kernel thread.
The existing task queues (taskqueue_swi and taskqueue_swi_giant) run in
software interrupt handlers, which wouldn't fix the problem at hand. So I
have created a new task queue, taskqueue_thread, that runs inside a kernel
thread. (It also runs outside of Giant -- clients must explicitly acquire
and release Giant in their taskqueue functions.)
scsi_cd.c: Remove sysctl variable creation code from cdregister(), and
move it to a new function, cdsysctlinit(). Queue
cdsysctlinit() to the taskqueue_thread taskqueue once we
have fully registered the cd(4) driver instance.
scsi_da.c: Remove sysctl variable creation code from daregister(), and
move it to move it to a new function, dasysctlinit().
Queue dasysctlinit() to the taskqueue_thread taskqueue once
we have fully registered the da(4) instance.
taskqueue.h: Declare the new taskqueue_thread taskqueue, update some
comments.
subr_taskqueue.c:
Create the new kernel thread taskqueue. This taskqueue
runs outside of Giant, so any functions queued to it would
need to explicitly acquire/release Giant if they need it.
cd.4: Update the cd(4) man page to talk about the minimum command
size sysctl/loader tunable. Also note that the changer
variables are available as loader tunables as well.
da.4: Update the da(4) man page to cover the retry_count,
default_timeout and minimum_cmd_size sysctl variables/loader
tunables. Remove references to /dev/r???, they aren't used
any longer.
cd.9: Update the cd(9) man page to describe the CD_Q_10_BYTE_ONLY
quirk.
taskqueue.9: Update the taskqueue(9) man page to describe the new thread
task queue, and the taskqueue_swi_giant queue.
MFC after: 3 days
2003-09-03 04:46:28 +00:00
|
|
|
|
2004-08-08 02:37:22 +00:00
|
|
|
TASKQUEUE_DEFINE_THREAD(thread);
|
2003-09-05 23:09:22 +00:00
|
|
|
|
2006-01-10 06:31:12 +00:00
|
|
|
struct taskqueue *
|
|
|
|
taskqueue_create_fast(const char *name, int mflags,
|
2006-01-14 01:55:24 +00:00
|
|
|
taskqueue_enqueue_fn enqueue, void *context)
|
2003-09-05 23:09:22 +00:00
|
|
|
{
|
2006-01-14 01:55:24 +00:00
|
|
|
return _taskqueue_create(name, mflags, enqueue, context,
|
2006-01-10 06:31:12 +00:00
|
|
|
MTX_SPIN, "fast_taskqueue");
|
2003-09-05 23:09:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *taskqueue_fast_ih;
|
|
|
|
|
|
|
|
static void
|
2006-01-10 06:31:12 +00:00
|
|
|
taskqueue_fast_enqueue(void *context)
|
2003-09-05 23:09:22 +00:00
|
|
|
{
|
|
|
|
swi_sched(taskqueue_fast_ih, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
taskqueue_fast_run(void *dummy)
|
|
|
|
{
|
2010-10-13 22:59:04 +00:00
|
|
|
taskqueue_run(taskqueue_fast);
|
2003-09-05 23:09:22 +00:00
|
|
|
}
|
|
|
|
|
2009-02-03 07:51:41 +00:00
|
|
|
TASKQUEUE_FAST_DEFINE(fast, taskqueue_fast_enqueue, NULL,
|
2012-08-28 13:35:37 +00:00
|
|
|
swi_add(NULL, "fast taskq", taskqueue_fast_run, NULL,
|
2006-01-10 06:31:12 +00:00
|
|
|
SWI_TQ_FAST, INTR_MPSAFE, &taskqueue_fast_ih));
|
2009-08-17 09:01:20 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
taskqueue_member(struct taskqueue *queue, struct thread *td)
|
|
|
|
{
|
|
|
|
int i, j, ret = 0;
|
|
|
|
|
|
|
|
for (i = 0, j = 0; ; i++) {
|
|
|
|
if (queue->tq_threads[i] == NULL)
|
|
|
|
continue;
|
|
|
|
if (queue->tq_threads[i] == td) {
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (++j >= queue->tq_tcount)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (ret);
|
|
|
|
}
|