When the owner is killed, vhost_worker_killed() detaches the worker
from the vqs. A bio completing after that fails to queue the
completion work, so its request stays on llhead and is never removed
from req_inflight. vhost_blk_flush() on release then waits forever
and the process is stuck in D state. Any kill of a VM with I/O in
flight can hit this.

If the work cannot be queued, drop the completed requests right in
the bio end_io: forget them without writing a status, as there is no
guest left to see it. llist_del_all() makes sure a request is dropped
once even if it races with the last run of the host kick handler.
forget_request() can now run in irq context, so take flush_lock with
interrupts disabled. The end_io may run in atomic context and the
request buffers may be vmalloc'ed, so free them on release instead:
a dropped request is the one left with ->inflight set.

Once a request is on llhead, a concurrent consumer may forget it and
let release free the request array and blk while the end_io is still
using blk_vq. Keep the end_io tail in an RCU read-side section and
wait for a grace period before freeing the requests. The same window
existed before with the host kick handler as the consumer.

https://virtuozzo.atlassian.net/browse/VSTOR-152175
Feature: vhost-blk: in-kernel accelerator for virtio-blk guests
Signed-off-by: Alexander Ivanov <[email protected]>
---
 drivers/vhost/blk.c | 52 +++++++++++++++++++++++++++++++++------------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/drivers/vhost/blk.c b/drivers/vhost/blk.c
index b95358cdf3bc..b67255580031 100644
--- a/drivers/vhost/blk.c
+++ b/drivers/vhost/blk.c
@@ -146,6 +146,8 @@ static inline int vhost_blk_set_status(struct vhost_blk_req 
*req, u8 status)
        return 0;
 }
 
+static void vhost_blk_drop_completed(struct vhost_blk_vq *blk_vq);
+
 static void vhost_blk_req_done(struct bio *bio)
 {
        struct vhost_blk_req *req = bio->bi_private;
@@ -168,8 +170,14 @@ static void vhost_blk_req_done(struct bio *bio)
        }
 
        if (atomic_dec_and_test(&req->bio_nr)) {
-               llist_add(&req->llnode, &req->blk_vq->llhead);
-               vhost_vq_work_queue(&req->blk_vq->vq, &req->blk_vq->work);
+               struct vhost_blk_vq *blk_vq = req->blk_vq;
+
+               /* req and blk may be freed once req is on llhead */
+               rcu_read_lock();
+               llist_add(&req->llnode, &blk_vq->llhead);
+               if (!vhost_vq_work_queue(&blk_vq->vq, &blk_vq->work))
+                       vhost_blk_drop_completed(blk_vq);
+               rcu_read_unlock();
        }
 }
 
@@ -394,22 +402,34 @@ static inline void vhost_blk_bio_send(struct 
vhost_blk_req *req)
 
 static inline void note_request(struct vhost_blk_req *req)
 {
-       spin_lock(&req->blk->flush_lock);
+       spin_lock_irq(&req->blk->flush_lock);
        req->req_bin = req->blk->new_req_bin;
        atomic_inc(&req->blk->req_inflight[req->req_bin]);
-       spin_unlock(&req->blk->flush_lock);
+       spin_unlock_irq(&req->blk->flush_lock);
 }
 
 static inline void forget_request(struct vhost_blk_req *req)
 {
        struct vhost_blk *blk = req->blk;
+       unsigned long flags;
        int zero;
 
-       spin_lock(&blk->flush_lock);
+       spin_lock_irqsave(&blk->flush_lock, flags);
        zero = atomic_dec_and_test(&blk->req_inflight[req->req_bin]);
        if (zero && blk->during_flush)
                wake_up(&blk->flush_wait);
-       spin_unlock(&blk->flush_lock);
+       spin_unlock_irqrestore(&blk->flush_lock, flags);
+}
+
+/* Called when the worker is killed: nobody will complete these to the guest */
+static void vhost_blk_drop_completed(struct vhost_blk_vq *blk_vq)
+{
+       struct vhost_blk_req *req, *tmp;
+       struct llist_node *llnode;
+
+       llnode = llist_del_all(&blk_vq->llhead);
+       llist_for_each_entry_safe(req, tmp, llnode, llnode)
+               forget_request(req);
 }
 
 static int vhost_blk_req_submit(struct vhost_blk_req *req)
@@ -688,12 +708,12 @@ static void vhost_blk_flush(struct vhost_blk *blk)
 {
        int flush_bin;
 
-       spin_lock(&blk->flush_lock);
+       spin_lock_irq(&blk->flush_lock);
        WARN_ON(blk->during_flush);
        blk->during_flush = 1;
        flush_bin = blk->new_req_bin;
        blk->new_req_bin = !blk->new_req_bin;
-       spin_unlock(&blk->flush_lock);
+       spin_unlock_irq(&blk->flush_lock);
 
        vhost_dev_flush(&blk->dev);
        /*
@@ -707,15 +727,15 @@ static void vhost_blk_flush(struct vhost_blk *blk)
         */
        wait_event(blk->flush_wait, 
!atomic_read(&blk->req_inflight[flush_bin]));
 
-       spin_lock(&blk->flush_lock);
+       spin_lock_irq(&blk->flush_lock);
        blk->during_flush = 0;
-       spin_unlock(&blk->flush_lock);
+       spin_unlock_irq(&blk->flush_lock);
 }
 
 static void vhost_blk_drop_backend(struct vhost_blk *blk)
 {
        struct vhost_virtqueue *vq;
-       int i;
+       int i, j;
 
        if (!blk->backend)
                return;
@@ -729,10 +749,16 @@ static void vhost_blk_drop_backend(struct vhost_blk *blk)
        }
 
        vhost_blk_flush(blk);
+       synchronize_rcu();
 
        for (i = 0; i < VHOST_BLK_VQ_MAX; i++) {
-               kvfree(blk->vqs[i].req);
-               blk->vqs[i].req = NULL;
+               struct vhost_blk_vq *blk_vq = &blk->vqs[i];
+
+               for (j = 0; blk_vq->req && j < blk_vq->vq.num; j++)
+                       if (blk_vq->req[j].inflight)
+                               vhost_blk_req_cleanup(&blk_vq->req[j]);
+               kvfree(blk_vq->req);
+               blk_vq->req = NULL;
        }
 
        fput(blk->backend);
-- 
2.53.0

_______________________________________________
Devel mailing list
[email protected]
https://lists.openvz.org/mailman/listinfo/devel

Reply via email to