]>
Commit | Line | Data |
---|---|---|
26c9a015 AF |
1 | /* |
2 | * QTest testcase for VirtIO SCSI | |
3 | * | |
4 | * Copyright (c) 2014 SUSE LINUX Products GmbH | |
397c767b | 5 | * Copyright (c) 2015 Red Hat Inc. |
26c9a015 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 | ||
681c28a3 | 11 | #include "qemu/osdep.h" |
26c9a015 | 12 | #include "libqtest.h" |
4bb7b0da | 13 | #include "block/scsi.h" |
a980f7f2 | 14 | #include "libqos/libqos-pc.h" |
397c767b FZ |
15 | #include "libqos/virtio.h" |
16 | #include "libqos/virtio-pci.h" | |
8ac9e205 | 17 | #include "standard-headers/linux/virtio_ids.h" |
c75f4c06 | 18 | #include "standard-headers/linux/virtio_pci.h" |
74f079a7 | 19 | #include "standard-headers/linux/virtio_scsi.h" |
397c767b FZ |
20 | |
21 | #define PCI_SLOT 0x02 | |
22 | #define PCI_FN 0x00 | |
23 | #define QVIRTIO_SCSI_TIMEOUT_US (1 * 1000 * 1000) | |
397c767b FZ |
24 | |
25 | #define MAX_NUM_QUEUES 64 | |
26 | ||
27 | typedef struct { | |
28 | QVirtioDevice *dev; | |
a980f7f2 | 29 | QOSState *qs; |
397c767b FZ |
30 | int num_queues; |
31 | QVirtQueue *vq[MAX_NUM_QUEUES + 2]; | |
32 | } QVirtIOSCSI; | |
33 | ||
a980f7f2 | 34 | static QOSState *qvirtio_scsi_start(const char *extra_opts) |
06b008d9 | 35 | { |
a980f7f2 LV |
36 | const char *cmd = "-drive id=drv0,if=none,file=/dev/null,format=raw " |
37 | "-device virtio-scsi-pci,id=vs0 " | |
38 | "-device scsi-hd,bus=vs0.0,drive=drv0 %s"; | |
39 | ||
40 | return qtest_pc_boot(cmd, extra_opts ? : ""); | |
06b008d9 FZ |
41 | } |
42 | ||
a980f7f2 | 43 | static void qvirtio_scsi_stop(QOSState *qs) |
06b008d9 | 44 | { |
a980f7f2 | 45 | qtest_shutdown(qs); |
06b008d9 FZ |
46 | } |
47 | ||
397c767b FZ |
48 | static void qvirtio_scsi_pci_free(QVirtIOSCSI *vs) |
49 | { | |
50 | int i; | |
51 | ||
52 | for (i = 0; i < vs->num_queues + 2; i++) { | |
a980f7f2 | 53 | qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->qs->alloc); |
397c767b | 54 | } |
397c767b FZ |
55 | qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev)); |
56 | g_free(vs->dev); | |
a980f7f2 | 57 | qvirtio_scsi_stop(vs->qs); |
f62e0bbb | 58 | g_free(vs); |
397c767b FZ |
59 | } |
60 | ||
61 | static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size, | |
62 | const void *data) | |
63 | { | |
64 | uint64_t addr; | |
65 | ||
a980f7f2 | 66 | addr = guest_alloc(vs->qs->alloc, alloc_size); |
397c767b FZ |
67 | if (data) { |
68 | memwrite(addr, data, alloc_size); | |
69 | } | |
70 | ||
71 | return addr; | |
72 | } | |
73 | ||
74 | static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb, | |
75 | const uint8_t *data_in, | |
76 | size_t data_in_len, | |
4bb7b0da | 77 | uint8_t *data_out, size_t data_out_len, |
74f079a7 | 78 | struct virtio_scsi_cmd_resp *resp_out) |
397c767b FZ |
79 | { |
80 | QVirtQueue *vq; | |
74f079a7 SH |
81 | struct virtio_scsi_cmd_req req = { { 0 } }; |
82 | struct virtio_scsi_cmd_resp resp = { .response = 0xff, .status = 0xff }; | |
397c767b FZ |
83 | uint64_t req_addr, resp_addr, data_in_addr = 0, data_out_addr = 0; |
84 | uint8_t response; | |
85 | uint32_t free_head; | |
86 | ||
87 | vq = vs->vq[2]; | |
88 | ||
89 | req.lun[0] = 1; /* Select LUN */ | |
90 | req.lun[1] = 1; /* Select target 1 */ | |
74f079a7 | 91 | memcpy(req.cdb, cdb, VIRTIO_SCSI_CDB_SIZE); |
397c767b FZ |
92 | |
93 | /* XXX: Fix endian if any multi-byte field in req/resp is used */ | |
94 | ||
95 | /* Add request header */ | |
96 | req_addr = qvirtio_scsi_alloc(vs, sizeof(req), &req); | |
97 | free_head = qvirtqueue_add(vq, req_addr, sizeof(req), false, true); | |
98 | ||
99 | if (data_out_len) { | |
100 | data_out_addr = qvirtio_scsi_alloc(vs, data_out_len, data_out); | |
101 | qvirtqueue_add(vq, data_out_addr, data_out_len, false, true); | |
102 | } | |
103 | ||
104 | /* Add response header */ | |
105 | resp_addr = qvirtio_scsi_alloc(vs, sizeof(resp), &resp); | |
106 | qvirtqueue_add(vq, resp_addr, sizeof(resp), true, !!data_in_len); | |
107 | ||
108 | if (data_in_len) { | |
109 | data_in_addr = qvirtio_scsi_alloc(vs, data_in_len, data_in); | |
110 | qvirtqueue_add(vq, data_in_addr, data_in_len, true, false); | |
111 | } | |
112 | ||
6b9cdf4c LV |
113 | qvirtqueue_kick(vs->dev, vq, free_head); |
114 | qvirtio_wait_queue_isr(vs->dev, vq, QVIRTIO_SCSI_TIMEOUT_US); | |
397c767b | 115 | |
74f079a7 SH |
116 | response = readb(resp_addr + |
117 | offsetof(struct virtio_scsi_cmd_resp, response)); | |
397c767b | 118 | |
4bb7b0da SH |
119 | if (resp_out) { |
120 | memread(resp_addr, resp_out, sizeof(*resp_out)); | |
121 | } | |
122 | ||
a980f7f2 LV |
123 | guest_free(vs->qs->alloc, req_addr); |
124 | guest_free(vs->qs->alloc, resp_addr); | |
125 | guest_free(vs->qs->alloc, data_in_addr); | |
126 | guest_free(vs->qs->alloc, data_out_addr); | |
397c767b FZ |
127 | return response; |
128 | } | |
129 | ||
4bb7b0da SH |
130 | static QVirtIOSCSI *qvirtio_scsi_pci_init(int slot) |
131 | { | |
74f079a7 | 132 | const uint8_t test_unit_ready_cdb[VIRTIO_SCSI_CDB_SIZE] = {}; |
4bb7b0da SH |
133 | QVirtIOSCSI *vs; |
134 | QVirtioPCIDevice *dev; | |
74f079a7 | 135 | struct virtio_scsi_cmd_resp resp; |
4bb7b0da SH |
136 | void *addr; |
137 | int i; | |
138 | ||
139 | vs = g_new0(QVirtIOSCSI, 1); | |
4bb7b0da | 140 | |
a980f7f2 LV |
141 | vs->qs = qvirtio_scsi_start("-drive file=blkdebug::null-co://," |
142 | "if=none,id=dr1,format=raw,file.align=4k " | |
143 | "-device scsi-disk,drive=dr1,lun=0,scsi-id=1"); | |
144 | dev = qvirtio_pci_device_find(vs->qs->pcibus, VIRTIO_ID_SCSI); | |
4bb7b0da SH |
145 | vs->dev = (QVirtioDevice *)dev; |
146 | g_assert(dev != NULL); | |
8ac9e205 | 147 | g_assert_cmphex(vs->dev->device_type, ==, VIRTIO_ID_SCSI); |
4bb7b0da SH |
148 | |
149 | qvirtio_pci_device_enable(dev); | |
6b9cdf4c LV |
150 | qvirtio_reset(vs->dev); |
151 | qvirtio_set_acknowledge(vs->dev); | |
152 | qvirtio_set_driver(vs->dev); | |
4bb7b0da | 153 | |
c75f4c06 | 154 | addr = dev->addr + VIRTIO_PCI_CONFIG_OFF(false); |
6b9cdf4c | 155 | vs->num_queues = qvirtio_config_readl(vs->dev, (uint64_t)(uintptr_t)addr); |
4bb7b0da SH |
156 | |
157 | g_assert_cmpint(vs->num_queues, <, MAX_NUM_QUEUES); | |
158 | ||
159 | for (i = 0; i < vs->num_queues + 2; i++) { | |
a980f7f2 | 160 | vs->vq[i] = qvirtqueue_setup(vs->dev, vs->qs->alloc, i); |
4bb7b0da SH |
161 | } |
162 | ||
163 | /* Clear the POWER ON OCCURRED unit attention */ | |
164 | g_assert_cmpint(virtio_scsi_do_command(vs, test_unit_ready_cdb, | |
165 | NULL, 0, NULL, 0, &resp), | |
166 | ==, 0); | |
167 | g_assert_cmpint(resp.status, ==, CHECK_CONDITION); | |
168 | g_assert_cmpint(resp.sense[0], ==, 0x70); /* Fixed format sense buffer */ | |
169 | g_assert_cmpint(resp.sense[2], ==, UNIT_ATTENTION); | |
170 | g_assert_cmpint(resp.sense[12], ==, 0x29); /* POWER ON */ | |
171 | g_assert_cmpint(resp.sense[13], ==, 0x00); | |
172 | ||
173 | return vs; | |
174 | } | |
175 | ||
26c9a015 AF |
176 | /* Tests only initialization so far. TODO: Replace with functional tests */ |
177 | static void pci_nop(void) | |
178 | { | |
a980f7f2 LV |
179 | QOSState *qs; |
180 | ||
181 | qs = qvirtio_scsi_start(NULL); | |
182 | qvirtio_scsi_stop(qs); | |
26c9a015 AF |
183 | } |
184 | ||
ac2c4946 IM |
185 | static void hotplug(void) |
186 | { | |
187 | QDict *response; | |
a980f7f2 | 188 | QOSState *qs; |
ac2c4946 | 189 | |
a980f7f2 | 190 | qs = qvirtio_scsi_start("-drive id=drv1,if=none,file=/dev/null,format=raw"); |
ac2c4946 IM |
191 | response = qmp("{\"execute\": \"device_add\"," |
192 | " \"arguments\": {" | |
193 | " \"driver\": \"scsi-hd\"," | |
194 | " \"id\": \"scsi-hd\"," | |
195 | " \"drive\": \"drv1\"" | |
196 | "}}"); | |
197 | ||
198 | g_assert(response); | |
199 | g_assert(!qdict_haskey(response, "error")); | |
200 | QDECREF(response); | |
201 | ||
202 | response = qmp("{\"execute\": \"device_del\"," | |
203 | " \"arguments\": {" | |
204 | " \"id\": \"scsi-hd\"" | |
205 | "}}"); | |
206 | ||
207 | g_assert(response); | |
208 | g_assert(!qdict_haskey(response, "error")); | |
209 | g_assert(qdict_haskey(response, "event")); | |
210 | g_assert(!strcmp(qdict_get_str(response, "event"), "DEVICE_DELETED")); | |
211 | QDECREF(response); | |
a980f7f2 | 212 | qvirtio_scsi_stop(qs); |
ac2c4946 IM |
213 | } |
214 | ||
397c767b FZ |
215 | /* Test WRITE SAME with the lba not aligned */ |
216 | static void test_unaligned_write_same(void) | |
217 | { | |
218 | QVirtIOSCSI *vs; | |
975b6655 FZ |
219 | uint8_t buf1[512] = { 0 }; |
220 | uint8_t buf2[512] = { 1 }; | |
74f079a7 SH |
221 | const uint8_t write_same_cdb_1[VIRTIO_SCSI_CDB_SIZE] = { |
222 | 0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00 | |
223 | }; | |
224 | const uint8_t write_same_cdb_2[VIRTIO_SCSI_CDB_SIZE] = { | |
225 | 0x41, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x33, 0x00, 0x00 | |
226 | }; | |
397c767b | 227 | |
397c767b FZ |
228 | vs = qvirtio_scsi_pci_init(PCI_SLOT); |
229 | ||
230 | g_assert_cmphex(0, ==, | |
975b6655 FZ |
231 | virtio_scsi_do_command(vs, write_same_cdb_1, NULL, 0, buf1, 512, NULL)); |
232 | ||
233 | g_assert_cmphex(0, ==, | |
234 | virtio_scsi_do_command(vs, write_same_cdb_2, NULL, 0, buf2, 512, NULL)); | |
397c767b FZ |
235 | |
236 | qvirtio_scsi_pci_free(vs); | |
397c767b FZ |
237 | } |
238 | ||
26c9a015 AF |
239 | int main(int argc, char **argv) |
240 | { | |
26c9a015 AF |
241 | g_test_init(&argc, &argv, NULL); |
242 | qtest_add_func("/virtio/scsi/pci/nop", pci_nop); | |
ac2c4946 | 243 | qtest_add_func("/virtio/scsi/pci/hotplug", hotplug); |
397c767b FZ |
244 | qtest_add_func("/virtio/scsi/pci/scsi-disk/unaligned-write-same", |
245 | test_unaligned_write_same); | |
26c9a015 | 246 | |
9be38598 | 247 | return g_test_run(); |
26c9a015 | 248 | } |