xfs: move the CIL workqueue to the CIL

We only use the CIL workqueue in the CIL, so it makes no sense to
hang it off the xfs_mount and have to walk multiple pointers back up
to the mount when we have the CIL structures right there.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>

diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index 17785f4..ccd621e 100644 (file)
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -1151,7 +1151,7 @@ xlog_cil_push_background(
        spin_lock(&cil->xc_push_lock);
        if (cil->xc_push_seq < cil->xc_current_sequence) {
                cil->xc_push_seq = cil->xc_current_sequence;
-               queue_work(log->l_mp->m_cil_workqueue, &cil->xc_ctx->push_work);
+               queue_work(cil->xc_push_wq, &cil->xc_ctx->push_work);
        }
 
        /*
@@ -1217,7 +1217,7 @@ xlog_cil_push_now(
 
        /* start on any pending background push to minimise wait time on it */
        if (!async)
-               flush_workqueue(log->l_mp->m_cil_workqueue);
+               flush_workqueue(cil->xc_push_wq);
 
        /*
         * If the CIL is empty or we've already pushed the sequence then
@@ -1231,7 +1231,7 @@ xlog_cil_push_now(
 
        cil->xc_push_seq = push_seq;
        cil->xc_push_commit_stable = async;
-       queue_work(log->l_mp->m_cil_workqueue, &cil->xc_ctx->push_work);
+       queue_work(cil->xc_push_wq, &cil->xc_ctx->push_work);
        spin_unlock(&cil->xc_push_lock);
 }
 
@@ -1470,6 +1470,15 @@ xlog_cil_init(
        cil = kmem_zalloc(sizeof(*cil), KM_MAYFAIL);
        if (!cil)
                return -ENOMEM;
+       /*
+        * Limit the CIL pipeline depth to 4 concurrent works to bound the
+        * concurrency the log spinlocks will be exposed to.
+        */
+       cil->xc_push_wq = alloc_workqueue("xfs-cil/%s",
+                       XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM | WQ_UNBOUND),
+                       4, log->l_mp->m_super->s_id);
+       if (!cil->xc_push_wq)
+               goto out_destroy_cil;
 
        INIT_LIST_HEAD(&cil->xc_cil);
        INIT_LIST_HEAD(&cil->xc_committing);
@@ -1486,6 +1495,10 @@ xlog_cil_init(
        xlog_cil_ctx_switch(cil, ctx);
 
        return 0;
+
+out_destroy_cil:
+       kmem_free(cil);
+       return -ENOMEM;
 }
 
 void
@@ -1499,6 +1512,7 @@ xlog_cil_destroy(
        }
 
        ASSERT(list_empty(&log->l_cilp->xc_cil));
+       destroy_workqueue(log->l_cilp->xc_push_wq);
        kmem_free(log->l_cilp);
 }
 

diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 5aaaf5f..844fbee 100644 (file)
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -272,6 +272,7 @@ struct xfs_cil {
        struct xlog             *xc_log;
        struct list_head        xc_cil;
        spinlock_t              xc_cil_lock;
+       struct workqueue_struct *xc_push_wq;
 
        struct rw_semaphore     xc_ctx_lock ____cacheline_aligned_in_smp;
        struct xfs_cil_ctx      *xc_ctx;

diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 3214310..2266c6a 100644 (file)
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -107,7 +107,6 @@ typedef struct xfs_mount {
        struct xfs_mru_cache    *m_filestream;  /* per-mount filestream data */
        struct workqueue_struct *m_buf_workqueue;
        struct workqueue_struct *m_unwritten_workqueue;
-       struct workqueue_struct *m_cil_workqueue;
        struct workqueue_struct *m_reclaim_workqueue;
        struct workqueue_struct *m_sync_workqueue;
        struct workqueue_struct *m_blockgc_wq;

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 6d42883..7b55464 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -518,21 +518,11 @@ xfs_init_mount_workqueues(
        if (!mp->m_unwritten_workqueue)
                goto out_destroy_buf;
 
-       /*
-        * Limit the CIL pipeline depth to 4 concurrent works to bound the
-        * concurrency the log spinlocks will be exposed to.
-        */
-       mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
-                       XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM | WQ_UNBOUND),
-                       4, mp->m_super->s_id);
-       if (!mp->m_cil_workqueue)
-               goto out_destroy_unwritten;
-
        mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s",
                        XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM),
                        0, mp->m_super->s_id);
        if (!mp->m_reclaim_workqueue)
-               goto out_destroy_cil;
+               goto out_destroy_unwritten;
 
        mp->m_blockgc_wq = alloc_workqueue("xfs-blockgc/%s",
                        XFS_WQFLAGS(WQ_UNBOUND | WQ_FREEZABLE | WQ_MEM_RECLAIM),
@@ -559,8 +549,6 @@ out_destroy_blockgc:
        destroy_workqueue(mp->m_blockgc_wq);
 out_destroy_reclaim:
        destroy_workqueue(mp->m_reclaim_workqueue);
-out_destroy_cil:
-       destroy_workqueue(mp->m_cil_workqueue);
 out_destroy_unwritten:
        destroy_workqueue(mp->m_unwritten_workqueue);
 out_destroy_buf:
@@ -577,7 +565,6 @@ xfs_destroy_mount_workqueues(
        destroy_workqueue(mp->m_blockgc_wq);
        destroy_workqueue(mp->m_inodegc_wq);
        destroy_workqueue(mp->m_reclaim_workqueue);
-       destroy_workqueue(mp->m_cil_workqueue);
        destroy_workqueue(mp->m_unwritten_workqueue);
        destroy_workqueue(mp->m_buf_workqueue);
 }