2 * Virtio-SCSI implementation for s390 machine loader for qemu
4 * Copyright 2015 IBM Corp.
5 * Author: Eugene "jno" Dvurechenski <jno@linux.vnet.ibm.com>
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
15 #include "virtio-scsi.h"
17 static ScsiDevice default_scsi_device
;
18 static VirtioScsiCmdReq req
;
19 static VirtioScsiCmdResp resp
;
21 static uint8_t scsi_inquiry_std_response
[256];
23 static inline void vs_assert(bool term
, const char **msgs
)
30 sclp_print(msgs
[i
++]);
36 static void virtio_scsi_verify_response(VirtioScsiCmdResp
*resp
,
40 title
, ": response ", virtio_scsi_response_msg(resp
), 0
44 CDB_STATUS_VALID(resp
->status
) ? ": " : ": invalid ",
45 scsi_cdb_status_msg(resp
->status
),
46 resp
->status
== CDB_STATUS_CHECK_CONDITION
? " " : 0,
47 resp
->sense_len
? scsi_cdb_asc_msg(resp
->sense
)
49 scsi_sense_response(resp
->sense
) == 0x70 ? ", sure" : "?",
53 vs_assert(resp
->response
== VIRTIO_SCSI_S_OK
, mr
);
54 vs_assert(resp
->status
== CDB_STATUS_GOOD
, ms
);
57 static void prepare_request(VDev
*vdev
, const void *cdb
, int cdb_size
,
58 void *data
, uint32_t data_size
)
60 const ScsiDevice
*sdev
= vdev
->scsi_device
;
62 memset(&req
, 0, sizeof(req
));
63 req
.lun
= make_lun(sdev
->channel
, sdev
->target
, sdev
->lun
);
64 memcpy(&req
.cdb
, cdb
, cdb_size
);
66 memset(&resp
, 0, sizeof(resp
));
67 resp
.status
= 0xff; /* set invalid */
68 resp
.response
= 0xff; /* */
70 if (data
&& data_size
) {
71 memset(data
, 0, data_size
);
75 static inline void vs_io_assert(bool term
, const char *msg
)
78 virtio_scsi_verify_response(&resp
, msg
);
82 static void vs_run(const char *title
, VirtioCmd
*cmd
, VDev
*vdev
,
83 const void *cdb
, int cdb_size
,
84 void *data
, uint32_t data_size
)
86 prepare_request(vdev
, cdb
, cdb_size
, data
, data_size
);
87 vs_io_assert(virtio_run(vdev
, VR_REQUEST
, cmd
) == 0, title
);
90 /* SCSI protocol implementation routines */
92 static bool scsi_inquiry(VDev
*vdev
, void *data
, uint32_t data_size
)
94 ScsiCdbInquiry cdb
= {
96 .alloc_len
= data_size
< 65535 ? data_size
: 65535,
98 VirtioCmd inquiry
[] = {
99 { &req
, sizeof(req
), VRING_DESC_F_NEXT
},
100 { &resp
, sizeof(resp
), VRING_DESC_F_WRITE
| VRING_DESC_F_NEXT
},
101 { data
, data_size
, VRING_DESC_F_WRITE
},
104 vs_run("inquiry", inquiry
, vdev
, &cdb
, sizeof(cdb
), data
, data_size
);
106 return virtio_scsi_response_ok(&resp
);
109 static bool scsi_test_unit_ready(VDev
*vdev
)
111 ScsiCdbTestUnitReady cdb
= {
114 VirtioCmd test_unit_ready
[] = {
115 { &req
, sizeof(req
), VRING_DESC_F_NEXT
},
116 { &resp
, sizeof(resp
), VRING_DESC_F_WRITE
},
119 prepare_request(vdev
, &cdb
, sizeof(cdb
), 0, 0);
120 virtio_run(vdev
, VR_REQUEST
, test_unit_ready
); /* ignore errors here */
122 return virtio_scsi_response_ok(&resp
);
125 static bool scsi_report_luns(VDev
*vdev
, void *data
, uint32_t data_size
)
127 ScsiCdbReportLuns cdb
= {
129 .select_report
= 0x02, /* REPORT ALL */
130 .alloc_len
= data_size
,
132 VirtioCmd report_luns
[] = {
133 { &req
, sizeof(req
), VRING_DESC_F_NEXT
},
134 { &resp
, sizeof(resp
), VRING_DESC_F_WRITE
| VRING_DESC_F_NEXT
},
135 { data
, data_size
, VRING_DESC_F_WRITE
},
138 vs_run("report luns", report_luns
,
139 vdev
, &cdb
, sizeof(cdb
), data
, data_size
);
141 return virtio_scsi_response_ok(&resp
);
144 static bool scsi_read_10(VDev
*vdev
,
145 ulong sector
, int sectors
, void *data
,
146 unsigned int data_size
)
148 ScsiCdbRead10 cdb
= {
151 .xfer_length
= sectors
,
153 VirtioCmd read_10
[] = {
154 { &req
, sizeof(req
), VRING_DESC_F_NEXT
},
155 { &resp
, sizeof(resp
), VRING_DESC_F_WRITE
| VRING_DESC_F_NEXT
},
156 { data
, data_size
, VRING_DESC_F_WRITE
},
159 debug_print_int("read_10 sector", sector
);
160 debug_print_int("read_10 sectors", sectors
);
162 vs_run("read(10)", read_10
, vdev
, &cdb
, sizeof(cdb
), data
, data_size
);
164 return virtio_scsi_response_ok(&resp
);
167 static bool scsi_read_capacity(VDev
*vdev
,
168 void *data
, uint32_t data_size
)
170 ScsiCdbReadCapacity16 cdb
= {
171 .command
= 0x9e, /* SERVICE_ACTION_IN_16 */
172 .service_action
= 0x10, /* SA_READ_CAPACITY */
173 .alloc_len
= data_size
,
175 VirtioCmd read_capacity_16
[] = {
176 { &req
, sizeof(req
), VRING_DESC_F_NEXT
},
177 { &resp
, sizeof(resp
), VRING_DESC_F_WRITE
| VRING_DESC_F_NEXT
},
178 { data
, data_size
, VRING_DESC_F_WRITE
},
181 vs_run("read capacity", read_capacity_16
,
182 vdev
, &cdb
, sizeof(cdb
), data
, data_size
);
184 return virtio_scsi_response_ok(&resp
);
187 /* virtio-scsi routines */
189 static void virtio_scsi_locate_device(VDev
*vdev
)
191 const uint16_t channel
= 0; /* again, it's what QEMU does */
193 static uint8_t data
[16 + 8 * 63];
194 ScsiLunReport
*r
= (void *) data
;
195 ScsiDevice
*sdev
= vdev
->scsi_device
;
198 /* QEMU has hardcoded channel #0 in many places.
199 * If this hardcoded value is ever changed, we'll need to add code for
200 * vdev->config.scsi.max_channel != 0 here.
202 debug_print_int("config.scsi.max_channel", vdev
->config
.scsi
.max_channel
);
203 debug_print_int("config.scsi.max_target ", vdev
->config
.scsi
.max_target
);
204 debug_print_int("config.scsi.max_lun ", vdev
->config
.scsi
.max_lun
);
205 debug_print_int("config.scsi.max_sectors", vdev
->config
.scsi
.max_sectors
);
207 if (vdev
->scsi_device_selected
) {
208 sdev
->channel
= vdev
->selected_scsi_device
.channel
;
209 sdev
->target
= vdev
->selected_scsi_device
.target
;
210 sdev
->lun
= vdev
->selected_scsi_device
.lun
;
212 IPL_check(sdev
->channel
== 0, "non-zero channel requested");
213 IPL_check(sdev
->target
<= vdev
->config
.scsi
.max_target
, "target# high");
214 IPL_check(sdev
->lun
<= vdev
->config
.scsi
.max_lun
, "LUN# high");
218 for (target
= 0; target
<= vdev
->config
.scsi
.max_target
; target
++) {
219 sdev
->channel
= channel
;
220 sdev
->target
= target
; /* sdev->lun will be 0 here */
221 if (!scsi_report_luns(vdev
, data
, sizeof(data
))) {
222 if (resp
.response
== VIRTIO_SCSI_S_BAD_TARGET
) {
225 print_int("target", target
);
226 virtio_scsi_verify_response(&resp
, "SCSI cannot report LUNs");
228 if (r
->lun_list_len
== 0) {
229 print_int("no LUNs for target", target
);
232 luns
= r
->lun_list_len
/ 8;
233 debug_print_int("LUNs reported", luns
);
235 /* There is no ",lun=#" arg for -device or ",lun=0" given.
236 * Hence, the only LUN reported.
239 sdev
->lun
= r
->lun
[0].v16
[0]; /* it's returned this way */
240 debug_print_int("Have to use LUN", sdev
->lun
);
241 return; /* we have to use this device */
243 for (i
= 0; i
< luns
; i
++) {
245 /* Look for non-zero LUN - we have where to choose from */
246 sdev
->lun
= r
->lun
[i
].v16
[0];
247 debug_print_int("Will use LUN", sdev
->lun
);
248 return; /* we have found a device */
252 panic("\n! Cannot locate virtio-scsi device !\n");
255 int virtio_scsi_read_many(VDev
*vdev
,
256 ulong sector
, void *load_addr
, int sec_num
)
259 int f
= vdev
->blk_factor
;
260 unsigned int data_size
;
263 sector_count
= MIN_NON_ZERO(sec_num
, vdev
->config
.scsi
.max_sectors
);
264 data_size
= sector_count
* virtio_get_block_size() * f
;
265 if (!scsi_read_10(vdev
, sector
* f
, sector_count
* f
, load_addr
,
267 virtio_scsi_verify_response(&resp
, "virtio-scsi:read_many");
269 load_addr
+= data_size
;
270 sector
+= sector_count
;
271 sec_num
-= sector_count
;
272 } while (sec_num
> 0);
277 static bool virtio_scsi_inquiry_response_is_cdrom(void *data
)
279 const ScsiInquiryStd
*response
= data
;
280 const int resp_data_fmt
= response
->b3
& 0x0f;
283 IPL_check(resp_data_fmt
== 2, "Wrong INQUIRY response format");
284 if (resp_data_fmt
!= 2) {
285 return false; /* cannot decode */
288 if ((response
->peripheral_qdt
& 0x1f) == SCSI_INQ_RDT_CDROM
) {
292 for (i
= 0; i
< sizeof(response
->prod_id
); i
++) {
293 if (response
->prod_id
[i
] != QEMU_CDROM_SIGNATURE
[i
]) {
300 static void scsi_parse_capacity_report(void *data
,
301 uint64_t *last_lba
, uint32_t *lb_len
)
303 ScsiReadCapacity16Data
*p
= data
;
306 *last_lba
= p
->ret_lba
;
314 void virtio_scsi_setup(VDev
*vdev
)
316 int retry_test_unit_ready
= 3;
318 uint32_t data_size
= sizeof(data
);
320 vdev
->scsi_device
= &default_scsi_device
;
321 virtio_scsi_locate_device(vdev
);
323 /* We have to "ping" the device before it becomes readable */
324 while (!scsi_test_unit_ready(vdev
)) {
326 if (!virtio_scsi_response_ok(&resp
)) {
327 uint8_t code
= resp
.sense
[0] & SCSI_SENSE_CODE_MASK
;
328 uint8_t sense_key
= resp
.sense
[2] & SCSI_SENSE_KEY_MASK
;
330 IPL_assert(resp
.sense_len
!= 0, "virtio-scsi:setup: no SENSE data");
332 IPL_assert(retry_test_unit_ready
&& code
== 0x70 &&
333 sense_key
== SCSI_SENSE_KEY_UNIT_ATTENTION
,
334 "virtio-scsi:setup: cannot retry");
336 /* retry on CHECK_CONDITION/UNIT_ATTENTION as it
337 * may not designate a real error, but it may be
338 * a result of device reset, etc.
340 retry_test_unit_ready
--;
345 virtio_scsi_verify_response(&resp
, "virtio-scsi:setup");
348 /* read and cache SCSI INQUIRY response */
349 if (!scsi_inquiry(vdev
, scsi_inquiry_std_response
,
350 sizeof(scsi_inquiry_std_response
))) {
351 virtio_scsi_verify_response(&resp
, "virtio-scsi:setup:inquiry");
354 if (virtio_scsi_inquiry_response_is_cdrom(scsi_inquiry_std_response
)) {
355 sclp_print("SCSI CD-ROM detected.\n");
356 vdev
->is_cdrom
= true;
357 vdev
->scsi_block_size
= VIRTIO_ISO_BLOCK_SIZE
;
360 if (!scsi_read_capacity(vdev
, data
, data_size
)) {
361 virtio_scsi_verify_response(&resp
, "virtio-scsi:setup:read_capacity");
363 scsi_parse_capacity_report(data
, &vdev
->scsi_last_block
,
364 (uint32_t *) &vdev
->scsi_block_size
);