Commit 91cb1c9b authored by Fam Zheng's avatar Fam Zheng Committed by Paolo Bonzini
Browse files

virtio-scsi-dataplane: Code to run virtio-scsi on iothread 



This implements the core part of dataplane feature of virtio-scsi.

A few fields are added in VirtIOSCSICommon to maintain the dataplane
status. These fields are managed by a new source file:
virtio-scsi-dataplane.c.

Most code in this file will run on an iothread, unless otherwise
commented as in a global mutex context, such as those functions to
start, stop and setting the iothread property.

Upon start, we set up guest/host event notifiers, in a same way as
virtio-blk does. The handlers then pop request from vring and call into
virtio-scsi.c functions to process it. So we need to make sure make all
those called functions work with iothread, too.

Signed-off-by: default avatarFam Zheng <famz@redhat.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 244e2898

hw/scsi/Makefile.objs

+1 −1
Original line number Diff line number Diff line
@@ -8,6 +8,6 @@ common-obj-$(CONFIG_ESP_PCI) += esp-pci.o 
obj-$(CONFIG_PSERIES) += spapr_vscsi.o



ifeq ($(CONFIG_VIRTIO),y)

obj-y += virtio-scsi.o

obj-y += virtio-scsi.o virtio-scsi-dataplane.o

obj-$(CONFIG_VHOST_SCSI) += vhost-scsi.o

endif

hw/scsi/virtio-scsi-dataplane.c

0 → 100644
+222 −0
Original line number Diff line number Diff line 
/*

 * Virtio SCSI dataplane

 *

 * Copyright Red Hat, Inc. 2014

 *

 * Authors:

 *   Fam Zheng <famz@redhat.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 *

 */



#include "hw/virtio/virtio-scsi.h"

#include "qemu/error-report.h"

#include <hw/scsi/scsi.h>

#include <block/scsi.h>

#include <hw/virtio/virtio-bus.h>

#include "hw/virtio/virtio-access.h"

#include "stdio.h"



/* Context: QEMU global mutex held */

void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread)

{

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);



    assert(!s->ctx);

    s->ctx = iothread_get_aio_context(vs->conf.iothread);



    /* Don't try if transport does not support notifiers. */

    if (!k->set_guest_notifiers || !k->set_host_notifier) {

        fprintf(stderr, "virtio-scsi: Failed to set iothread "

                   "(transport does not support notifiers)");

        exit(1);

    }

}



static VirtIOSCSIVring *virtio_scsi_vring_init(VirtIOSCSI *s,

                                               VirtQueue *vq,

                                               EventNotifierHandler *handler,

                                               int n)

{

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOSCSIVring *r = g_slice_new(VirtIOSCSIVring);



    /* Set up virtqueue notify */

    if (k->set_host_notifier(qbus->parent, n, true) != 0) {

        fprintf(stderr, "virtio-scsi: Failed to set host notifier\n");

        exit(1);

    }

    r->host_notifier = *virtio_queue_get_host_notifier(vq);

    r->guest_notifier = *virtio_queue_get_guest_notifier(vq);

    aio_set_event_notifier(s->ctx, &r->host_notifier, handler);



    r->parent = s;



    if (!vring_setup(&r->vring, VIRTIO_DEVICE(s), n)) {

        fprintf(stderr, "virtio-scsi: VRing setup failed\n");

        exit(1);

    }

    return r;

}



VirtIOSCSIReq *virtio_scsi_pop_req_vring(VirtIOSCSI *s,

                                         VirtIOSCSIVring *vring)

{

    VirtIOSCSIReq *req = virtio_scsi_init_req(s, NULL);

    int r;



    req->vring = vring;

    r = vring_pop((VirtIODevice *)s, &vring->vring, &req->elem);

    if (r < 0) {

        virtio_scsi_free_req(req);

        req = NULL;

    }

    return req;

}



void virtio_scsi_vring_push_notify(VirtIOSCSIReq *req)

{

    vring_push(&req->vring->vring, &req->elem,

               req->qsgl.size + req->resp_iov.size);

    event_notifier_set(&req->vring->guest_notifier);

}



static void virtio_scsi_iothread_handle_ctrl(EventNotifier *notifier)

{

    VirtIOSCSIVring *vring = container_of(notifier,

                                          VirtIOSCSIVring, host_notifier);

    VirtIOSCSI *s = VIRTIO_SCSI(vring->parent);

    VirtIOSCSIReq *req;



    event_notifier_test_and_clear(notifier);

    while ((req = virtio_scsi_pop_req_vring(s, vring))) {

        virtio_scsi_handle_ctrl_req(s, req);

    }

}



static void virtio_scsi_iothread_handle_event(EventNotifier *notifier)

{

    VirtIOSCSIVring *vring = container_of(notifier,

                                          VirtIOSCSIVring, host_notifier);

    VirtIOSCSI *s = vring->parent;

    VirtIODevice *vdev = VIRTIO_DEVICE(s);



    event_notifier_test_and_clear(notifier);



    if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {

        return;

    }



    if (s->events_dropped) {

        virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);

    }

}



static void virtio_scsi_iothread_handle_cmd(EventNotifier *notifier)

{

    VirtIOSCSIVring *vring = container_of(notifier,

                                          VirtIOSCSIVring, host_notifier);

    VirtIOSCSI *s = (VirtIOSCSI *)vring->parent;

    VirtIOSCSIReq *req;



    event_notifier_test_and_clear(notifier);

    while ((req = virtio_scsi_pop_req_vring(s, vring))) {

        virtio_scsi_handle_cmd_req(s, req);

    }

}



/* Context: QEMU global mutex held */

void virtio_scsi_dataplane_start(VirtIOSCSI *s)

{

    int i;

    int rc;

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);



    if (s->dataplane_started ||

        s->dataplane_starting ||

        s->ctx != iothread_get_aio_context(vs->conf.iothread)) {

        return;

    }



    s->dataplane_starting = true;



    /* Set up guest notifier (irq) */

    rc = k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, true);

    if (rc != 0) {

        fprintf(stderr, "virtio-scsi: Failed to set guest notifiers, "

                "ensure -enable-kvm is set\n");

        exit(1);

    }



    aio_context_acquire(s->ctx);

    s->ctrl_vring = virtio_scsi_vring_init(s, vs->ctrl_vq,

                                           virtio_scsi_iothread_handle_ctrl,

                                           0);

    s->event_vring = virtio_scsi_vring_init(s, vs->event_vq,

                                            virtio_scsi_iothread_handle_event,

                                            1);

    s->cmd_vrings = g_malloc0(sizeof(VirtIOSCSIVring) * vs->conf.num_queues);

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

        s->cmd_vrings[i] =

            virtio_scsi_vring_init(s, vs->cmd_vqs[i],

                                   virtio_scsi_iothread_handle_cmd,

                                   i + 2);

    }



    aio_context_release(s->ctx);

    s->dataplane_starting = false;

    s->dataplane_started = true;

}



/* Context: QEMU global mutex held */

void virtio_scsi_dataplane_stop(VirtIOSCSI *s)

{

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIODevice *vdev = VIRTIO_DEVICE(s);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);

    int i;



    if (!s->dataplane_started || s->dataplane_stopping) {

        return;

    }

    s->dataplane_stopping = true;

    assert(s->ctx == iothread_get_aio_context(vs->conf.iothread));



    aio_context_acquire(s->ctx);



    aio_set_event_notifier(s->ctx, &s->ctrl_vring->host_notifier, NULL);

    aio_set_event_notifier(s->ctx, &s->event_vring->host_notifier, NULL);

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

        aio_set_event_notifier(s->ctx, &s->cmd_vrings[i]->host_notifier, NULL);

    }



    bdrv_drain_all(); /* ensure there are no in-flight requests */



    aio_context_release(s->ctx);



    /* Sync vring state back to virtqueue so that non-dataplane request

     * processing can continue when we disable the host notifier below.

     */

    vring_teardown(&s->ctrl_vring->vring, vdev, 0);

    vring_teardown(&s->event_vring->vring, vdev, 1);

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

        vring_teardown(&s->cmd_vrings[i]->vring, vdev, 2 + i);

    }



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

        k->set_host_notifier(qbus->parent, i, false);

    }



    /* Clean up guest notifier (irq) */

    k->set_guest_notifiers(qbus->parent, vs->conf.num_queues + 2, false);

    s->dataplane_stopping = false;

    s->dataplane_started = false;

}

include/hw/virtio/virtio-scsi.h

+19 −0
Original line number Diff line number Diff line
@@ -182,6 +182,18 @@ typedef struct VirtIOSCSI { 
    SCSIBus bus;

    int resetting;

    bool events_dropped;



    /* Fields for dataplane below */

    AioContext *ctx; /* one iothread per virtio-scsi-pci for now */



    /* Vring is used instead of vq in dataplane code, because of the underlying

     * memory layer thread safety */

    VirtIOSCSIVring *ctrl_vring;

    VirtIOSCSIVring *event_vring;

    VirtIOSCSIVring **cmd_vrings;

    bool dataplane_started;

    bool dataplane_starting;

    bool dataplane_stopping;

} VirtIOSCSI;



typedef struct VirtIOSCSIReq {
@@ -248,4 +260,11 @@ void virtio_scsi_free_req(VirtIOSCSIReq *req); 
void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,

                            uint32_t event, uint32_t reason);



void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread);

void virtio_scsi_dataplane_start(VirtIOSCSI *s);

void virtio_scsi_dataplane_stop(VirtIOSCSI *s);

void virtio_scsi_vring_push_notify(VirtIOSCSIReq *req);

VirtIOSCSIReq *virtio_scsi_pop_req_vring(VirtIOSCSI *s,

                                         VirtIOSCSIVring *vring);



#endif /* _QEMU_VIRTIO_SCSI_H */