1 /*
2 * Virtio-SCSI implementation for s390 machine loader for qemu
3 *
4 * Copyright 2015 IBM Corp.
5 * Author: Eugene "jno" Dvurechenski <jno@linux.vnet.ibm.com>
6 *
7 * This work is licensed under the terms of the GNU GPL, version 2 or (at
8 * your option) any later version. See the COPYING file in the top-level
9 * directory.
10 */
11
12 #include <string.h>
13 #include <stdio.h>
14 #include "s390-ccw.h"
15 #include "virtio.h"
16 #include "scsi.h"
17 #include "virtio-scsi.h"
18 #include "s390-time.h"
19 #include "helper.h"
20
21 static ScsiDevice default_scsi_device;
22 static VirtioScsiCmdReq req;
23 static VirtioScsiCmdResp resp;
24
25 static uint8_t scsi_inquiry_std_response[256];
26 static ScsiInquiryEvpdPages scsi_inquiry_evpd_pages_response;
27 static ScsiInquiryEvpdBl scsi_inquiry_evpd_bl_response;
28
vs_assert(bool term,const char ** msgs)29 static inline bool vs_assert(bool term, const char **msgs)
30 {
31 if (!term) {
32 int i = 0;
33
34 printf("\n! ");
35 while (msgs[i]) {
36 printf("%s", msgs[i++]);
37 }
38 puts(" !");
39 }
40
41 return term;
42 }
43
virtio_scsi_verify_response(VirtioScsiCmdResp * resp,const char * title)44 static bool virtio_scsi_verify_response(VirtioScsiCmdResp *resp,
45 const char *title)
46 {
47 const char *mr[] = {
48 title, ": response ", virtio_scsi_response_msg(resp), 0
49 };
50 const char *ms[] = {
51 title,
52 CDB_STATUS_VALID(resp->status) ? ": " : ": invalid ",
53 scsi_cdb_status_msg(resp->status),
54 resp->status == CDB_STATUS_CHECK_CONDITION ? " " : 0,
55 resp->sense_len ? scsi_cdb_asc_msg(resp->sense)
56 : "no sense data",
57 scsi_sense_response(resp->sense) == 0x70 ? ", sure" : "?",
58 0
59 };
60
61 return vs_assert(resp->response == VIRTIO_SCSI_S_OK, mr) &&
62 vs_assert(resp->status == CDB_STATUS_GOOD, ms);
63 }
64
prepare_request(VDev * vdev,const void * cdb,int cdb_size,void * data,uint32_t data_size)65 static void prepare_request(VDev *vdev, const void *cdb, int cdb_size,
66 void *data, uint32_t data_size)
67 {
68 const ScsiDevice *sdev = vdev->scsi_device;
69
70 memset(&req, 0, sizeof(req));
71 req.lun = make_lun(sdev->channel, sdev->target, sdev->lun);
72 memcpy(&req.cdb, cdb, cdb_size);
73
74 memset(&resp, 0, sizeof(resp));
75 resp.status = 0xff; /* set invalid */
76 resp.response = 0xff; /* */
77
78 if (data && data_size) {
79 memset(data, 0, data_size);
80 }
81 }
82
vs_io_assert(bool term,const char * msg)83 static inline bool vs_io_assert(bool term, const char *msg)
84 {
85 if (!term && !virtio_scsi_verify_response(&resp, msg)) {
86 return false;
87 }
88
89 return true;
90 }
91
vs_run(const char * title,VirtioCmd * cmd,VDev * vdev,const void * cdb,int cdb_size,void * data,uint32_t data_size)92 static int vs_run(const char *title, VirtioCmd *cmd, VDev *vdev,
93 const void *cdb, int cdb_size,
94 void *data, uint32_t data_size)
95 {
96 prepare_request(vdev, cdb, cdb_size, data, data_size);
97 if (!vs_io_assert(virtio_run(vdev, VR_REQUEST, cmd) == 0, title)) {
98 puts(title);
99 return -EIO;
100 }
101
102 return 0;
103 }
104
105 /* SCSI protocol implementation routines */
106
scsi_inquiry(VDev * vdev,uint8_t evpd,uint8_t page,void * data,uint32_t data_size)107 static int scsi_inquiry(VDev *vdev, uint8_t evpd, uint8_t page,
108 void *data, uint32_t data_size)
109 {
110 ScsiCdbInquiry cdb = {
111 .command = 0x12,
112 .b1 = evpd,
113 .b2 = page,
114 .alloc_len = data_size < 65535 ? data_size : 65535,
115 };
116 VirtioCmd inquiry[] = {
117 { &req, sizeof(req), VRING_DESC_F_NEXT },
118 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
119 { data, data_size, VRING_DESC_F_WRITE },
120 };
121
122 int ret = vs_run("inquiry", inquiry,
123 vdev, &cdb, sizeof(cdb), data, data_size);
124
125 return ret ? ret : virtio_scsi_response_ok(&resp);
126 }
127
scsi_test_unit_ready(VDev * vdev)128 static int scsi_test_unit_ready(VDev *vdev)
129 {
130 ScsiCdbTestUnitReady cdb = {
131 .command = 0x00,
132 };
133 VirtioCmd test_unit_ready[] = {
134 { &req, sizeof(req), VRING_DESC_F_NEXT },
135 { &resp, sizeof(resp), VRING_DESC_F_WRITE },
136 };
137
138 prepare_request(vdev, &cdb, sizeof(cdb), 0, 0);
139 virtio_run(vdev, VR_REQUEST, test_unit_ready); /* ignore errors here */
140
141 return virtio_scsi_response_ok(&resp);
142 }
143
scsi_report_luns(VDev * vdev,void * data,uint32_t data_size)144 static int scsi_report_luns(VDev *vdev, void *data, uint32_t data_size)
145 {
146 ScsiCdbReportLuns cdb = {
147 .command = 0xa0,
148 .select_report = 0x02, /* REPORT ALL */
149 .alloc_len = data_size,
150 };
151 VirtioCmd report_luns[] = {
152 { &req, sizeof(req), VRING_DESC_F_NEXT },
153 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
154 { data, data_size, VRING_DESC_F_WRITE },
155 };
156
157 int ret = vs_run("report luns", report_luns,
158 vdev, &cdb, sizeof(cdb), data, data_size);
159
160 return ret ? ret : virtio_scsi_response_ok(&resp);
161 }
162
scsi_read_10(VDev * vdev,unsigned long sector,int sectors,void * data,unsigned int data_size)163 static int scsi_read_10(VDev *vdev,
164 unsigned long sector, int sectors, void *data,
165 unsigned int data_size)
166 {
167 ScsiCdbRead10 cdb = {
168 .command = 0x28,
169 .lba = sector,
170 .xfer_length = sectors,
171 };
172 VirtioCmd read_10[] = {
173 { &req, sizeof(req), VRING_DESC_F_NEXT },
174 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
175 { data, data_size, VRING_DESC_F_WRITE },
176 };
177
178 debug_print_int("read_10 sector", sector);
179 debug_print_int("read_10 sectors", sectors);
180
181 int ret = vs_run("read(10)", read_10,
182 vdev, &cdb, sizeof(cdb), data, data_size);
183
184 return ret ? ret : virtio_scsi_response_ok(&resp);
185 }
186
scsi_read_capacity(VDev * vdev,void * data,uint32_t data_size)187 static int scsi_read_capacity(VDev *vdev,
188 void *data, uint32_t data_size)
189 {
190 ScsiCdbReadCapacity16 cdb = {
191 .command = 0x9e, /* SERVICE_ACTION_IN_16 */
192 .service_action = 0x10, /* SA_READ_CAPACITY */
193 .alloc_len = data_size,
194 };
195 VirtioCmd read_capacity_16[] = {
196 { &req, sizeof(req), VRING_DESC_F_NEXT },
197 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
198 { data, data_size, VRING_DESC_F_WRITE },
199 };
200
201 int ret = vs_run("read capacity", read_capacity_16,
202 vdev, &cdb, sizeof(cdb), data, data_size);
203
204 return ret ? ret : virtio_scsi_response_ok(&resp);
205 }
206
207 /* virtio-scsi routines */
208
209 /*
210 * Tries to locate a SCSI device and adds the information for the found
211 * device to the vdev->scsi_device structure.
212 * Returns 0 if SCSI device could be located, or a error code < 0 otherwise
213 */
virtio_scsi_locate_device(VDev * vdev)214 static int virtio_scsi_locate_device(VDev *vdev)
215 {
216 const uint16_t channel = 0; /* again, it's what QEMU does */
217 uint16_t target;
218 static uint8_t data[16 + 8 * 63];
219 ScsiLunReport *r = (void *) data;
220 ScsiDevice *sdev = vdev->scsi_device;
221 int i, ret, luns;
222
223 /* QEMU has hardcoded channel #0 in many places.
224 * If this hardcoded value is ever changed, we'll need to add code for
225 * vdev->config.scsi.max_channel != 0 here.
226 */
227 debug_print_int("config.scsi.max_channel", vdev->config.scsi.max_channel);
228 debug_print_int("config.scsi.max_target ", vdev->config.scsi.max_target);
229 debug_print_int("config.scsi.max_lun ", vdev->config.scsi.max_lun);
230 debug_print_int("config.scsi.max_sectors", vdev->config.scsi.max_sectors);
231
232 if (vdev->scsi_device_selected) {
233 sdev->channel = vdev->selected_scsi_device.channel;
234 sdev->target = vdev->selected_scsi_device.target;
235 sdev->lun = vdev->selected_scsi_device.lun;
236
237 IPL_check(sdev->channel == 0, "non-zero channel requested");
238 IPL_check(sdev->target <= vdev->config.scsi.max_target, "target# high");
239 IPL_check(sdev->lun <= vdev->config.scsi.max_lun, "LUN# high");
240 return 0;
241 }
242
243 for (target = 0; target <= vdev->config.scsi.max_target; target++) {
244 sdev->channel = channel;
245 sdev->target = target;
246 sdev->lun = 0; /* LUN has to be 0 for REPORT LUNS */
247 ret = scsi_report_luns(vdev, data, sizeof(data));
248 if (ret < 0) {
249 return ret;
250 }
251
252 else if (ret == 0) {
253 if (resp.response == VIRTIO_SCSI_S_BAD_TARGET) {
254 continue;
255 }
256 printf("target 0x%X\n", target);
257 if (!virtio_scsi_verify_response(&resp, "SCSI cannot report LUNs")) {
258 return -EIO;
259 }
260 }
261
262 if (r->lun_list_len == 0) {
263 printf("no LUNs for target 0x%X\n", target);
264 continue;
265 }
266 luns = r->lun_list_len / 8;
267 debug_print_int("LUNs reported", luns);
268 if (luns == 1) {
269 /* There is no ",lun=#" arg for -device or ",lun=0" given.
270 * Hence, the only LUN reported.
271 * Usually, it's 0.
272 */
273 sdev->lun = r->lun[0].v16[0]; /* it's returned this way */
274 debug_print_int("Have to use LUN", sdev->lun);
275 return 0; /* we have to use this device */
276 }
277 for (i = 0; i < luns; i++) {
278 if (r->lun[i].v64) {
279 /* Look for non-zero LUN - we have where to choose from */
280 sdev->lun = r->lun[i].v16[0];
281 debug_print_int("Will use LUN", sdev->lun);
282 return 0; /* we have found a device */
283 }
284 }
285 }
286
287 puts("Warning: Could not locate a usable virtio-scsi device");
288 return -ENODEV;
289 }
290
virtio_scsi_read_many(VDev * vdev,unsigned long sector,void * load_addr,int sec_num)291 int virtio_scsi_read_many(VDev *vdev,
292 unsigned long sector, void *load_addr, int sec_num)
293 {
294 int sector_count;
295 int f = vdev->blk_factor;
296 unsigned int data_size;
297 unsigned int max_transfer = MIN_NON_ZERO(vdev->config.scsi.max_sectors,
298 vdev->max_transfer);
299
300 do {
301 sector_count = MIN_NON_ZERO(sec_num, max_transfer);
302 data_size = sector_count * virtio_get_block_size() * f;
303 if (!scsi_read_10(vdev, sector * f, sector_count * f, load_addr,
304 data_size)) {
305 if (!virtio_scsi_verify_response(&resp, "virtio-scsi:read_many")) {
306 return -1;
307 }
308 }
309 load_addr += data_size;
310 sector += sector_count;
311 sec_num -= sector_count;
312 } while (sec_num > 0);
313
314 return 0;
315 }
316
virtio_scsi_inquiry_response_is_cdrom(void * data)317 static bool virtio_scsi_inquiry_response_is_cdrom(void *data)
318 {
319 const ScsiInquiryStd *response = data;
320 const int resp_data_fmt = response->b3 & 0x0f;
321 int i;
322
323 IPL_check(resp_data_fmt == 2, "Wrong INQUIRY response format");
324 if (resp_data_fmt != 2) {
325 return false; /* cannot decode */
326 }
327
328 if ((response->peripheral_qdt & 0x1f) == SCSI_INQ_RDT_CDROM) {
329 return true;
330 }
331
332 for (i = 0; i < sizeof(response->prod_id); i++) {
333 if (response->prod_id[i] != QEMU_CDROM_SIGNATURE[i]) {
334 return false;
335 }
336 }
337 return true;
338 }
339
scsi_parse_capacity_report(void * data,uint64_t * last_lba,uint32_t * lb_len)340 static void scsi_parse_capacity_report(void *data,
341 uint64_t *last_lba, uint32_t *lb_len)
342 {
343 ScsiReadCapacity16Data *p = data;
344
345 if (last_lba) {
346 *last_lba = p->ret_lba;
347 }
348
349 if (lb_len) {
350 *lb_len = p->lb_len;
351 }
352 }
353
virtio_scsi_setup(VDev * vdev)354 static int virtio_scsi_setup(VDev *vdev)
355 {
356 int retry_test_unit_ready = 3;
357 uint8_t data[256];
358 uint32_t data_size = sizeof(data);
359 ScsiInquiryEvpdPages *evpd = &scsi_inquiry_evpd_pages_response;
360 ScsiInquiryEvpdBl *evpd_bl = &scsi_inquiry_evpd_bl_response;
361 int i, ret;
362
363 vdev->scsi_device = &default_scsi_device;
364 ret = virtio_scsi_locate_device(vdev);
365 if (ret < 0) {
366 return ret;
367 }
368
369 /* We have to "ping" the device before it becomes readable */
370 while (!scsi_test_unit_ready(vdev)) {
371
372 if (!virtio_scsi_response_ok(&resp)) {
373 uint8_t code = resp.sense[0] & SCSI_SENSE_CODE_MASK;
374 uint8_t sense_key = resp.sense[2] & SCSI_SENSE_KEY_MASK;
375
376 if (resp.sense_len == 0) {
377 puts("virtio-scsi: setup: no SENSE data");
378 return -EINVAL;
379 }
380
381 if (!retry_test_unit_ready || code != 0x70 ||
382 sense_key != SCSI_SENSE_KEY_UNIT_ATTENTION) {
383 puts("virtio-scsi:setup: cannot retry");
384 return -EIO;
385 }
386
387 /* retry on CHECK_CONDITION/UNIT_ATTENTION as it
388 * may not designate a real error, but it may be
389 * a result of device reset, etc.
390 */
391 retry_test_unit_ready--;
392 sleep(1);
393 continue;
394 }
395
396 if (!virtio_scsi_verify_response(&resp, "virtio-scsi:setup")) {
397 return -1;
398 }
399 }
400
401 /* read and cache SCSI INQUIRY response */
402 ret = scsi_inquiry(vdev,
403 SCSI_INQUIRY_STANDARD,
404 SCSI_INQUIRY_STANDARD_NONE,
405 scsi_inquiry_std_response,
406 sizeof(scsi_inquiry_std_response));
407 if (ret < 1) {
408 if (ret != 0 || !virtio_scsi_verify_response(&resp,
409 "virtio-scsi:setup:inquiry")) {
410 return -1;
411 }
412 }
413
414 if (virtio_scsi_inquiry_response_is_cdrom(scsi_inquiry_std_response)) {
415 puts("SCSI CD-ROM detected.");
416 vdev->is_cdrom = true;
417 vdev->scsi_block_size = VIRTIO_ISO_BLOCK_SIZE;
418 }
419
420 ret = scsi_inquiry(vdev,
421 SCSI_INQUIRY_EVPD,
422 SCSI_INQUIRY_EVPD_SUPPORTED_PAGES,
423 evpd,
424 sizeof(*evpd));
425 if (ret < 1) {
426 if (ret != 0 || !virtio_scsi_verify_response(&resp,
427 "virtio-scsi:setup:supported_pages")) {
428 return -1;
429 }
430 }
431
432 debug_print_int("EVPD length", evpd->page_length);
433
434 for (i = 0; i <= evpd->page_length; i++) {
435 debug_print_int("supported EVPD page", evpd->byte[i]);
436
437 if (evpd->byte[i] != SCSI_INQUIRY_EVPD_BLOCK_LIMITS) {
438 continue;
439 }
440
441 ret = scsi_inquiry(vdev,
442 SCSI_INQUIRY_EVPD,
443 SCSI_INQUIRY_EVPD_BLOCK_LIMITS,
444 evpd_bl,
445 sizeof(*evpd_bl));
446 if (ret < 1) {
447 if (ret != 0 || !virtio_scsi_verify_response(&resp,
448 "virtio-scsi:setup:blocklimits")) {
449 return -1;
450 }
451 }
452
453 debug_print_int("max transfer", evpd_bl->max_transfer);
454 vdev->max_transfer = evpd_bl->max_transfer;
455 }
456
457 /*
458 * The host sg driver will often be unhappy with particularly large
459 * I/Os that exceed the block iovec limits. Let's enforce something
460 * reasonable, despite what the device configuration tells us.
461 */
462
463 vdev->max_transfer = MIN_NON_ZERO(VIRTIO_SCSI_MAX_SECTORS,
464 vdev->max_transfer);
465
466 ret = scsi_read_capacity(vdev, data, data_size);
467 if (ret < 1) {
468 if (ret != 0 || !virtio_scsi_verify_response(&resp,
469 "virtio-scsi:setup:read_capacity")) {
470 return -1;
471 }
472 }
473 scsi_parse_capacity_report(data, &vdev->scsi_last_block,
474 (uint32_t *) &vdev->scsi_block_size);
475
476 return 0;
477 }
478
virtio_scsi_setup_device(SubChannelId schid)479 int virtio_scsi_setup_device(SubChannelId schid)
480 {
481 VDev *vdev = virtio_get_device();
482
483 vdev->schid = schid;
484 virtio_setup_ccw(vdev);
485
486 if (vdev->config.scsi.sense_size != VIRTIO_SCSI_SENSE_SIZE) {
487 puts("Config: sense size mismatch");
488 return -EINVAL;
489 }
490
491 if (vdev->config.scsi.cdb_size != VIRTIO_SCSI_CDB_SIZE) {
492 puts("Config: CDB size mismatch");
493 return -EINVAL;
494 }
495
496 puts("Using virtio-scsi.");
497
498 return virtio_scsi_setup(vdev);
499 }
500