Replace struct spl_task with struct taskq_ent

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

diff --git a/module/spl/spl-taskq.c b/module/spl/spl-taskq.c
index f9ee570351c4acb7f125b99c10a86a1844058ddc..50d32e021ae98e983b754bb56e4168bbe573ba76 100644 (file)
--- a/module/spl/spl-taskq.c
+++ b/module/spl/spl-taskq.c
@@ -38,22 +38,22 @@
 taskq_t *system_taskq;
 EXPORT_SYMBOL(system_taskq);
 
-typedef struct spl_task {
-        spinlock_t              t_lock;
-        struct list_head        t_list;
-        taskqid_t               t_id;
-        task_func_t             *t_func;
-        void                    *t_arg;
-} spl_task_t;
+typedef struct taskq_ent {
+        spinlock_t              tqent_lock;
+        struct list_head        tqent_list;
+        taskqid_t               tqent_id;
+        task_func_t             *tqent_func;
+        void                    *tqent_arg;
+} taskq_ent_t;
 
 /*
  * 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.
  */
-static spl_task_t *
+static taskq_ent_t *
 task_alloc(taskq_t *tq, uint_t flags)
 {
-        spl_task_t *t;
+        taskq_ent_t *t;
         int count = 0;
         SENTRY;
 
@@ -62,10 +62,10 @@ task_alloc(taskq_t *tq, uint_t flags)
         ASSERT(!((flags & TQ_SLEEP) && (flags & TQ_NOSLEEP))); /* Not both */
         ASSERT(spin_is_locked(&tq->tq_lock));
 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)) {
-                t = list_entry(tq->tq_free_list.next, spl_task_t, t_list);
-                list_del_init(&t->t_list);
+                t = list_entry(tq->tq_free_list.next, taskq_ent_t, tqent_list);
+                list_del_init(&t->tqent_list);
                 SRETURN(t);
         }
 
@@ -73,15 +73,15 @@ retry:
         if (flags & TQ_NOALLOC)
                 SRETURN(NULL);
 
-        /* Hit maximum spl_task_t pool size */
+        /* Hit maximum taskq_ent_t pool size */
         if (tq->tq_nalloc >= tq->tq_maxalloc) {
                 if (flags & TQ_NOSLEEP)
                         SRETURN(NULL);
 
                 /*
                  * Sleep periodically polling the free list for an available
-                 * spl_task_t. Dispatching with TQ_SLEEP should always succeed
-                 * but we cannot block forever waiting for an spl_taskq_t to
+                 * taskq_ent_t. Dispatching with TQ_SLEEP should always succeed
+                 * but we cannot block forever waiting for an taskq_entq_t to
                  * show up in the free list, otherwise a deadlock can happen.
                  *
                  * 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);
-        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);
 
         if (t) {
-                spin_lock_init(&t->t_lock);
-                INIT_LIST_HEAD(&t->t_list);
-                t->t_id = 0;
-                t->t_func = NULL;
-                t->t_arg = NULL;
+                spin_lock_init(&t->tqent_lock);
+                INIT_LIST_HEAD(&t->tqent_list);
+                t->tqent_id = 0;
+                t->tqent_func = NULL;
+                t->tqent_arg = NULL;
                 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.
  */
 static void
-task_free(taskq_t *tq, spl_task_t *t)
+task_free(taskq_t *tq, taskq_ent_t *t)
 {
         SENTRY;
 
         ASSERT(tq);
         ASSERT(t);
        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--;
 
        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
- * 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
-task_done(taskq_t *tq, spl_task_t *t)
+task_done(taskq_t *tq, taskq_ent_t *t)
 {
        SENTRY;
        ASSERT(tq);
        ASSERT(t);
        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) {
-               t->t_id = 0;
-               t->t_func = NULL;
-               t->t_arg = NULL;
-                list_add_tail(&t->t_list, &tq->tq_free_list);
+               t->tqent_id = 0;
+               t->tqent_func = NULL;
+               t->tqent_arg = NULL;
+                list_add_tail(&t->tqent_list, &tq->tq_free_list);
        } else {
                task_free(tq, t);
        }
@@ -245,7 +245,7 @@ EXPORT_SYMBOL(__taskq_member);
 taskqid_t
 __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;
         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)
                SGOTO(out, rc = 0);
 
-       spin_lock(&t->t_lock);
+       spin_lock(&t->tqent_lock);
 
        /* Queue to the priority list instead of the pending list */
        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
-               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++;
-        t->t_func = func;
-        t->t_arg = arg;
-       spin_unlock(&t->t_lock);
+        t->tqent_func = func;
+        t->tqent_arg = arg;
+       spin_unlock(&t->tqent_lock);
 
        wake_up(&tq->tq_work_waitq);
 out:
@@ -294,7 +294,6 @@ out:
        SRETURN(rc);
 }
 EXPORT_SYMBOL(__taskq_dispatch);
-
 /*
  * Returns the lowest incomplete taskqid_t.  The taskqid_t may
  * 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)
 {
        taskqid_t lowest_id = tq->tq_next_id;
-        spl_task_t *t;
+        taskq_ent_t *t;
        SENTRY;
 
        ASSERT(tq);
        ASSERT(spin_is_locked(&tq->tq_lock));
 
        if (!list_empty(&tq->tq_pend_list)) {
-               t = list_entry(tq->tq_pend_list.next, spl_task_t, t_list);
-               lowest_id = MIN(lowest_id, t->t_id);
+               t = list_entry(tq->tq_pend_list.next, taskq_ent_t, tqent_list);
+               lowest_id = MIN(lowest_id, t->tqent_id);
        }
 
        if (!list_empty(&tq->tq_prio_list)) {
-               t = list_entry(tq->tq_prio_list.next, spl_task_t, t_list);
-               lowest_id = MIN(lowest_id, t->t_id);
+               t = list_entry(tq->tq_prio_list.next, taskq_ent_t, tqent_list);
+               lowest_id = MIN(lowest_id, t->tqent_id);
        }
 
        if (!list_empty(&tq->tq_work_list)) {
-               t = list_entry(tq->tq_work_list.next, spl_task_t, t_list);
-               lowest_id = MIN(lowest_id, t->t_id);
+               t = list_entry(tq->tq_work_list.next, taskq_ent_t, tqent_list);
+               lowest_id = MIN(lowest_id, t->tqent_id);
        }
 
        SRETURN(lowest_id);
@@ -334,9 +333,9 @@ taskq_lowest_id(taskq_t *tq)
  * taskqid.
  */
 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;
 
        SENTRY;
@@ -345,14 +344,14 @@ taskq_insert_in_order(taskq_t *tq, spl_task_t *t)
        ASSERT(spin_is_locked(&tq->tq_lock));
 
        list_for_each_prev(l, &tq->tq_work_list) {
-               w = list_entry(l, spl_task_t, t_list);
-               if (w->t_id < t->t_id) {
-                       list_add(&t->t_list, l);
+               w = list_entry(l, taskq_ent_t, tqent_list);
+               if (w->tqent_id < t->tqent_id) {
+                       list_add(&t->tqent_list, l);
                        break;
                }
        }
        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;
 }
@@ -364,7 +363,7 @@ taskq_thread(void *args)
         sigset_t blocked;
        taskqid_t id;
         taskq_t *tq = args;
-        spl_task_t *t;
+        taskq_ent_t *t;
        struct list_head *pend_list;
        SENTRY;
 
@@ -406,18 +405,18 @@ taskq_thread(void *args)
                        pend_list = NULL;
 
                if (pend_list) {
-                        t = list_entry(pend_list->next, spl_task_t, t_list);
-                        list_del_init(&t->t_list);
+                        t = list_entry(pend_list->next, taskq_ent_t, tqent_list);
+                        list_del_init(&t->tqent_list);
                        taskq_insert_in_order(tq, t);
                         tq->tq_nactive++;
                        spin_unlock_irqrestore(&tq->tq_lock, tq->tq_lock_flags);
 
                        /* 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);
                         tq->tq_nactive--;
-                       id = t->t_id;
+                       id = t->tqent_id;
                         task_done(tq, t);
 
                        /* When the current lowest outstanding taskqid is
@@ -529,7 +528,7 @@ EXPORT_SYMBOL(__taskq_create);
 void
 __taskq_destroy(taskq_t *tq)
 {
-       spl_task_t *t;
+       taskq_ent_t *t;
        int i, nthreads;
        SENTRY;
 
@@ -549,8 +548,8 @@ __taskq_destroy(taskq_t *tq)
         spin_lock_irqsave(&tq->tq_lock, tq->tq_lock_flags);
 
         while (!list_empty(&tq->tq_free_list)) {
-               t = list_entry(tq->tq_free_list.next, spl_task_t, t_list);
-               list_del_init(&t->t_list);
+               t = list_entry(tq->tq_free_list.next, taskq_ent_t, tqent_list);
+               list_del_init(&t->tqent_list);
                 task_free(tq, t);
         }
 
@@ -562,7 +561,7 @@ __taskq_destroy(taskq_t *tq)
         ASSERT(list_empty(&tq->tq_prio_list));
 
         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));
 
        SEXIT;