mirror of
https://git.proxmox.com/git/mirror_zfs.git
synced 2024-11-18 02:20:59 +03:00
6e605b6e58
dynamic taskqs which still need to be fully implemented. git-svn-id: https://outreach.scidac.gov/svn/spl/trunk@87 7e1ea52c-4ff2-0310-8f11-9dd32ca42a1c
115 lines
2.9 KiB
C
115 lines
2.9 KiB
C
#include <sys/taskq.h>
|
|
|
|
#ifdef DEBUG_SUBSYSTEM
|
|
#undef DEBUG_SUBSYSTEM
|
|
#endif
|
|
|
|
#define DEBUG_SUBSYSTEM S_TASKQ
|
|
|
|
/*
|
|
* Task queue interface
|
|
*
|
|
* The taskq_work_wrapper functions are used to manage the work_structs
|
|
* which must be submitted to linux. The shim layer allocates a wrapper
|
|
* structure for all items which contains a pointer to itself as well as
|
|
* the real work to be performed. When the work item run the generic
|
|
* handle is called which calls the real work function and then using
|
|
* the self pointer frees the work_struct.
|
|
*/
|
|
typedef struct taskq_work_wrapper {
|
|
struct work_struct tww_work;
|
|
task_func_t tww_func;
|
|
void * tww_priv;
|
|
} taskq_work_wrapper_t;
|
|
|
|
static void
|
|
taskq_work_handler(void *priv)
|
|
{
|
|
taskq_work_wrapper_t *tww = priv;
|
|
|
|
ASSERT(tww);
|
|
ASSERT(tww->tww_func);
|
|
|
|
/* Call the real function and free the wrapper */
|
|
tww->tww_func(tww->tww_priv);
|
|
kfree(tww);
|
|
}
|
|
|
|
/* XXX - All flags currently ignored */
|
|
taskqid_t
|
|
__taskq_dispatch(taskq_t *tq, task_func_t func, void *priv, uint_t flags)
|
|
{
|
|
struct workqueue_struct *wq = tq;
|
|
taskq_work_wrapper_t *tww;
|
|
int rc;
|
|
ENTRY;
|
|
|
|
ASSERT(tq);
|
|
ASSERT(func);
|
|
|
|
/* Use GFP_ATOMIC since this may be called in interrupt context */
|
|
tww = (taskq_work_wrapper_t *)kmalloc(sizeof(*tww), GFP_ATOMIC);
|
|
if (!tww)
|
|
RETURN((taskqid_t)0);
|
|
|
|
INIT_WORK(&(tww->tww_work), taskq_work_handler, tww);
|
|
tww->tww_func = func;
|
|
tww->tww_priv = priv;
|
|
|
|
rc = queue_work(wq, &(tww->tww_work));
|
|
if (!rc) {
|
|
kfree(tww);
|
|
RETURN((taskqid_t)0);
|
|
}
|
|
|
|
RETURN((taskqid_t)wq);
|
|
}
|
|
EXPORT_SYMBOL(__taskq_dispatch);
|
|
|
|
/* XXX - We must fully implement dynamic workqueues since they make a
|
|
* significant impact in terms of performance. For now I've made
|
|
* a trivial compromise. If you ask for one thread you get one
|
|
* thread, if you ask for more than that you get one per core.
|
|
* It's unclear if you ever really need/want more than one per-core
|
|
* anyway. More analysis is required.
|
|
*
|
|
* name - Workqueue names are limited to 10 chars
|
|
* pri - Ignore priority
|
|
* min - Ignored until this is a dynamic thread pool
|
|
* max - Ignored until this is a dynamic thread pool
|
|
* flags - Ignored until this is a dynamic thread_pool
|
|
*/
|
|
taskq_t *
|
|
__taskq_create(const char *name, int nthreads, pri_t pri,
|
|
int minalloc, int maxalloc, uint_t flags)
|
|
{
|
|
taskq_t *tq;
|
|
ENTRY;
|
|
|
|
if (nthreads == 1)
|
|
tq = create_singlethread_workqueue(name);
|
|
else
|
|
tq = create_workqueue(name);
|
|
|
|
return tq;
|
|
}
|
|
EXPORT_SYMBOL(__taskq_create);
|
|
|
|
void
|
|
__taskq_destroy(taskq_t *tq)
|
|
{
|
|
ENTRY;
|
|
destroy_workqueue(tq);
|
|
EXIT;
|
|
}
|
|
EXPORT_SYMBOL(__taskq_destroy);
|
|
|
|
void
|
|
__taskq_wait(taskq_t *tq)
|
|
{
|
|
ENTRY;
|
|
flush_workqueue(tq);
|
|
EXIT;
|
|
}
|
|
EXPORT_SYMBOL(__taskq_wait);
|