c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2025-01-29 03:14:25 +03:00
Code Issues Packages Projects Releases Wiki Activity

Replace struct spl_task with struct taskq_ent

Browse Source 
The spl_task structure was renamed to taskq_ent, and all of
its fields were renamed to have a prefix of 'tqent' rather
than 't'. This was to align with the naming convention which
the ZFS code assumes.  Previously these fields were private
so the name never mattered.

Signed-off-by: Prakash Surya <surya1@llnl.gov>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Issue #65
This commit is contained in:
Prakash Surya 2011-11-11 15:06:35 -08:00 committed by Brian Behlendorf
parent ed948fa72b
commit 046a70c93b
1 changed files with 62 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
module/spl/spl-taskq.c
View File

@ -38,22 +38,22 @@
taskq_t *system_taskq; taskq_t *system_taskq;
EXPORT_SYMBOL(system_taskq); EXPORT_SYMBOL(system_taskq);
typedef struct spl_task { typedef struct taskq_ent {
spinlock_t t_lock; spinlock_t tqent_lock;
struct list_head t_list; struct list_head tqent_list;
taskqid_t t_id; taskqid_t tqent_id;
task_func_t *t_func; task_func_t *tqent_func;
void *t_arg; void *tqent_arg;
} spl_task_t; } taskq_ent_t;
/* /*
* NOTE: Must be called with tq->tq_lock held, returns a list_t which * NOTE: Must be called with tq->tq_lock held, returns a list_t which
* is not attached to the free, work, or pending taskq lists. * is not attached to the free, work, or pending taskq lists.
*/ */
static spl_task_t * static taskq_ent_t *
task_alloc(taskq_t *tq, uint_t flags) task_alloc(taskq_t *tq, uint_t flags)
{ {
spl_task_t *t; taskq_ent_t *t;
int count = 0; int count = 0;
SENTRY; SENTRY;
@ -62,10 +62,10 @@ task_alloc(taskq_t *tq, uint_t flags)
ASSERT(!((flags & TQ_SLEEP) && (flags & TQ_NOSLEEP))); /* Not both */ ASSERT(!((flags & TQ_SLEEP) && (flags & TQ_NOSLEEP))); /* Not both */
ASSERT(spin_is_locked(&tq->tq_lock)); ASSERT(spin_is_locked(&tq->tq_lock));
retry: retry:
/* Acquire spl_task_t's from free list if available */ /* Acquire taskq_ent_t's from free list if available */
if (!list_empty(&tq->tq_free_list) && !(flags & TQ_NEW)) { if (!list_empty(&tq->tq_free_list) && !(flags & TQ_NEW)) {
t = list_entry(tq->tq_free_list.next, spl_task_t, t_list); t = list_entry(tq->tq_free_list.next, taskq_ent_t, tqent_list);
list_del_init(&t->t_list); list_del_init(&t->tqent_list);
SRETURN(t); SRETURN(t);
} }
@ -73,15 +73,15 @@ retry:
if (flags & TQ_NOALLOC) if (flags & TQ_NOALLOC)
SRETURN(NULL); SRETURN(NULL);
/* Hit maximum spl_task_t pool size */ /* Hit maximum taskq_ent_t pool size */
if (tq->tq_nalloc >= tq->tq_maxalloc) { if (tq->tq_nalloc >= tq->tq_maxalloc) {
if (flags & TQ_NOSLEEP) if (flags & TQ_NOSLEEP)
SRETURN(NULL); SRETURN(NULL);
/* /*
* Sleep periodically polling the free list for an available * Sleep periodically polling the free list for an available
* spl_task_t. Dispatching with TQ_SLEEP should always succeed * taskq_ent_t. Dispatching with TQ_SLEEP should always succeed
* but we cannot block forever waiting for an spl_taskq_t to * but we cannot block forever waiting for an taskq_entq_t to
* show up in the free list, otherwise a deadlock can happen. * show up in the free list, otherwise a deadlock can happen.
* *
* Therefore, we need to allocate a new task even if the number * Therefore, we need to allocate a new task even if the number
@ -97,15 +97,15 @@ retry:
} }
spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags); spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags);
t = kmem_alloc(sizeof(spl_task_t), flags & (TQ_SLEEP | TQ_NOSLEEP)); t = kmem_alloc(sizeof(taskq_ent_t), flags & (TQ_SLEEP | TQ_NOSLEEP));
spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags); spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags);
if (t) { if (t) {
spin_lock_init(&t->t_lock); spin_lock_init(&t->tqent_lock);
INIT_LIST_HEAD(&t->t_list); INIT_LIST_HEAD(&t->tqent_list);
t->t_id = 0; t->tqent_id = 0;
t->t_func = NULL; t->tqent_func = NULL;
t->t_arg = NULL; t->tqent_arg = NULL;
tq->tq_nalloc++; tq->tq_nalloc++;
} }
@ -113,20 +113,20 @@ retry:
} }
/* /*
* NOTE: Must be called with tq->tq_lock held, expects the spl_task_t * NOTE: Must be called with tq->tq_lock held, expects the taskq_ent_t
* to already be removed from the free, work, or pending taskq lists. * to already be removed from the free, work, or pending taskq lists.
*/ */
static void static void
task_free(taskq_t *tq, spl_task_t *t) task_free(taskq_t *tq, taskq_ent_t *t)
{ {
SENTRY; SENTRY;
ASSERT(tq); ASSERT(tq);
ASSERT(t); ASSERT(t);
ASSERT(spin_is_locked(&tq->tq_lock)); ASSERT(spin_is_locked(&tq->tq_lock));
ASSERT(list_empty(&t->t_list)); ASSERT(list_empty(&t->tqent_list));
kmem_free(t, sizeof(spl_task_t)); kmem_free(t, sizeof(taskq_ent_t));
tq->tq_nalloc--; tq->tq_nalloc--;
SEXIT; SEXIT;
@ -134,23 +134,23 @@ task_free(taskq_t *tq, spl_task_t *t)
/* /*
* NOTE: Must be called with tq->tq_lock held, either destroys the * NOTE: Must be called with tq->tq_lock held, either destroys the
* spl_task_t if too many exist or moves it to the free list for later use. * taskq_ent_t if too many exist or moves it to the free list for later use.
*/ */
static void static void
task_done(taskq_t *tq, spl_task_t *t) task_done(taskq_t *tq, taskq_ent_t *t)
{ {
SENTRY; SENTRY;
ASSERT(tq); ASSERT(tq);
ASSERT(t); ASSERT(t);
ASSERT(spin_is_locked(&tq->tq_lock)); ASSERT(spin_is_locked(&tq->tq_lock));
list_del_init(&t->t_list); list_del_init(&t->tqent_list);
if (tq->tq_nalloc <= tq->tq_minalloc) { if (tq->tq_nalloc <= tq->tq_minalloc) {
t->t_id = 0; t->tqent_id = 0;
t->t_func = NULL; t->tqent_func = NULL;
t->t_arg = NULL; t->tqent_arg = NULL;
list_add_tail(&t->t_list, &tq->tq_free_list); list_add_tail(&t->tqent_list, &tq->tq_free_list);
} else { } else {
task_free(tq, t); task_free(tq, t);
} }
@ -245,7 +245,7 @@ EXPORT_SYMBOL(__taskq_member);
taskqid_t taskqid_t
__taskq_dispatch(taskq_t *tq, task_func_t func, void *arg, uint_t flags) __taskq_dispatch(taskq_t *tq, task_func_t func, void *arg, uint_t flags)
{ {
spl_task_t *t; taskq_ent_t *t;
taskqid_t rc = 0; taskqid_t rc = 0;
SENTRY; SENTRY;
@ -274,19 +274,19 @@ __taskq_dispatch(taskq_t *tq, task_func_t func, void *arg, uint_t flags)
if ((t = task_alloc(tq, flags)) == NULL) if ((t = task_alloc(tq, flags)) == NULL)
SGOTO(out, rc = 0); SGOTO(out, rc = 0);
spin_lock(&t->t_lock); spin_lock(&t->tqent_lock);
/* Queue to the priority list instead of the pending list */ /* Queue to the priority list instead of the pending list */
if (flags & TQ_FRONT) if (flags & TQ_FRONT)
list_add_tail(&t->t_list, &tq->tq_prio_list); list_add_tail(&t->tqent_list, &tq->tq_prio_list);
else else
list_add_tail(&t->t_list, &tq->tq_pend_list); list_add_tail(&t->tqent_list, &tq->tq_pend_list);
t->t_id = rc = tq->tq_next_id; t->tqent_id = rc = tq->tq_next_id;
tq->tq_next_id++; tq->tq_next_id++;
t->t_func = func; t->tqent_func = func;
t->t_arg = arg; t->tqent_arg = arg;
spin_unlock(&t->t_lock); spin_unlock(&t->tqent_lock);
wake_up(&tq->tq_work_waitq); wake_up(&tq->tq_work_waitq);
out: out:
@ -294,7 +294,6 @@ out:
SRETURN(rc); SRETURN(rc);
} }
EXPORT_SYMBOL(__taskq_dispatch); EXPORT_SYMBOL(__taskq_dispatch);
/* /*
* Returns the lowest incomplete taskqid_t. The taskqid_t may * Returns the lowest incomplete taskqid_t. The taskqid_t may
* be queued on the pending list, on the priority list, or on * be queued on the pending list, on the priority list, or on
@ -305,25 +304,25 @@ static taskqid_t
taskq_lowest_id(taskq_t *tq) taskq_lowest_id(taskq_t *tq)
{ {
taskqid_t lowest_id = tq->tq_next_id; taskqid_t lowest_id = tq->tq_next_id;
spl_task_t *t; taskq_ent_t *t;
SENTRY; SENTRY;
ASSERT(tq); ASSERT(tq);
ASSERT(spin_is_locked(&tq->tq_lock)); ASSERT(spin_is_locked(&tq->tq_lock));
if (!list_empty(&tq->tq_pend_list)) { if (!list_empty(&tq->tq_pend_list)) {
t = list_entry(tq->tq_pend_list.next, spl_task_t, t_list); t = list_entry(tq->tq_pend_list.next, taskq_ent_t, tqent_list);
lowest_id = MIN(lowest_id, t->t_id); lowest_id = MIN(lowest_id, t->tqent_id);
} }
if (!list_empty(&tq->tq_prio_list)) { if (!list_empty(&tq->tq_prio_list)) {
t = list_entry(tq->tq_prio_list.next, spl_task_t, t_list); t = list_entry(tq->tq_prio_list.next, taskq_ent_t, tqent_list);
lowest_id = MIN(lowest_id, t->t_id); lowest_id = MIN(lowest_id, t->tqent_id);
} }
if (!list_empty(&tq->tq_work_list)) { if (!list_empty(&tq->tq_work_list)) {
t = list_entry(tq->tq_work_list.next, spl_task_t, t_list); t = list_entry(tq->tq_work_list.next, taskq_ent_t, tqent_list);
lowest_id = MIN(lowest_id, t->t_id); lowest_id = MIN(lowest_id, t->tqent_id);
} }
SRETURN(lowest_id); SRETURN(lowest_id);
@ -334,9 +333,9 @@ taskq_lowest_id(taskq_t *tq)
* taskqid. * taskqid.
*/ */
static void static void
taskq_insert_in_order(taskq_t *tq, spl_task_t *t) taskq_insert_in_order(taskq_t *tq, taskq_ent_t *t)
{ {
spl_task_t *w; taskq_ent_t *w;
struct list_head *l; struct list_head *l;
SENTRY; SENTRY;
@ -345,14 +344,14 @@ taskq_insert_in_order(taskq_t *tq, spl_task_t *t)
ASSERT(spin_is_locked(&tq->tq_lock)); ASSERT(spin_is_locked(&tq->tq_lock));
list_for_each_prev(l, &tq->tq_work_list) { list_for_each_prev(l, &tq->tq_work_list) {
w = list_entry(l, spl_task_t, t_list); w = list_entry(l, taskq_ent_t, tqent_list);
if (w->t_id < t->t_id) { if (w->tqent_id < t->tqent_id) {
list_add(&t->t_list, l); list_add(&t->tqent_list, l);
break; break;
} }
} }
if (l == &tq->tq_work_list) if (l == &tq->tq_work_list)
list_add(&t->t_list, &tq->tq_work_list); list_add(&t->tqent_list, &tq->tq_work_list);
SEXIT; SEXIT;
} }
@ -364,7 +363,7 @@ taskq_thread(void *args)
sigset_t blocked; sigset_t blocked;
taskqid_t id; taskqid_t id;
taskq_t *tq = args; taskq_t *tq = args;
spl_task_t *t; taskq_ent_t *t;
struct list_head *pend_list; struct list_head *pend_list;
SENTRY; SENTRY;
@ -406,18 +405,18 @@ taskq_thread(void *args)
pend_list = NULL; pend_list = NULL;
if (pend_list) { if (pend_list) {
t = list_entry(pend_list->next, spl_task_t, t_list); t = list_entry(pend_list->next, taskq_ent_t, tqent_list);
list_del_init(&t->t_list); list_del_init(&t->tqent_list);
taskq_insert_in_order(tq, t); taskq_insert_in_order(tq, t);
tq->tq_nactive++; tq->tq_nactive++;
spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags); spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags);
/* Perform the requested task */ /* Perform the requested task */
t->t_func(t->t_arg); t->tqent_func(t->tqent_arg);
spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags); spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags);
tq->tq_nactive--; tq->tq_nactive--;
id = t->t_id; id = t->tqent_id;
task_done(tq, t); task_done(tq, t);
/* When the current lowest outstanding taskqid is /* When the current lowest outstanding taskqid is
@ -529,7 +528,7 @@ EXPORT_SYMBOL(__taskq_create);
void void
__taskq_destroy(taskq_t *tq) __taskq_destroy(taskq_t *tq)
{ {
spl_task_t *t; taskq_ent_t *t;
int i, nthreads; int i, nthreads;
SENTRY; SENTRY;
@ -549,8 +548,8 @@ __taskq_destroy(taskq_t *tq)
spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags); spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags);
while (!list_empty(&tq->tq_free_list)) { while (!list_empty(&tq->tq_free_list)) {
t = list_entry(tq->tq_free_list.next, spl_task_t, t_list); t = list_entry(tq->tq_free_list.next, taskq_ent_t, tqent_list);
list_del_init(&t->t_list); list_del_init(&t->tqent_list);
task_free(tq, t); task_free(tq, t);
} }
@ -562,7 +561,7 @@ __taskq_destroy(taskq_t *tq)
ASSERT(list_empty(&tq->tq_prio_list)); ASSERT(list_empty(&tq->tq_prio_list));
spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags); spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags);
kmem_free(tq->tq_threads, nthreads * sizeof(spl_task_t *)); kmem_free(tq->tq_threads, nthreads * sizeof(taskq_ent_t *));
kmem_free(tq, sizeof(taskq_t)); kmem_free(tq, sizeof(taskq_t));
SEXIT; SEXIT;