Commit a8f2e5c8 authored by Paolo Bonzini's avatar Paolo Bonzini Committed by Michael S. Tsirkin
Browse files

virtio-scsi: use aio handler for data plane 



In addition to handling IO in vcpu thread and in io thread, dataplane
introduces yet another mode: handling it by AioContext.

This reuses the same handler as previous modes, which triggers races as
these were not designed to be reentrant.  Use a separate handler just
for aio, and disable regular handlers when dataplane is active.

Reviewed-by: default avatarCornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Reviewed-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent 8a2fad57

hw/scsi/virtio-scsi-dataplane.c

+39 −4
Original line number Diff line number Diff line
@@ -38,7 +38,35 @@ void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread) 
    }

}



static int virtio_scsi_vring_init(VirtIOSCSI *s, VirtQueue *vq, int n)

static void virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,

                                              VirtQueue *vq)

{

    VirtIOSCSI *s = (VirtIOSCSI *)vdev;



    assert(s->ctx && s->dataplane_started);

    virtio_scsi_handle_cmd_vq(s, vq);

}



static void virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,

                                               VirtQueue *vq)

{

    VirtIOSCSI *s = VIRTIO_SCSI(vdev);



    assert(s->ctx && s->dataplane_started);

    virtio_scsi_handle_ctrl_vq(s, vq);

}



static void virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,

                                                VirtQueue *vq)

{

    VirtIOSCSI *s = VIRTIO_SCSI(vdev);



    assert(s->ctx && s->dataplane_started);

    virtio_scsi_handle_event_vq(s, vq);

}



static int virtio_scsi_vring_init(VirtIOSCSI *s, VirtQueue *vq, int n,

                                  void (*fn)(VirtIODevice *vdev, VirtQueue *vq))

{

    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
@@ -54,6 +82,7 @@ static int virtio_scsi_vring_init(VirtIOSCSI *s, VirtQueue *vq, int n) 
    }



    virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, true, true);

    virtio_set_queue_aio(vq, fn);

    return 0;

}
@@ -71,9 +100,12 @@ static void virtio_scsi_clear_aio(VirtIOSCSI *s) 
    int i;



    virtio_queue_aio_set_host_notifier_handler(vs->ctrl_vq, s->ctx, false, false);

    virtio_set_queue_aio(vs->ctrl_vq, NULL);

    virtio_queue_aio_set_host_notifier_handler(vs->event_vq, s->ctx, false, false);

    virtio_set_queue_aio(vs->event_vq, NULL);

    for (i = 0; i < vs->conf.num_queues; i++) {

        virtio_queue_aio_set_host_notifier_handler(vs->cmd_vqs[i], s->ctx, false, false);

        virtio_set_queue_aio(vs->cmd_vqs[i], NULL);

    }

}
@@ -104,16 +136,19 @@ void virtio_scsi_dataplane_start(VirtIOSCSI *s) 
    }



    aio_context_acquire(s->ctx);

    rc = virtio_scsi_vring_init(s, vs->ctrl_vq, 0);

    rc = virtio_scsi_vring_init(s, vs->ctrl_vq, 0,

                                virtio_scsi_data_plane_handle_ctrl);

    if (rc) {

        goto fail_vrings;

    }

    rc = virtio_scsi_vring_init(s, vs->event_vq, 1);

    rc = virtio_scsi_vring_init(s, vs->event_vq, 1,

                                virtio_scsi_data_plane_handle_event);

    if (rc) {

        goto fail_vrings;

    }

    for (i = 0; i < vs->conf.num_queues; i++) {

        rc = virtio_scsi_vring_init(s, vs->cmd_vqs[i], i + 2);

        rc = virtio_scsi_vring_init(s, vs->cmd_vqs[i], i + 2,

                                    virtio_scsi_data_plane_handle_cmd);

        if (rc) {

            goto fail_vrings;

        }

hw/scsi/virtio-scsi.c

+44 −21
Original line number Diff line number Diff line
@@ -374,7 +374,7 @@ fail: 
    return ret;

}



void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req)

static void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req)

{

    VirtIODevice *vdev = (VirtIODevice *)s;

    uint32_t type;
@@ -412,18 +412,26 @@ void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req) 
    }

}



void virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq)

{

    VirtIOSCSIReq *req;



    while ((req = virtio_scsi_pop_req(s, vq))) {

        virtio_scsi_handle_ctrl_req(s, req);

    }

}



static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)

{

    VirtIOSCSI *s = (VirtIOSCSI *)vdev;

    VirtIOSCSIReq *req;



    if (s->ctx && !s->dataplane_started) {

    if (s->ctx) {

        virtio_scsi_dataplane_start(s);

        if (!s->dataplane_fenced) {

            return;

        }

    while ((req = virtio_scsi_pop_req(s, vq))) {

        virtio_scsi_handle_ctrl_req(s, req);

    }

    virtio_scsi_handle_ctrl_vq(s, vq);

}



static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq *req)
@@ -508,7 +516,7 @@ static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq *req) 
    virtio_scsi_complete_cmd_req(req);

}



bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req)

static bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req)

{

    VirtIOSCSICommon *vs = &s->parent_obj;

    SCSIDevice *d;
@@ -550,7 +558,7 @@ bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req) 
    return true;

}



void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req)

static void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req)

{

    SCSIRequest *sreq = req->sreq;

    if (scsi_req_enqueue(sreq)) {
@@ -560,17 +568,11 @@ void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req) 
    scsi_req_unref(sreq);

}



static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)

void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)

{

    /* use non-QOM casts in the data path */

    VirtIOSCSI *s = (VirtIOSCSI *)vdev;

    VirtIOSCSIReq *req, *next;

    QTAILQ_HEAD(, VirtIOSCSIReq) reqs = QTAILQ_HEAD_INITIALIZER(reqs);



    if (s->ctx && !s->dataplane_started) {

        virtio_scsi_dataplane_start(s);

        return;

    }

    while ((req = virtio_scsi_pop_req(s, vq))) {

        if (virtio_scsi_handle_cmd_req_prepare(s, req)) {

            QTAILQ_INSERT_TAIL(&reqs, req, next);
@@ -582,6 +584,20 @@ static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq) 
    }

}



static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)

{

    /* use non-QOM casts in the data path */

    VirtIOSCSI *s = (VirtIOSCSI *)vdev;



    if (s->ctx) {

        virtio_scsi_dataplane_start(s);

        if (!s->dataplane_fenced) {

            return;

        }

    }

    virtio_scsi_handle_cmd_vq(s, vq);

}



static void virtio_scsi_get_config(VirtIODevice *vdev,

                                   uint8_t *config)

{
@@ -725,17 +741,24 @@ out: 
    }

}



void virtio_scsi_handle_event_vq(VirtIOSCSI *s, VirtQueue *vq)

{

    if (s->events_dropped) {

        virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);

    }

}



static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)

{

    VirtIOSCSI *s = VIRTIO_SCSI(vdev);



    if (s->ctx && !s->dataplane_started) {

    if (s->ctx) {

        virtio_scsi_dataplane_start(s);

        if (!s->dataplane_fenced) {

            return;

        }

    if (s->events_dropped) {

        virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);

    }

    virtio_scsi_handle_event_vq(s, vq);

}



static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense)

include/hw/virtio/virtio-scsi.h

+3 −3
Original line number Diff line number Diff line
@@ -139,9 +139,9 @@ void virtio_scsi_common_realize(DeviceState *dev, Error **errp, 
                                HandleOutput cmd);



void virtio_scsi_common_unrealize(DeviceState *dev, Error **errp);

void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req);

bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req);

void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req);

void virtio_scsi_handle_event_vq(VirtIOSCSI *s, VirtQueue *vq);

void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq);

void virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq);

void virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq, VirtIOSCSIReq *req);

void virtio_scsi_free_req(VirtIOSCSIReq *req);

void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,