1 /* 2 * QTest testcase for VirtIO SCSI 3 * 4 * Copyright (c) 2014 SUSE LINUX Products GmbH 5 * Copyright (c) 2015 Red Hat Inc. 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 "qemu/osdep.h" 12 #include "libqtest-single.h" 13 #include "qemu/module.h" 14 #include "scsi/constants.h" 15 #include "libqos/libqos-pc.h" 16 #include "libqos/libqos-spapr.h" 17 #include "libqos/virtio.h" 18 #include "libqos/virtio-pci.h" 19 #include "standard-headers/linux/virtio_ids.h" 20 #include "standard-headers/linux/virtio_pci.h" 21 #include "standard-headers/linux/virtio_scsi.h" 22 #include "libqos/virtio-scsi.h" 23 #include "libqos/qgraph.h" 24 25 #define PCI_SLOT 0x02 26 #define PCI_FN 0x00 27 #define QVIRTIO_SCSI_TIMEOUT_US (1 * 1000 * 1000) 28 29 #define MAX_NUM_QUEUES 64 30 31 typedef struct { 32 QVirtioDevice *dev; 33 int num_queues; 34 QVirtQueue *vq[MAX_NUM_QUEUES + 2]; 35 } QVirtioSCSIQueues; 36 37 static QGuestAllocator *alloc; 38 39 static void qvirtio_scsi_pci_free(QVirtioSCSIQueues *vs) 40 { 41 int i; 42 43 for (i = 0; i < vs->num_queues + 2; i++) { 44 qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], alloc); 45 } 46 g_free(vs); 47 } 48 49 static uint64_t qvirtio_scsi_alloc(QVirtioSCSIQueues *vs, size_t alloc_size, 50 const void *data) 51 { 52 uint64_t addr; 53 54 addr = guest_alloc(alloc, alloc_size); 55 if (data) { 56 memwrite(addr, data, alloc_size); 57 } 58 59 return addr; 60 } 61 62 static uint8_t virtio_scsi_do_command(QVirtioSCSIQueues *vs, 63 const uint8_t *cdb, 64 const uint8_t *data_in, 65 size_t data_in_len, 66 uint8_t *data_out, size_t data_out_len, 67 struct virtio_scsi_cmd_resp *resp_out) 68 { 69 QVirtQueue *vq; 70 struct virtio_scsi_cmd_req req = { { 0 } }; 71 struct virtio_scsi_cmd_resp resp = { .response = 0xff, .status = 0xff }; 72 uint64_t req_addr, resp_addr, data_in_addr = 0, data_out_addr = 0; 73 uint8_t response; 74 uint32_t free_head; 75 QTestState *qts = global_qtest; 76 77 vq = vs->vq[2]; 78 79 req.lun[0] = 1; /* Select LUN */ 80 req.lun[1] = 1; /* Select target 1 */ 81 memcpy(req.cdb, cdb, VIRTIO_SCSI_CDB_SIZE); 82 83 /* XXX: Fix endian if any multi-byte field in req/resp is used */ 84 85 /* Add request header */ 86 req_addr = qvirtio_scsi_alloc(vs, sizeof(req), &req); 87 free_head = qvirtqueue_add(qts, vq, req_addr, sizeof(req), false, true); 88 89 if (data_out_len) { 90 data_out_addr = qvirtio_scsi_alloc(vs, data_out_len, data_out); 91 qvirtqueue_add(qts, vq, data_out_addr, data_out_len, false, true); 92 } 93 94 /* Add response header */ 95 resp_addr = qvirtio_scsi_alloc(vs, sizeof(resp), &resp); 96 qvirtqueue_add(qts, vq, resp_addr, sizeof(resp), true, !!data_in_len); 97 98 if (data_in_len) { 99 data_in_addr = qvirtio_scsi_alloc(vs, data_in_len, data_in); 100 qvirtqueue_add(qts, vq, data_in_addr, data_in_len, true, false); 101 } 102 103 qvirtqueue_kick(qts, vs->dev, vq, free_head); 104 qvirtio_wait_used_elem(qts, vs->dev, vq, free_head, NULL, 105 QVIRTIO_SCSI_TIMEOUT_US); 106 107 response = readb(resp_addr + 108 offsetof(struct virtio_scsi_cmd_resp, response)); 109 110 if (resp_out) { 111 memread(resp_addr, resp_out, sizeof(*resp_out)); 112 } 113 114 guest_free(alloc, req_addr); 115 guest_free(alloc, resp_addr); 116 guest_free(alloc, data_in_addr); 117 guest_free(alloc, data_out_addr); 118 return response; 119 } 120 121 static QVirtioSCSIQueues *qvirtio_scsi_init(QVirtioDevice *dev) 122 { 123 QVirtioSCSIQueues *vs; 124 const uint8_t test_unit_ready_cdb[VIRTIO_SCSI_CDB_SIZE] = {}; 125 struct virtio_scsi_cmd_resp resp; 126 uint64_t features; 127 int i; 128 129 vs = g_new0(QVirtioSCSIQueues, 1); 130 vs->dev = dev; 131 132 features = qvirtio_get_features(dev); 133 features &= ~(QVIRTIO_F_BAD_FEATURE | (1ull << VIRTIO_RING_F_EVENT_IDX)); 134 qvirtio_set_features(dev, features); 135 136 vs->num_queues = qvirtio_config_readl(dev, 0); 137 138 g_assert_cmpint(vs->num_queues, <, MAX_NUM_QUEUES); 139 140 for (i = 0; i < vs->num_queues + 2; i++) { 141 vs->vq[i] = qvirtqueue_setup(dev, alloc, i); 142 } 143 144 qvirtio_set_driver_ok(dev); 145 146 /* Clear the POWER ON OCCURRED unit attention */ 147 g_assert_cmpint(virtio_scsi_do_command(vs, test_unit_ready_cdb, 148 NULL, 0, NULL, 0, &resp), 149 ==, 0); 150 g_assert_cmpint(resp.status, ==, CHECK_CONDITION); 151 g_assert_cmpint(resp.sense[0], ==, 0x70); /* Fixed format sense buffer */ 152 g_assert_cmpint(resp.sense[2], ==, UNIT_ATTENTION); 153 g_assert_cmpint(resp.sense[12], ==, 0x29); /* POWER ON */ 154 g_assert_cmpint(resp.sense[13], ==, 0x00); 155 156 return vs; 157 } 158 159 static void hotplug(void *obj, void *data, QGuestAllocator *alloc) 160 { 161 QTestState *qts = global_qtest; 162 163 qtest_qmp_device_add(qts, "scsi-hd", "scsihd", "{'drive': 'drv1'}"); 164 qtest_qmp_device_del(qts, "scsihd"); 165 } 166 167 /* Test WRITE SAME with the lba not aligned */ 168 static void test_unaligned_write_same(void *obj, void *data, 169 QGuestAllocator *t_alloc) 170 { 171 QVirtioSCSI *scsi = obj; 172 QVirtioSCSIQueues *vs; 173 uint8_t buf1[512] = { 0 }; 174 uint8_t buf2[512] = { 1 }; 175 const uint8_t write_same_cdb_1[VIRTIO_SCSI_CDB_SIZE] = { 176 0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00 177 }; 178 const uint8_t write_same_cdb_2[VIRTIO_SCSI_CDB_SIZE] = { 179 0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x33, 0x00, 0x00 180 }; 181 const uint8_t write_same_cdb_ndob[VIRTIO_SCSI_CDB_SIZE] = { 182 0x41, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x33, 0x00, 0x00 183 }; 184 185 alloc = t_alloc; 186 vs = qvirtio_scsi_init(scsi->vdev); 187 188 g_assert_cmphex(0, ==, 189 virtio_scsi_do_command(vs, write_same_cdb_1, NULL, 0, buf1, 512, 190 NULL)); 191 192 g_assert_cmphex(0, ==, 193 virtio_scsi_do_command(vs, write_same_cdb_2, NULL, 0, buf2, 512, 194 NULL)); 195 196 g_assert_cmphex(0, ==, 197 virtio_scsi_do_command(vs, write_same_cdb_ndob, NULL, 0, NULL, 0, 198 NULL)); 199 200 qvirtio_scsi_pci_free(vs); 201 } 202 203 static void test_write_to_cdrom(void *obj, void *data, 204 QGuestAllocator *t_alloc) 205 { 206 QVirtioSCSI *scsi = obj; 207 QVirtioSCSIQueues *vs; 208 uint8_t buf[2048] = { 0 }; 209 const uint8_t write_cdb[VIRTIO_SCSI_CDB_SIZE] = { 210 /* WRITE(10) to LBA 0, transfer length 1 */ 211 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 212 }; 213 struct virtio_scsi_cmd_resp resp; 214 215 alloc = t_alloc; 216 vs = qvirtio_scsi_init(scsi->vdev); 217 218 virtio_scsi_do_command(vs, write_cdb, NULL, 0, buf, 2048, &resp); 219 g_assert_cmphex(resp.response, ==, 0); 220 g_assert_cmphex(resp.status, ==, CHECK_CONDITION); 221 g_assert_cmphex(resp.sense[0], ==, 0x70); 222 g_assert_cmphex(resp.sense[2], ==, DATA_PROTECT); 223 g_assert_cmphex(resp.sense[12], ==, 0x27); /* WRITE PROTECTED */ 224 g_assert_cmphex(resp.sense[13], ==, 0x00); /* WRITE PROTECTED */ 225 226 qvirtio_scsi_pci_free(vs); 227 } 228 229 static void test_iothread_attach_node(void *obj, void *data, 230 QGuestAllocator *t_alloc) 231 { 232 QVirtioSCSIPCI *scsi_pci = obj; 233 QVirtioSCSI *scsi = &scsi_pci->scsi; 234 QVirtioSCSIQueues *vs; 235 char tmp_path[] = "/tmp/qtest.XXXXXX"; 236 int fd; 237 int ret; 238 239 uint8_t buf[512] = { 0 }; 240 const uint8_t write_cdb[VIRTIO_SCSI_CDB_SIZE] = { 241 /* WRITE(10) to LBA 0, transfer length 1 */ 242 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 243 }; 244 245 alloc = t_alloc; 246 vs = qvirtio_scsi_init(scsi->vdev); 247 248 /* Create a temporary qcow2 overlay*/ 249 fd = mkstemp(tmp_path); 250 g_assert(fd >= 0); 251 close(fd); 252 253 if (!have_qemu_img()) { 254 g_test_message("QTEST_QEMU_IMG not set or qemu-img missing; " 255 "skipping snapshot test"); 256 goto fail; 257 } 258 259 mkqcow2(tmp_path, 64); 260 261 /* Attach the overlay to the null0 node */ 262 qtest_qmp_assert_success(scsi_pci->pci_vdev.pdev->bus->qts, 263 "{'execute': 'blockdev-add', 'arguments': {" 264 " 'driver': 'qcow2', 'node-name': 'overlay'," 265 " 'backing': 'null0', 'file': {" 266 " 'driver': 'file', 'filename': %s}}}", 267 tmp_path); 268 269 /* Send a request to see if the AioContext is still right */ 270 ret = virtio_scsi_do_command(vs, write_cdb, NULL, 0, buf, 512, NULL); 271 g_assert_cmphex(ret, ==, 0); 272 273 fail: 274 qvirtio_scsi_pci_free(vs); 275 unlink(tmp_path); 276 } 277 278 static void *virtio_scsi_hotplug_setup(GString *cmd_line, void *arg) 279 { 280 g_string_append(cmd_line, 281 " -drive id=drv1,if=none,file=null-co://," 282 "file.read-zeroes=on,format=raw"); 283 return arg; 284 } 285 286 static void *virtio_scsi_setup(GString *cmd_line, void *arg) 287 { 288 g_string_append(cmd_line, 289 " -drive file=blkdebug::null-co://," 290 "file.image.read-zeroes=on," 291 "if=none,id=dr1,format=raw,file.align=4k " 292 "-device scsi-hd,drive=dr1,lun=0,scsi-id=1"); 293 return arg; 294 } 295 296 static void *virtio_scsi_setup_cd(GString *cmd_line, void *arg) 297 { 298 g_string_append(cmd_line, 299 " -drive file=null-co://," 300 "file.read-zeroes=on," 301 "if=none,id=dr1,format=raw " 302 "-device scsi-cd,drive=dr1,lun=0,scsi-id=1"); 303 return arg; 304 } 305 306 static void *virtio_scsi_setup_iothread(GString *cmd_line, void *arg) 307 { 308 g_string_append(cmd_line, 309 " -object iothread,id=thread0" 310 " -blockdev driver=null-co,read-zeroes=on,node-name=null0" 311 " -device scsi-hd,drive=null0"); 312 return arg; 313 } 314 315 static void register_virtio_scsi_test(void) 316 { 317 QOSGraphTestOptions opts = { }; 318 319 opts.before = virtio_scsi_hotplug_setup; 320 qos_add_test("hotplug", "virtio-scsi", hotplug, &opts); 321 322 opts.before = virtio_scsi_setup; 323 qos_add_test("unaligned-write-same", "virtio-scsi", 324 test_unaligned_write_same, &opts); 325 326 opts.before = virtio_scsi_setup_cd; 327 qos_add_test("write-to-cdrom", "virtio-scsi", test_write_to_cdrom, &opts); 328 329 opts.before = virtio_scsi_setup_iothread; 330 opts.edge = (QOSGraphEdgeOptions) { 331 .extra_device_opts = "iothread=thread0", 332 }; 333 qos_add_test("iothread-attach-node", "virtio-scsi-pci", 334 test_iothread_attach_node, &opts); 335 } 336 337 libqos_init(register_virtio_scsi_test); 338