block, cfq: unlink cfq_io_context's immediately

cic is association between io_context and request_queue.  A cic is
linked from both ioc and q and should be destroyed when either one
goes away.  As ioc and q both have their own locks, locking becomes a
bit complex - both orders work for removal from one but not from the
other.

Currently, cfq tries to circumvent this locking order issue with RCU.
ioc->lock nests inside queue_lock but the radix tree and cic's are
also protected by RCU allowing either side to walk their lists without
grabbing lock.

This rather unconventional use of RCU quickly devolves into extremely
fragile convolution.  e.g. The following is from cfqd going away too
soon after ioc and q exits raced.

 general protection fault: 0000 [#1] PREEMPT SMP
 CPU 2
 Modules linked in:
 [   88.503444]
 Pid: 599, comm: hexdump Not tainted 3.1.0-rc10-work+ #158 Bochs Bochs
 RIP: 0010:[<ffffffff81397628>]  [<ffffffff81397628>] cfq_exit_single_io_context+0x58/0xf0
 ...
 Call Trace:
  [<ffffffff81395a4a>] call_for_each_cic+0x5a/0x90
  [<ffffffff81395ab5>] cfq_exit_io_context+0x15/0x20
  [<ffffffff81389130>] exit_io_context+0x100/0x140
  [<ffffffff81098a29>] do_exit+0x579/0x850
  [<ffffffff81098d5b>] do_group_exit+0x5b/0xd0
  [<ffffffff81098de7>] sys_exit_group+0x17/0x20
  [<ffffffff81b02f2b>] system_call_fastpath+0x16/0x1b

The only real hot path here is cic lookup during request
initialization and avoiding extra locking requires very confined use
of RCU.  This patch makes cic removal from both ioc and request_queue
perform double-locking and unlink immediately.

* From q side, the change is almost trivial as ioc->lock nests inside
  queue_lock.  It just needs to grab each ioc->lock as it walks
  cic_list and unlink it.

* From ioc side, it's a bit more difficult because of inversed lock
  order.  ioc needs its lock to walk its cic_list but can't grab the
  matching queue_lock and needs to perform unlock-relock dancing.

  Unlinking is now wholly done from put_io_context() and fast path is
  optimized by using the queue_lock the caller already holds, which is
  by far the most common case.  If the ioc accessed multiple devices,
  it tries with trylock.  In unlikely cases of fast path failure, it
  falls back to full double-locking dance from workqueue.

Double-locking isn't the prettiest thing in the world but it's *far*
simpler and more understandable than RCU trick without adding any
meaningful overhead.

This still leaves a lot of now unnecessary RCU logics.  Future patches
will trim them.

-v2: Vivek pointed out that cic->q was being dereferenced after
     cic->release() was called.  Updated to use local variable @this_q
     instead.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 137 insertions, 29 deletions

diff --git a/block/blk-ioc.c b/block/blk-ioc.c
index 6f59fbad93d9..fb23965595da 100644
--- a/block/blk-ioc.c
+++ b/block/blk-ioc.c
@@ -29,55 +29,164 @@ void get_io_context(struct io_context *ioc)
 }
 EXPORT_SYMBOL(get_io_context);
 
-static void cfq_dtor(struct io_context *ioc)
+/*
+ * Releasing ioc may nest into another put_io_context() leading to nested
+ * fast path release.  As the ioc's can't be the same, this is okay but
+ * makes lockdep whine.  Keep track of nesting and use it as subclass.
+ */
+#ifdef CONFIG_LOCKDEP
+#define ioc_release_depth(q)            ((q) ? (q)->ioc_release_depth : 0)
+#define ioc_release_depth_inc(q)        (q)->ioc_release_depth++
+#define ioc_release_depth_dec(q)        (q)->ioc_release_depth--
+#else
+#define ioc_release_depth(q)            0
+#define ioc_release_depth_inc(q)        do { } while (0)
+#define ioc_release_depth_dec(q)        do { } while (0)
+#endif
+
+/*
+ * Slow path for ioc release in put_io_context().  Performs double-lock
+ * dancing to unlink all cic's and then frees ioc.
+ */
+static void ioc_release_fn(struct work_struct *work)
 {
-        if (!hlist_empty(&ioc->cic_list)) {
-                struct cfq_io_context *cic;
+        struct io_context *ioc = container_of(work, struct io_context,
+                                              release_work);
+        struct request_queue *last_q = NULL;
+
+        spin_lock_irq(&ioc->lock);
+
+        while (!hlist_empty(&ioc->cic_list)) {
+                struct cfq_io_context *cic = hlist_entry(ioc->cic_list.first,
+                                                         struct cfq_io_context,
+                                                         cic_list);
+                struct request_queue *this_q = cic->q;
+
+                if (this_q != last_q) {
+                        /*
+                         * Need to switch to @this_q.  Once we release
+                         * @ioc->lock, it can go away along with @cic.
+                         * Hold on to it.
+                         */
+                        __blk_get_queue(this_q);
+
+                        /*
+                         * blk_put_queue() might sleep thanks to kobject
+                         * idiocy.  Always release both locks, put and
+                         * restart.
+                         */
+                        if (last_q) {
+                                spin_unlock(last_q->queue_lock);
+                                spin_unlock_irq(&ioc->lock);
+                                blk_put_queue(last_q);
+                        } else {
+                                spin_unlock_irq(&ioc->lock);
+                        }
+
+                        last_q = this_q;
+                        spin_lock_irq(this_q->queue_lock);
+                        spin_lock(&ioc->lock);
+                        continue;
+                }
+                ioc_release_depth_inc(this_q);
+                cic->exit(cic);
+                cic->release(cic);
+                ioc_release_depth_dec(this_q);
+        }
 
-                cic = hlist_entry(ioc->cic_list.first, struct cfq_io_context,
-                                                                cic_list);
-                cic->dtor(ioc);
+        if (last_q) {
+                spin_unlock(last_q->queue_lock);
+                spin_unlock_irq(&ioc->lock);
+                blk_put_queue(last_q);
+        } else {
+                spin_unlock_irq(&ioc->lock);
         }
+
+        kmem_cache_free(iocontext_cachep, ioc);
 }
 
 /**
  * put_io_context - put a reference of io_context
  * @ioc: io_context to put
+ * @locked_q: request_queue the caller is holding queue_lock of (hint)
  *
  * Decrement reference count of @ioc and release it if the count reaches
- * zero.
+ * zero.  If the caller is holding queue_lock of a queue, it can indicate
+ * that with @locked_q.  This is an optimization hint and the caller is
+ * allowed to pass in %NULL even when it's holding a queue_lock.
  */
-void put_io_context(struct io_context *ioc)
+void put_io_context(struct io_context *ioc, struct request_queue *locked_q)
 {
+        struct request_queue *last_q = locked_q;
+        unsigned long flags;
+
         if (ioc == NULL)
                 return;
 
         BUG_ON(atomic_long_read(&ioc->refcount) <= 0);
+        if (locked_q)
+                lockdep_assert_held(locked_q->queue_lock);
 
         if (!atomic_long_dec_and_test(&ioc->refcount))
                 return;
 
-        rcu_read_lock();
-        cfq_dtor(ioc);
-        rcu_read_unlock();
-
-        kmem_cache_free(iocontext_cachep, ioc);
-}
-EXPORT_SYMBOL(put_io_context);
+        /*
+         * Destroy @ioc.  This is a bit messy because cic's are chained
+         * from both ioc and queue, and ioc->lock nests inside queue_lock.
+         * The inner ioc->lock should be held to walk our cic_list and then
+         * for each cic the outer matching queue_lock should be grabbed.
+         * ie. We need to do reverse-order double lock dancing.
+         *
+         * Another twist is that we are often called with one of the
+         * matching queue_locks held as indicated by @locked_q, which
+         * prevents performing double-lock dance for other queues.
+         *
+         * So, we do it in two stages.  The fast path uses the queue_lock
+         * the caller is holding and, if other queues need to be accessed,
+         * uses trylock to avoid introducing locking dependency.  This can
+         * handle most cases, especially if @ioc was performing IO on only
+         * single device.
+         *
+         * If trylock doesn't cut it, we defer to @ioc->release_work which
+         * can do all the double-locking dancing.
+         */
+        spin_lock_irqsave_nested(&ioc->lock, flags,
+                                 ioc_release_depth(locked_q));
+
+        while (!hlist_empty(&ioc->cic_list)) {
+                struct cfq_io_context *cic = hlist_entry(ioc->cic_list.first,
+                                                         struct cfq_io_context,
+                                                         cic_list);
+                struct request_queue *this_q = cic->q;
+
+                if (this_q != last_q) {
+                        if (last_q && last_q != locked_q)
+                                spin_unlock(last_q->queue_lock);
+                        last_q = NULL;
+
+                        if (!spin_trylock(this_q->queue_lock))
+                                break;
+                        last_q = this_q;
+                        continue;
+                }
+                ioc_release_depth_inc(this_q);
+                cic->exit(cic);
+                cic->release(cic);
+                ioc_release_depth_dec(this_q);
+        }
 
-static void cfq_exit(struct io_context *ioc)
-{
-        rcu_read_lock();
+        if (last_q && last_q != locked_q)
+                spin_unlock(last_q->queue_lock);
 
-        if (!hlist_empty(&ioc->cic_list)) {
-                struct cfq_io_context *cic;
+        spin_unlock_irqrestore(&ioc->lock, flags);
 
-                cic = hlist_entry(ioc->cic_list.first, struct cfq_io_context,
-                                                                cic_list);
-                cic->exit(ioc);
-        }
-        rcu_read_unlock();
+        /* if no cic's left, we're done; otherwise, kick release_work */
+        if (hlist_empty(&ioc->cic_list))
+                kmem_cache_free(iocontext_cachep, ioc);
+        else
+                schedule_work(&ioc->release_work);
 }
+EXPORT_SYMBOL(put_io_context);
 
 /* Called by the exiting task */
 void exit_io_context(struct task_struct *task)
@@ -92,10 +201,8 @@ void exit_io_context(struct task_struct *task)
         task->io_context = NULL;
         task_unlock(task);
 
-        if (atomic_dec_and_test(&ioc->nr_tasks))
-                cfq_exit(ioc);
-
-        put_io_context(ioc);
+        atomic_dec(&ioc->nr_tasks);
+        put_io_context(ioc, NULL);
 }
 
 static struct io_context *create_task_io_context(struct task_struct *task,
@@ -115,6 +222,7 @@ static struct io_context *create_task_io_context(struct task_struct *task,
         spin_lock_init(&ioc->lock);
         INIT_RADIX_TREE(&ioc->radix_root, GFP_ATOMIC | __GFP_HIGH);
         INIT_HLIST_HEAD(&ioc->cic_list);
+        INIT_WORK(&ioc->release_work, ioc_release_fn);
 
         /* try to install, somebody might already have beaten us to it */
         task_lock(task);