[mirror_qemu.git] / tests / virtio-blk-test.c

/*
 * QTest testcase for VirtIO Block Device
 *
 * Copyright (c) 2014 SUSE LINUX Products GmbH
 * Copyright (c) 2014 Marc Marí
 *
 * 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 <glib.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include "libqtest.h"
#include "libqos/virtio.h"
#include "libqos/virtio-pci.h"
#include "libqos/pci-pc.h"
#include "libqos/malloc.h"
#include "libqos/malloc-pc.h"
#include "qemu/bswap.h"

#define QVIRTIO_BLK_F_BARRIER       0x00000001
#define QVIRTIO_BLK_F_SIZE_MAX      0x00000002
#define QVIRTIO_BLK_F_SEG_MAX       0x00000004
#define QVIRTIO_BLK_F_GEOMETRY      0x00000010
#define QVIRTIO_BLK_F_RO            0x00000020
#define QVIRTIO_BLK_F_BLK_SIZE      0x00000040
#define QVIRTIO_BLK_F_SCSI          0x00000080
#define QVIRTIO_BLK_F_WCE           0x00000200
#define QVIRTIO_BLK_F_TOPOLOGY      0x00000400
#define QVIRTIO_BLK_F_CONFIG_WCE    0x00000800

#define QVIRTIO_BLK_T_IN            0
#define QVIRTIO_BLK_T_OUT           1
#define QVIRTIO_BLK_T_SCSI_CMD      2
#define QVIRTIO_BLK_T_SCSI_CMD_OUT  3
#define QVIRTIO_BLK_T_FLUSH         4
#define QVIRTIO_BLK_T_FLUSH_OUT     5
#define QVIRTIO_BLK_T_GET_ID        8

#define TEST_IMAGE_SIZE         (64 * 1024 * 1024)
#define QVIRTIO_BLK_TIMEOUT     100
#define PCI_SLOT                0x04
#define PCI_FN                  0x00

typedef struct QVirtioBlkReq {
    uint32_t type;
    uint32_t ioprio;
    uint64_t sector;
    char *data;
    uint8_t status;
} QVirtioBlkReq;

static QPCIBus *test_start(void)
{
    char cmdline[100];
    char tmp_path[] = "/tmp/qtest.XXXXXX";
    int fd, ret;

    /* Create a temporary raw image */
    fd = mkstemp(tmp_path);
    g_assert_cmpint(fd, >=, 0);
    ret = ftruncate(fd, TEST_IMAGE_SIZE);
    g_assert_cmpint(ret, ==, 0);
    close(fd);

    snprintf(cmdline, 100, "-drive if=none,id=drive0,file=%s "
                            "-device virtio-blk-pci,drive=drive0,addr=%x.%x",
                            tmp_path, PCI_SLOT, PCI_FN);
    qtest_start(cmdline);
    unlink(tmp_path);

    return qpci_init_pc();
}

static void test_end(void)
{
    qtest_end();
}

static QVirtioPCIDevice *virtio_blk_init(QPCIBus *bus)
{
    QVirtioPCIDevice *dev;

    dev = qvirtio_pci_device_find(bus, QVIRTIO_BLK_DEVICE_ID);
    g_assert(dev != NULL);
    g_assert_cmphex(dev->vdev.device_type, ==, QVIRTIO_BLK_DEVICE_ID);
    g_assert_cmphex(dev->pdev->devfn, ==, ((PCI_SLOT << 3) | PCI_FN));

    qvirtio_pci_device_enable(dev);
    qvirtio_reset(&qvirtio_pci, &dev->vdev);
    qvirtio_set_acknowledge(&qvirtio_pci, &dev->vdev);
    qvirtio_set_driver(&qvirtio_pci, &dev->vdev);

    return dev;
}

static inline void virtio_blk_fix_request(QVirtioBlkReq *req)
{
#ifdef HOST_WORDS_BIGENDIAN
    bool host_endian = true;
#else
    bool host_endian = false;
#endif

    if (qtest_big_endian() != host_endian) {
        req->type = bswap32(req->type);
        req->ioprio = bswap32(req->ioprio);
        req->sector = bswap64(req->sector);
    }
}

static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioBlkReq *req,
                                                            uint64_t data_size)
{
    uint64_t addr;
    uint8_t status = 0xFF;

    g_assert_cmpuint(data_size % 512, ==, 0);
    addr = guest_alloc(alloc, sizeof(*req) + data_size);

    virtio_blk_fix_request(req);

    memwrite(addr, req, 16);
    memwrite(addr + 16, req->data, data_size);
    memwrite(addr + 16 + data_size, &status, sizeof(status));

    return addr;
}

static void pci_basic(void)
{
    QVirtioPCIDevice *dev;
    QPCIBus *bus;
    QVirtQueuePCI *vqpci;
    QGuestAllocator *alloc;
    QVirtioBlkReq req;
    void *addr;
    uint64_t req_addr;
    uint64_t capacity;
    uint32_t features;
    uint32_t free_head;
    uint8_t status;
    char *data;

    bus = test_start();

    dev = virtio_blk_init(bus);

    /* MSI-X is not enabled */
    addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_NO_MSIX;

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);

    features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
    features = features & ~(QVIRTIO_F_BAD_FEATURE |
                    QVIRTIO_F_RING_INDIRECT_DESC | QVIRTIO_F_RING_EVENT_IDX |
                            QVIRTIO_BLK_F_SCSI);
    qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);

    alloc = pc_alloc_init();
    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
                                                                    alloc, 0);

    qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);

    /* Write and read with 2 descriptor layout */
    /* Write request */
    req.type = QVIRTIO_BLK_T_OUT;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));
    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    guest_free(alloc, req_addr);

    /* Read request */
    req.type = QVIRTIO_BLK_T_IN;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false);

    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));
    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    data = g_malloc0(512);
    memread(req_addr + 16, data, 512);
    g_assert_cmpstr(data, ==, "TEST");
    g_free(data);

    guest_free(alloc, req_addr);

    /* Write and read with 3 descriptor layout */
    /* Write request */
    req.type = QVIRTIO_BLK_T_OUT;
    req.ioprio = 1;
    req.sector = 1;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);

    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));
    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    guest_free(alloc, req_addr);

    /* Read request */
    req.type = QVIRTIO_BLK_T_IN;
    req.ioprio = 1;
    req.sector = 1;
    req.data = g_malloc0(512);

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, true, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);

    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));
    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    data = g_malloc0(512);
    memread(req_addr + 16, data, 512);
    g_assert_cmpstr(data, ==, "TEST");
    g_free(data);

    guest_free(alloc, req_addr);

    /* End test */
    guest_free(alloc, vqpci->vq.desc);
    qvirtio_pci_device_disable(dev);
    g_free(dev);
    test_end();
}

static void pci_indirect(void)
{
    QVirtioPCIDevice *dev;
    QPCIBus *bus;
    QVirtQueuePCI *vqpci;
    QGuestAllocator *alloc;
    QVirtioBlkReq req;
    QVRingIndirectDesc *indirect;
    void *addr;
    uint64_t req_addr;
    uint64_t capacity;
    uint32_t features;
    uint32_t free_head;
    uint8_t status;
    char *data;

    bus = test_start();

    dev = virtio_blk_init(bus);

    /* MSI-X is not enabled */
    addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_NO_MSIX;

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);

    features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
    g_assert_cmphex(features & QVIRTIO_F_RING_INDIRECT_DESC, !=, 0);
    features = features & ~(QVIRTIO_F_BAD_FEATURE | QVIRTIO_F_RING_EVENT_IDX |
                                                            QVIRTIO_BLK_F_SCSI);
    qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);

    alloc = pc_alloc_init();
    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
                                                                    alloc, 0);
    qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);

    /* Write request */
    req.type = QVIRTIO_BLK_T_OUT;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
    qvring_indirect_desc_add(indirect, req_addr, 528, false);
    qvring_indirect_desc_add(indirect, req_addr + 528, 1, true);
    free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));
    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    g_free(indirect);
    guest_free(alloc, req_addr);

    /* Read request */
    req.type = QVIRTIO_BLK_T_IN;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
    qvring_indirect_desc_add(indirect, req_addr, 16, false);
    qvring_indirect_desc_add(indirect, req_addr + 16, 513, true);
    free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));
    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    data = g_malloc0(512);
    memread(req_addr + 16, data, 512);
    g_assert_cmpstr(data, ==, "TEST");
    g_free(data);

    g_free(indirect);
    guest_free(alloc, req_addr);

    /* End test */
    guest_free(alloc, vqpci->vq.desc);
    qvirtio_pci_device_disable(dev);
    g_free(dev);
    test_end();
}

static void pci_config(void)
{
    QVirtioPCIDevice *dev;
    QPCIBus *bus;
    int n_size = TEST_IMAGE_SIZE / 2;
    void *addr;
    uint64_t capacity;

    bus = test_start();

    dev = virtio_blk_init(bus);

    /* MSI-X is not enabled */
    addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_NO_MSIX;

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);

    qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);

    qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
                                                    " 'size': %d } }", n_size);
    g_assert(qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev,
                                                        QVIRTIO_BLK_TIMEOUT));

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, n_size / 512);

    qvirtio_pci_device_disable(dev);
    g_free(dev);
    test_end();
}

static void pci_msix(void)
{
    QVirtioPCIDevice *dev;
    QPCIBus *bus;
    QVirtQueuePCI *vqpci;
    QGuestAllocator *alloc;
    QVirtioBlkReq req;
    int n_size = TEST_IMAGE_SIZE / 2;
    void *addr;
    uint64_t req_addr;
    uint64_t capacity;
    uint32_t features;
    uint32_t free_head;
    uint8_t status;
    char *data;

    bus = test_start();
    alloc = pc_alloc_init();

    dev = virtio_blk_init(bus);
    qpci_msix_enable(dev->pdev);

    qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);

    /* MSI-X is enabled */
    addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_MSIX;

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);

    features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
    features = features & ~(QVIRTIO_F_BAD_FEATURE |
                            QVIRTIO_F_RING_INDIRECT_DESC |
                            QVIRTIO_F_RING_EVENT_IDX | QVIRTIO_BLK_F_SCSI);
    qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);

    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
                                                                    alloc, 0);
    qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);

    qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);

    qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
                                                    " 'size': %d } }", n_size);

    g_assert(qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev,
                                                        QVIRTIO_BLK_TIMEOUT));

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, n_size / 512);

    /* Write request */
    req.type = QVIRTIO_BLK_T_OUT;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));

    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    guest_free(alloc, req_addr);

    /* Read request */
    req.type = QVIRTIO_BLK_T_IN;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false);

    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);


    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));

    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    data = g_malloc0(512);
    memread(req_addr + 16, data, 512);
    g_assert_cmpstr(data, ==, "TEST");
    g_free(data);

    guest_free(alloc, req_addr);

    /* End test */
    guest_free(alloc, (uint64_t)vqpci->vq.desc);
    qpci_msix_disable(dev->pdev);
    qvirtio_pci_device_disable(dev);
    g_free(dev);
    test_end();
}

static void pci_idx(void)
{
    QVirtioPCIDevice *dev;
    QPCIBus *bus;
    QVirtQueuePCI *vqpci;
    QGuestAllocator *alloc;
    QVirtioBlkReq req;
    void *addr;
    uint64_t req_addr;
    uint64_t capacity;
    uint32_t features;
    uint32_t free_head;
    uint8_t status;
    char *data;

    bus = test_start();
    alloc = pc_alloc_init();

    dev = virtio_blk_init(bus);
    qpci_msix_enable(dev->pdev);

    qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);

    /* MSI-X is enabled */
    addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_MSIX;

    capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
    g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);

    features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
    features = features & ~(QVIRTIO_F_BAD_FEATURE |
                            QVIRTIO_F_RING_INDIRECT_DESC |
                            QVIRTIO_F_NOTIFY_ON_EMPTY | QVIRTIO_BLK_F_SCSI);
    qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);

    vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
                                                                    alloc, 0);
    qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);

    qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);

    /* Write request */
    req.type = QVIRTIO_BLK_T_OUT;
    req.ioprio = 1;
    req.sector = 0;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));

    /* Write request */
    req.type = QVIRTIO_BLK_T_OUT;
    req.ioprio = 1;
    req.sector = 1;
    req.data = g_malloc0(512);
    strcpy(req.data, "TEST");

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    /* Notify after processing the third request */
    qvirtqueue_set_used_event(&vqpci->vq, 2);
    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);

    /* No notification expected */
    g_assert(!qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));

    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    guest_free(alloc, req_addr);

    /* Read request */
    req.type = QVIRTIO_BLK_T_IN;
    req.ioprio = 1;
    req.sector = 1;
    req.data = g_malloc0(512);

    req_addr = virtio_blk_request(alloc, &req, 512);

    g_free(req.data);

    free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
    qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false);

    qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);


    g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
                                                        QVIRTIO_BLK_TIMEOUT));

    status = readb(req_addr + 528);
    g_assert_cmpint(status, ==, 0);

    data = g_malloc0(512);
    memread(req_addr + 16, data, 512);
    g_assert_cmpstr(data, ==, "TEST");
    g_free(data);

    guest_free(alloc, req_addr);

    /* End test */
    guest_free(alloc, vqpci->vq.desc);
    qpci_msix_disable(dev->pdev);
    qvirtio_pci_device_disable(dev);
    g_free(dev);
    test_end();
}

int main(int argc, char **argv)
{
    int ret;

    g_test_init(&argc, &argv, NULL);

    g_test_add_func("/virtio/blk/pci/basic", pci_basic);
    g_test_add_func("/virtio/blk/pci/indirect", pci_indirect);
    g_test_add_func("/virtio/blk/pci/config", pci_config);
    g_test_add_func("/virtio/blk/pci/msix", pci_msix);
    g_test_add_func("/virtio/blk/pci/idx", pci_idx);

    ret = g_test_run();

    return ret;
}
Commit	Line	Data
c7a59bed AF	1	/*
	2	* QTest testcase for VirtIO Block Device
	3	*
	4	* Copyright (c) 2014 SUSE LINUX Products GmbH
311e666a	5	* Copyright (c) 2014 Marc Marí
c7a59bed AF	6	*
	7	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	8	* See the COPYING file in the top-level directory.
	9	*/
	10
	11	#include <glib.h>
	12	#include <string.h>
311e666a MM	13	#include <stdlib.h>
	14	#include <unistd.h>
	15	#include <stdio.h>
c7a59bed	16	#include "libqtest.h"
311e666a MM	17	#include "libqos/virtio.h"
	18	#include "libqos/virtio-pci.h"
	19	#include "libqos/pci-pc.h"
bf3c63d2 MM	20	#include "libqos/malloc.h"
	21	#include "libqos/malloc-pc.h"
	22	#include "qemu/bswap.h"
c7a59bed	23
bf3c63d2 MM	24	#define QVIRTIO_BLK_F_BARRIER 0x00000001
	25	#define QVIRTIO_BLK_F_SIZE_MAX 0x00000002
	26	#define QVIRTIO_BLK_F_SEG_MAX 0x00000004
	27	#define QVIRTIO_BLK_F_GEOMETRY 0x00000010
	28	#define QVIRTIO_BLK_F_RO 0x00000020
	29	#define QVIRTIO_BLK_F_BLK_SIZE 0x00000040
	30	#define QVIRTIO_BLK_F_SCSI 0x00000080
	31	#define QVIRTIO_BLK_F_WCE 0x00000200
	32	#define QVIRTIO_BLK_F_TOPOLOGY 0x00000400
	33	#define QVIRTIO_BLK_F_CONFIG_WCE 0x00000800
	34
	35	#define QVIRTIO_BLK_T_IN 0
	36	#define QVIRTIO_BLK_T_OUT 1
	37	#define QVIRTIO_BLK_T_SCSI_CMD 2
	38	#define QVIRTIO_BLK_T_SCSI_CMD_OUT 3
	39	#define QVIRTIO_BLK_T_FLUSH 4
	40	#define QVIRTIO_BLK_T_FLUSH_OUT 5
	41	#define QVIRTIO_BLK_T_GET_ID 8
	42
	43	#define TEST_IMAGE_SIZE (64 * 1024 * 1024)
	44	#define QVIRTIO_BLK_TIMEOUT 100
	45	#define PCI_SLOT 0x04
	46	#define PCI_FN 0x00
	47
	48	typedef struct QVirtioBlkReq {
	49	uint32_t type;
	50	uint32_t ioprio;
	51	uint64_t sector;
	52	char *data;
	53	uint8_t status;
	54	} QVirtioBlkReq;
311e666a MM	55
311e666a MM	56	static QPCIBus *test_start(void)
c7a59bed	57	{
311e666a MM	58	char cmdline[100];
	59	char tmp_path[] = "/tmp/qtest.XXXXXX";
	60	int fd, ret;
	61
	62	/* Create a temporary raw image */
	63	fd = mkstemp(tmp_path);
	64	g_assert_cmpint(fd, >=, 0);
	65	ret = ftruncate(fd, TEST_IMAGE_SIZE);
	66	g_assert_cmpint(ret, ==, 0);
	67	close(fd);
	68
	69	snprintf(cmdline, 100, "-drive if=none,id=drive0,file=%s "
	70	"-device virtio-blk-pci,drive=drive0,addr=%x.%x",
	71	tmp_path, PCI_SLOT, PCI_FN);
	72	qtest_start(cmdline);
	73	unlink(tmp_path);
	74
	75	return qpci_init_pc();
	76	}
	77
	78	static void test_end(void)
	79	{
	80	qtest_end();
	81	}
	82
46e0cf76	83	static QVirtioPCIDevice virtio_blk_init(QPCIBus bus)
311e666a MM	84	{
311e666a MM	85	QVirtioPCIDevice *dev;
311e666a MM	86
	87	dev = qvirtio_pci_device_find(bus, QVIRTIO_BLK_DEVICE_ID);
	88	g_assert(dev != NULL);
	89	g_assert_cmphex(dev->vdev.device_type, ==, QVIRTIO_BLK_DEVICE_ID);
	90	g_assert_cmphex(dev->pdev->devfn, ==, ((PCI_SLOT << 3) \| PCI_FN));
	91
46e0cf76 MM	92	qvirtio_pci_device_enable(dev);
	93	qvirtio_reset(&qvirtio_pci, &dev->vdev);
	94	qvirtio_set_acknowledge(&qvirtio_pci, &dev->vdev);
	95	qvirtio_set_driver(&qvirtio_pci, &dev->vdev);
	96
	97	return dev;
	98	}
	99
bf3c63d2 MM	100	static inline void virtio_blk_fix_request(QVirtioBlkReq *req)
	101	{
	102	#ifdef HOST_WORDS_BIGENDIAN
	103	bool host_endian = true;
	104	#else
	105	bool host_endian = false;
	106	#endif
	107
	108	if (qtest_big_endian() != host_endian) {
	109	req->type = bswap32(req->type);
	110	req->ioprio = bswap32(req->ioprio);
	111	req->sector = bswap64(req->sector);
	112	}
	113	}
	114
	115	static uint64_t virtio_blk_request(QGuestAllocator alloc, QVirtioBlkReq req,
	116	uint64_t data_size)
	117	{
	118	uint64_t addr;
	119	uint8_t status = 0xFF;
	120
	121	g_assert_cmpuint(data_size % 512, ==, 0);
	122	addr = guest_alloc(alloc, sizeof(*req) + data_size);
	123
	124	virtio_blk_fix_request(req);
	125
	126	memwrite(addr, req, 16);
	127	memwrite(addr + 16, req->data, data_size);
	128	memwrite(addr + 16 + data_size, &status, sizeof(status));
	129
	130	return addr;
	131	}
	132
46e0cf76 MM	133	static void pci_basic(void)
	134	{
	135	QVirtioPCIDevice *dev;
	136	QPCIBus *bus;
58368113	137	QVirtQueuePCI *vqpci;
bf3c63d2 MM	138	QGuestAllocator *alloc;
bf3c63d2 MM	139	QVirtioBlkReq req;
46e0cf76	140	void *addr;
bf3c63d2	141	uint64_t req_addr;
46e0cf76	142	uint64_t capacity;
bf3c63d2 MM	143	uint32_t features;
	144	uint32_t free_head;
	145	uint8_t status;
	146	char *data;
46e0cf76 MM	147
	148	bus = test_start();
	149
	150	dev = virtio_blk_init(bus);
	151
	152	/* MSI-X is not enabled */
	153	addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_NO_MSIX;
	154
	155	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	156	g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
	157
bf3c63d2 MM	158	features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
	159	features = features & ~(QVIRTIO_F_BAD_FEATURE \|
	160	QVIRTIO_F_RING_INDIRECT_DESC \| QVIRTIO_F_RING_EVENT_IDX \|
	161	QVIRTIO_BLK_F_SCSI);
	162	qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
	163
	164	alloc = pc_alloc_init();
58368113 MM	165	vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
58368113 MM	166	alloc, 0);
bf3c63d2 MM	167
	168	qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
	169
	170	/* Write and read with 2 descriptor layout */
	171	/* Write request */
	172	req.type = QVIRTIO_BLK_T_OUT;
	173	req.ioprio = 1;
	174	req.sector = 0;
	175	req.data = g_malloc0(512);
	176	strcpy(req.data, "TEST");
	177
	178	req_addr = virtio_blk_request(alloc, &req, 512);
	179
	180	g_free(req.data);
	181
58368113 MM	182	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
	183	qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
	184	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
bf3c63d2	185
58368113	186	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
bf3c63d2 MM	187	QVIRTIO_BLK_TIMEOUT));
	188	status = readb(req_addr + 528);
	189	g_assert_cmpint(status, ==, 0);
	190
	191	guest_free(alloc, req_addr);
	192
	193	/* Read request */
	194	req.type = QVIRTIO_BLK_T_IN;
	195	req.ioprio = 1;
	196	req.sector = 0;
	197	req.data = g_malloc0(512);
	198
	199	req_addr = virtio_blk_request(alloc, &req, 512);
	200
	201	g_free(req.data);
	202
58368113 MM	203	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
58368113 MM	204	qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false);
bf3c63d2	205
58368113	206	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
bf3c63d2	207
58368113	208	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
bf3c63d2 MM	209	QVIRTIO_BLK_TIMEOUT));
	210	status = readb(req_addr + 528);
	211	g_assert_cmpint(status, ==, 0);
	212
	213	data = g_malloc0(512);
	214	memread(req_addr + 16, data, 512);
	215	g_assert_cmpstr(data, ==, "TEST");
	216	g_free(data);
	217
	218	guest_free(alloc, req_addr);
	219
	220	/* Write and read with 3 descriptor layout */
	221	/* Write request */
	222	req.type = QVIRTIO_BLK_T_OUT;
	223	req.ioprio = 1;
	224	req.sector = 1;
	225	req.data = g_malloc0(512);
	226	strcpy(req.data, "TEST");
	227
	228	req_addr = virtio_blk_request(alloc, &req, 512);
	229
58368113 MM	230	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
	231	qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
	232	qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
bf3c63d2	233
58368113	234	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
bf3c63d2	235
58368113	236	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
bf3c63d2 MM	237	QVIRTIO_BLK_TIMEOUT));
	238	status = readb(req_addr + 528);
	239	g_assert_cmpint(status, ==, 0);
	240
	241	guest_free(alloc, req_addr);
	242
	243	/* Read request */
	244	req.type = QVIRTIO_BLK_T_IN;
	245	req.ioprio = 1;
	246	req.sector = 1;
	247	req.data = g_malloc0(512);
	248
	249	req_addr = virtio_blk_request(alloc, &req, 512);
	250
	251	g_free(req.data);
	252
58368113 MM	253	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
	254	qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, true, true);
	255	qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
bf3c63d2	256
58368113	257	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
bf3c63d2	258
58368113	259	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
bf3c63d2 MM	260	QVIRTIO_BLK_TIMEOUT));
	261	status = readb(req_addr + 528);
	262	g_assert_cmpint(status, ==, 0);
	263
bf3c63d2 MM	264	data = g_malloc0(512);
	265	memread(req_addr + 16, data, 512);
	266	g_assert_cmpstr(data, ==, "TEST");
	267	g_free(data);
	268
	269	guest_free(alloc, req_addr);
	270
	271	/* End test */
58368113	272	guest_free(alloc, vqpci->vq.desc);
46e0cf76	273	qvirtio_pci_device_disable(dev);
311e666a MM	274	g_free(dev);
311e666a MM	275	test_end();
c7a59bed AF	276	}
c7a59bed AF	277
f294b029 MM	278	static void pci_indirect(void)
	279	{
	280	QVirtioPCIDevice *dev;
	281	QPCIBus *bus;
58368113	282	QVirtQueuePCI *vqpci;
f294b029 MM	283	QGuestAllocator *alloc;
	284	QVirtioBlkReq req;
	285	QVRingIndirectDesc *indirect;
	286	void *addr;
	287	uint64_t req_addr;
	288	uint64_t capacity;
	289	uint32_t features;
	290	uint32_t free_head;
	291	uint8_t status;
	292	char *data;
	293
	294	bus = test_start();
	295
	296	dev = virtio_blk_init(bus);
	297
	298	/* MSI-X is not enabled */
	299	addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_NO_MSIX;
	300
	301	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	302	g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
	303
	304	features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
	305	g_assert_cmphex(features & QVIRTIO_F_RING_INDIRECT_DESC, !=, 0);
	306	features = features & ~(QVIRTIO_F_BAD_FEATURE \| QVIRTIO_F_RING_EVENT_IDX \|
	307	QVIRTIO_BLK_F_SCSI);
	308	qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
	309
	310	alloc = pc_alloc_init();
58368113 MM	311	vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
58368113 MM	312	alloc, 0);
f294b029 MM	313	qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
	314
	315	/* Write request */
	316	req.type = QVIRTIO_BLK_T_OUT;
	317	req.ioprio = 1;
	318	req.sector = 0;
	319	req.data = g_malloc0(512);
	320	strcpy(req.data, "TEST");
	321
	322	req_addr = virtio_blk_request(alloc, &req, 512);
	323
	324	g_free(req.data);
	325
	326	indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
	327	qvring_indirect_desc_add(indirect, req_addr, 528, false);
	328	qvring_indirect_desc_add(indirect, req_addr + 528, 1, true);
58368113 MM	329	free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
58368113 MM	330	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
f294b029	331
58368113	332	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
f294b029 MM	333	QVIRTIO_BLK_TIMEOUT));
	334	status = readb(req_addr + 528);
	335	g_assert_cmpint(status, ==, 0);
	336
	337	g_free(indirect);
	338	guest_free(alloc, req_addr);
	339
	340	/* Read request */
	341	req.type = QVIRTIO_BLK_T_IN;
	342	req.ioprio = 1;
	343	req.sector = 0;
	344	req.data = g_malloc0(512);
	345	strcpy(req.data, "TEST");
	346
	347	req_addr = virtio_blk_request(alloc, &req, 512);
	348
	349	g_free(req.data);
	350
	351	indirect = qvring_indirect_desc_setup(&dev->vdev, alloc, 2);
	352	qvring_indirect_desc_add(indirect, req_addr, 16, false);
	353	qvring_indirect_desc_add(indirect, req_addr + 16, 513, true);
58368113 MM	354	free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
58368113 MM	355	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
f294b029	356
58368113	357	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
f294b029 MM	358	QVIRTIO_BLK_TIMEOUT));
	359	status = readb(req_addr + 528);
	360	g_assert_cmpint(status, ==, 0);
	361
	362	data = g_malloc0(512);
	363	memread(req_addr + 16, data, 512);
	364	g_assert_cmpstr(data, ==, "TEST");
	365	g_free(data);
	366
	367	g_free(indirect);
	368	guest_free(alloc, req_addr);
	369
	370	/* End test */
58368113	371	guest_free(alloc, vqpci->vq.desc);
f294b029 MM	372	qvirtio_pci_device_disable(dev);
	373	g_free(dev);
	374	test_end();
	375	}
	376
e1119955 MM	377	static void pci_config(void)
	378	{
	379	QVirtioPCIDevice *dev;
	380	QPCIBus *bus;
	381	int n_size = TEST_IMAGE_SIZE / 2;
	382	void *addr;
	383	uint64_t capacity;
	384
	385	bus = test_start();
	386
	387	dev = virtio_blk_init(bus);
	388
	389	/* MSI-X is not enabled */
	390	addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_NO_MSIX;
	391
	392	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	393	g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
	394
	395	qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
	396
	397	qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
	398	" 'size': %d } }", n_size);
58368113	399	g_assert(qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev,
e1119955 MM	400	QVIRTIO_BLK_TIMEOUT));
	401
	402	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	403	g_assert_cmpint(capacity, ==, n_size / 512);
	404
	405	qvirtio_pci_device_disable(dev);
	406	g_free(dev);
	407	test_end();
	408	}
	409
58368113 MM	410	static void pci_msix(void)
	411	{
	412	QVirtioPCIDevice *dev;
	413	QPCIBus *bus;
	414	QVirtQueuePCI *vqpci;
	415	QGuestAllocator *alloc;
	416	QVirtioBlkReq req;
	417	int n_size = TEST_IMAGE_SIZE / 2;
	418	void *addr;
	419	uint64_t req_addr;
	420	uint64_t capacity;
	421	uint32_t features;
	422	uint32_t free_head;
	423	uint8_t status;
	424	char *data;
	425
	426	bus = test_start();
	427	alloc = pc_alloc_init();
	428
	429	dev = virtio_blk_init(bus);
	430	qpci_msix_enable(dev->pdev);
	431
	432	qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);
	433
	434	/* MSI-X is enabled */
	435	addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_MSIX;
	436
	437	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	438	g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
	439
	440	features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
	441	features = features & ~(QVIRTIO_F_BAD_FEATURE \|
	442	QVIRTIO_F_RING_INDIRECT_DESC \|
	443	QVIRTIO_F_RING_EVENT_IDX \| QVIRTIO_BLK_F_SCSI);
	444	qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
	445
	446	vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
	447	alloc, 0);
	448	qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
	449
	450	qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
	451
	452	qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
	453	" 'size': %d } }", n_size);
	454
	455	g_assert(qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev,
	456	QVIRTIO_BLK_TIMEOUT));
	457
	458	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	459	g_assert_cmpint(capacity, ==, n_size / 512);
	460
	461	/* Write request */
	462	req.type = QVIRTIO_BLK_T_OUT;
	463	req.ioprio = 1;
	464	req.sector = 0;
	465	req.data = g_malloc0(512);
	466	strcpy(req.data, "TEST");
	467
	468	req_addr = virtio_blk_request(alloc, &req, 512);
	469
	470	g_free(req.data);
	471
	472	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
	473	qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
474	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
475
476	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
477	QVIRTIO_BLK_TIMEOUT));
478
479	status = readb(req_addr + 528);
480	g_assert_cmpint(status, ==, 0);
481
482	guest_free(alloc, req_addr);
483
484	/* Read request */
485	req.type = QVIRTIO_BLK_T_IN;
486	req.ioprio = 1;
487	req.sector = 0;
488	req.data = g_malloc0(512);
489
490	req_addr = virtio_blk_request(alloc, &req, 512);
491
492	g_free(req.data);
493
494	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
495	qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false);
496
497	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
498
1053587c MM	499
	500	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
	501	QVIRTIO_BLK_TIMEOUT));
	502
	503	status = readb(req_addr + 528);
	504	g_assert_cmpint(status, ==, 0);
	505
	506	data = g_malloc0(512);
	507	memread(req_addr + 16, data, 512);
	508	g_assert_cmpstr(data, ==, "TEST");
	509	g_free(data);
	510
	511	guest_free(alloc, req_addr);
	512
	513	/* End test */
	514	guest_free(alloc, (uint64_t)vqpci->vq.desc);
	515	qpci_msix_disable(dev->pdev);
	516	qvirtio_pci_device_disable(dev);
	517	g_free(dev);
	518	test_end();
	519	}
	520
	521	static void pci_idx(void)
	522	{
	523	QVirtioPCIDevice *dev;
	524	QPCIBus *bus;
	525	QVirtQueuePCI *vqpci;
	526	QGuestAllocator *alloc;
	527	QVirtioBlkReq req;
	528	void *addr;
	529	uint64_t req_addr;
	530	uint64_t capacity;
	531	uint32_t features;
	532	uint32_t free_head;
	533	uint8_t status;
	534	char *data;
	535
	536	bus = test_start();
	537	alloc = pc_alloc_init();
	538
	539	dev = virtio_blk_init(bus);
	540	qpci_msix_enable(dev->pdev);
	541
	542	qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0);
	543
	544	/* MSI-X is enabled */
	545	addr = dev->addr + QVIRTIO_DEVICE_SPECIFIC_MSIX;
	546
	547	capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
	548	g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE / 512);
	549
	550	features = qvirtio_get_features(&qvirtio_pci, &dev->vdev);
	551	features = features & ~(QVIRTIO_F_BAD_FEATURE \|
	552	QVIRTIO_F_RING_INDIRECT_DESC \|
	553	QVIRTIO_F_NOTIFY_ON_EMPTY \| QVIRTIO_BLK_F_SCSI);
	554	qvirtio_set_features(&qvirtio_pci, &dev->vdev, features);
	555
	556	vqpci = (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev,
	557	alloc, 0);
	558	qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1);
	559
	560	qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
	561
	562	/* Write request */
563	req.type = QVIRTIO_BLK_T_OUT;
564	req.ioprio = 1;
565	req.sector = 0;
566	req.data = g_malloc0(512);
567	strcpy(req.data, "TEST");
568
569	req_addr = virtio_blk_request(alloc, &req, 512);
570
571	g_free(req.data);
572
573	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
574	qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
575	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
576
577	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
578	QVIRTIO_BLK_TIMEOUT));
579
580	/* Write request */
581	req.type = QVIRTIO_BLK_T_OUT;
582	req.ioprio = 1;
583	req.sector = 1;
584	req.data = g_malloc0(512);
585	strcpy(req.data, "TEST");
586
587	req_addr = virtio_blk_request(alloc, &req, 512);
588
589	g_free(req.data);
590
591	/* Notify after processing the third request */
592	qvirtqueue_set_used_event(&vqpci->vq, 2);
593	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true);
594	qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
595	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
596
597	/* No notification expected */
598	g_assert(!qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
599	QVIRTIO_BLK_TIMEOUT));
600
601	status = readb(req_addr + 528);
602	g_assert_cmpint(status, ==, 0);
603
604	guest_free(alloc, req_addr);
605
606	/* Read request */
607	req.type = QVIRTIO_BLK_T_IN;
608	req.ioprio = 1;
609	req.sector = 1;
610	req.data = g_malloc0(512);
611
612	req_addr = virtio_blk_request(alloc, &req, 512);
613
614	g_free(req.data);
615
616	free_head = qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true);
617	qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false);
618
619	qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head);
620
621
58368113 MM	622	g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq,
	623	QVIRTIO_BLK_TIMEOUT));
	624
	625	status = readb(req_addr + 528);
	626	g_assert_cmpint(status, ==, 0);
	627
	628	data = g_malloc0(512);
	629	memread(req_addr + 16, data, 512);
	630	g_assert_cmpstr(data, ==, "TEST");
	631	g_free(data);
	632
	633	guest_free(alloc, req_addr);
	634
	635	/* End test */
	636	guest_free(alloc, vqpci->vq.desc);
	637	qpci_msix_disable(dev->pdev);
	638	qvirtio_pci_device_disable(dev);
	639	g_free(dev);
	640	test_end();
	641	}
	642
c7a59bed AF	643	int main(int argc, char **argv)
	644	{
	645	int ret;
	646
	647	g_test_init(&argc, &argv, NULL);
c7a59bed	648
311e666a	649	g_test_add_func("/virtio/blk/pci/basic", pci_basic);
f294b029	650	g_test_add_func("/virtio/blk/pci/indirect", pci_indirect);
e1119955	651	g_test_add_func("/virtio/blk/pci/config", pci_config);
58368113	652	g_test_add_func("/virtio/blk/pci/msix", pci_msix);
1053587c	653	g_test_add_func("/virtio/blk/pci/idx", pci_idx);
c7a59bed	654
311e666a	655	ret = g_test_run();
c7a59bed AF	656
	657	return ret;
	658	}