2015-11-10 15:36:13 +01:00
|
|
|
/*
|
|
|
|
* Virtio-SCSI implementation for s390 machine loader for qemu
|
|
|
|
*
|
|
|
|
* Copyright 2015 IBM Corp.
|
|
|
|
* Author: Eugene "jno" Dvurechenski <jno@linux.vnet.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or (at
|
|
|
|
* your option) any later version. See the COPYING file in the top-level
|
|
|
|
* directory.
|
|
|
|
*/
|
|
|
|
|
2017-07-12 14:49:43 +02:00
|
|
|
#include "libc.h"
|
2015-11-10 15:36:13 +01:00
|
|
|
#include "s390-ccw.h"
|
|
|
|
#include "virtio.h"
|
|
|
|
#include "scsi.h"
|
|
|
|
#include "virtio-scsi.h"
|
2020-06-24 09:52:16 +02:00
|
|
|
#include "s390-time.h"
|
2020-06-24 09:52:17 +02:00
|
|
|
#include "helper.h"
|
2015-11-10 15:36:13 +01:00
|
|
|
|
|
|
|
static ScsiDevice default_scsi_device;
|
|
|
|
static VirtioScsiCmdReq req;
|
|
|
|
static VirtioScsiCmdResp resp;
|
|
|
|
|
|
|
|
static uint8_t scsi_inquiry_std_response[256];
|
2017-05-10 17:53:56 +02:00
|
|
|
static ScsiInquiryEvpdPages scsi_inquiry_evpd_pages_response;
|
pc-bios/s390-ccw: Get Block Limits VPD device data
The "Block Limits" Inquiry VPD page is optional for any SCSI device,
but if it's supported it provides a hint of the maximum I/O transfer
length for this particular device. If this page is supported by the
disk, let's issue that Inquiry and use the minimum of it and the
SCSI controller limit. That will cover this scenario:
qemu-system-s390x ...
-device virtio-scsi-ccw,id=scsi0,max_sectors=32768 ...
-drive file=/dev/sda,if=none,id=drive0,format=raw ...
-device scsi-hd,bus=scsi0.0,channel=0,scsi-id=0,
drive=drive0,id=disk0,max_io_size=1048576
controller: 32768 sectors x 512 bytes/sector = 16777216 bytes
disk: 1048576 bytes
Now that we have a limit for a virtio-scsi disk, compare that with the
limit for the virtio-scsi controller when we actually build the I/O.
The minimum of these two limits should be the one we use.
Signed-off-by: Eric Farman <farman@linux.vnet.ibm.com>
Message-Id: <20170510155359.32727-7-farman@linux.vnet.ibm.com>
Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com>
2017-05-10 17:53:57 +02:00
|
|
|
static ScsiInquiryEvpdBl scsi_inquiry_evpd_bl_response;
|
2015-11-10 15:36:13 +01:00
|
|
|
|
|
|
|
static inline void vs_assert(bool term, const char **msgs)
|
|
|
|
{
|
|
|
|
if (!term) {
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
sclp_print("\n! ");
|
|
|
|
while (msgs[i]) {
|
|
|
|
sclp_print(msgs[i++]);
|
|
|
|
}
|
|
|
|
panic(" !\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_scsi_verify_response(VirtioScsiCmdResp *resp,
|
|
|
|
const char *title)
|
|
|
|
{
|
|
|
|
const char *mr[] = {
|
|
|
|
title, ": response ", virtio_scsi_response_msg(resp), 0
|
|
|
|
};
|
|
|
|
const char *ms[] = {
|
|
|
|
title,
|
|
|
|
CDB_STATUS_VALID(resp->status) ? ": " : ": invalid ",
|
|
|
|
scsi_cdb_status_msg(resp->status),
|
|
|
|
resp->status == CDB_STATUS_CHECK_CONDITION ? " " : 0,
|
|
|
|
resp->sense_len ? scsi_cdb_asc_msg(resp->sense)
|
|
|
|
: "no sense data",
|
|
|
|
scsi_sense_response(resp->sense) == 0x70 ? ", sure" : "?",
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
|
|
|
vs_assert(resp->response == VIRTIO_SCSI_S_OK, mr);
|
|
|
|
vs_assert(resp->status == CDB_STATUS_GOOD, ms);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_request(VDev *vdev, const void *cdb, int cdb_size,
|
|
|
|
void *data, uint32_t data_size)
|
|
|
|
{
|
|
|
|
const ScsiDevice *sdev = vdev->scsi_device;
|
|
|
|
|
|
|
|
memset(&req, 0, sizeof(req));
|
|
|
|
req.lun = make_lun(sdev->channel, sdev->target, sdev->lun);
|
|
|
|
memcpy(&req.cdb, cdb, cdb_size);
|
|
|
|
|
|
|
|
memset(&resp, 0, sizeof(resp));
|
|
|
|
resp.status = 0xff; /* set invalid */
|
|
|
|
resp.response = 0xff; /* */
|
|
|
|
|
|
|
|
if (data && data_size) {
|
|
|
|
memset(data, 0, data_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void vs_io_assert(bool term, const char *msg)
|
|
|
|
{
|
|
|
|
if (!term) {
|
|
|
|
virtio_scsi_verify_response(&resp, msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vs_run(const char *title, VirtioCmd *cmd, VDev *vdev,
|
|
|
|
const void *cdb, int cdb_size,
|
|
|
|
void *data, uint32_t data_size)
|
|
|
|
{
|
|
|
|
prepare_request(vdev, cdb, cdb_size, data, data_size);
|
|
|
|
vs_io_assert(virtio_run(vdev, VR_REQUEST, cmd) == 0, title);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SCSI protocol implementation routines */
|
|
|
|
|
2017-05-10 17:53:55 +02:00
|
|
|
static bool scsi_inquiry(VDev *vdev, uint8_t evpd, uint8_t page,
|
|
|
|
void *data, uint32_t data_size)
|
2015-11-10 15:36:13 +01:00
|
|
|
{
|
|
|
|
ScsiCdbInquiry cdb = {
|
|
|
|
.command = 0x12,
|
2017-05-10 17:53:55 +02:00
|
|
|
.b1 = evpd,
|
|
|
|
.b2 = page,
|
2015-11-10 15:36:13 +01:00
|
|
|
.alloc_len = data_size < 65535 ? data_size : 65535,
|
|
|
|
};
|
|
|
|
VirtioCmd inquiry[] = {
|
|
|
|
{ &req, sizeof(req), VRING_DESC_F_NEXT },
|
|
|
|
{ &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
|
|
|
|
{ data, data_size, VRING_DESC_F_WRITE },
|
|
|
|
};
|
|
|
|
|
|
|
|
vs_run("inquiry", inquiry, vdev, &cdb, sizeof(cdb), data, data_size);
|
|
|
|
|
|
|
|
return virtio_scsi_response_ok(&resp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool scsi_test_unit_ready(VDev *vdev)
|
|
|
|
{
|
|
|
|
ScsiCdbTestUnitReady cdb = {
|
|
|
|
.command = 0x00,
|
|
|
|
};
|
|
|
|
VirtioCmd test_unit_ready[] = {
|
|
|
|
{ &req, sizeof(req), VRING_DESC_F_NEXT },
|
|
|
|
{ &resp, sizeof(resp), VRING_DESC_F_WRITE },
|
|
|
|
};
|
|
|
|
|
|
|
|
prepare_request(vdev, &cdb, sizeof(cdb), 0, 0);
|
|
|
|
virtio_run(vdev, VR_REQUEST, test_unit_ready); /* ignore errors here */
|
|
|
|
|
|
|
|
return virtio_scsi_response_ok(&resp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool scsi_report_luns(VDev *vdev, void *data, uint32_t data_size)
|
|
|
|
{
|
|
|
|
ScsiCdbReportLuns cdb = {
|
|
|
|
.command = 0xa0,
|
|
|
|
.select_report = 0x02, /* REPORT ALL */
|
|
|
|
.alloc_len = data_size,
|
|
|
|
};
|
|
|
|
VirtioCmd report_luns[] = {
|
|
|
|
{ &req, sizeof(req), VRING_DESC_F_NEXT },
|
|
|
|
{ &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
|
|
|
|
{ data, data_size, VRING_DESC_F_WRITE },
|
|
|
|
};
|
|
|
|
|
|
|
|
vs_run("report luns", report_luns,
|
|
|
|
vdev, &cdb, sizeof(cdb), data, data_size);
|
|
|
|
|
|
|
|
return virtio_scsi_response_ok(&resp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool scsi_read_10(VDev *vdev,
|
2017-05-10 17:53:53 +02:00
|
|
|
ulong sector, int sectors, void *data,
|
|
|
|
unsigned int data_size)
|
2015-11-10 15:36:13 +01:00
|
|
|
{
|
|
|
|
ScsiCdbRead10 cdb = {
|
|
|
|
.command = 0x28,
|
2017-05-10 17:53:53 +02:00
|
|
|
.lba = sector,
|
|
|
|
.xfer_length = sectors,
|
2015-11-10 15:36:13 +01:00
|
|
|
};
|
|
|
|
VirtioCmd read_10[] = {
|
|
|
|
{ &req, sizeof(req), VRING_DESC_F_NEXT },
|
|
|
|
{ &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
|
2017-05-10 17:53:52 +02:00
|
|
|
{ data, data_size, VRING_DESC_F_WRITE },
|
2015-11-10 15:36:13 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
debug_print_int("read_10 sector", sector);
|
|
|
|
debug_print_int("read_10 sectors", sectors);
|
|
|
|
|
|
|
|
vs_run("read(10)", read_10, vdev, &cdb, sizeof(cdb), data, data_size);
|
|
|
|
|
|
|
|
return virtio_scsi_response_ok(&resp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool scsi_read_capacity(VDev *vdev,
|
|
|
|
void *data, uint32_t data_size)
|
|
|
|
{
|
|
|
|
ScsiCdbReadCapacity16 cdb = {
|
|
|
|
.command = 0x9e, /* SERVICE_ACTION_IN_16 */
|
|
|
|
.service_action = 0x10, /* SA_READ_CAPACITY */
|
|
|
|
.alloc_len = data_size,
|
|
|
|
};
|
|
|
|
VirtioCmd read_capacity_16[] = {
|
|
|
|
{ &req, sizeof(req), VRING_DESC_F_NEXT },
|
|
|
|
{ &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
|
|
|
|
{ data, data_size, VRING_DESC_F_WRITE },
|
|
|
|
};
|
|
|
|
|
|
|
|
vs_run("read capacity", read_capacity_16,
|
|
|
|
vdev, &cdb, sizeof(cdb), data, data_size);
|
|
|
|
|
|
|
|
return virtio_scsi_response_ok(&resp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* virtio-scsi routines */
|
|
|
|
|
|
|
|
static void virtio_scsi_locate_device(VDev *vdev)
|
|
|
|
{
|
|
|
|
const uint16_t channel = 0; /* again, it's what QEMU does */
|
|
|
|
uint16_t target;
|
|
|
|
static uint8_t data[16 + 8 * 63];
|
|
|
|
ScsiLunReport *r = (void *) data;
|
|
|
|
ScsiDevice *sdev = vdev->scsi_device;
|
|
|
|
int i, luns;
|
|
|
|
|
|
|
|
/* QEMU has hardcoded channel #0 in many places.
|
|
|
|
* If this hardcoded value is ever changed, we'll need to add code for
|
|
|
|
* vdev->config.scsi.max_channel != 0 here.
|
|
|
|
*/
|
|
|
|
debug_print_int("config.scsi.max_channel", vdev->config.scsi.max_channel);
|
|
|
|
debug_print_int("config.scsi.max_target ", vdev->config.scsi.max_target);
|
|
|
|
debug_print_int("config.scsi.max_lun ", vdev->config.scsi.max_lun);
|
2017-05-10 17:53:54 +02:00
|
|
|
debug_print_int("config.scsi.max_sectors", vdev->config.scsi.max_sectors);
|
2015-11-10 15:36:13 +01:00
|
|
|
|
2016-06-01 15:25:51 +02:00
|
|
|
if (vdev->scsi_device_selected) {
|
|
|
|
sdev->channel = vdev->selected_scsi_device.channel;
|
|
|
|
sdev->target = vdev->selected_scsi_device.target;
|
|
|
|
sdev->lun = vdev->selected_scsi_device.lun;
|
|
|
|
|
|
|
|
IPL_check(sdev->channel == 0, "non-zero channel requested");
|
|
|
|
IPL_check(sdev->target <= vdev->config.scsi.max_target, "target# high");
|
|
|
|
IPL_check(sdev->lun <= vdev->config.scsi.max_lun, "LUN# high");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-11-10 15:36:13 +01:00
|
|
|
for (target = 0; target <= vdev->config.scsi.max_target; target++) {
|
|
|
|
sdev->channel = channel;
|
2017-11-17 19:10:28 +01:00
|
|
|
sdev->target = target;
|
|
|
|
sdev->lun = 0; /* LUN has to be 0 for REPORT LUNS */
|
2015-11-10 15:36:13 +01:00
|
|
|
if (!scsi_report_luns(vdev, data, sizeof(data))) {
|
|
|
|
if (resp.response == VIRTIO_SCSI_S_BAD_TARGET) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
print_int("target", target);
|
|
|
|
virtio_scsi_verify_response(&resp, "SCSI cannot report LUNs");
|
|
|
|
}
|
|
|
|
if (r->lun_list_len == 0) {
|
|
|
|
print_int("no LUNs for target", target);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
luns = r->lun_list_len / 8;
|
|
|
|
debug_print_int("LUNs reported", luns);
|
|
|
|
if (luns == 1) {
|
|
|
|
/* There is no ",lun=#" arg for -device or ",lun=0" given.
|
|
|
|
* Hence, the only LUN reported.
|
|
|
|
* Usually, it's 0.
|
|
|
|
*/
|
|
|
|
sdev->lun = r->lun[0].v16[0]; /* it's returned this way */
|
|
|
|
debug_print_int("Have to use LUN", sdev->lun);
|
|
|
|
return; /* we have to use this device */
|
|
|
|
}
|
|
|
|
for (i = 0; i < luns; i++) {
|
|
|
|
if (r->lun[i].v64) {
|
|
|
|
/* Look for non-zero LUN - we have where to choose from */
|
|
|
|
sdev->lun = r->lun[i].v16[0];
|
|
|
|
debug_print_int("Will use LUN", sdev->lun);
|
|
|
|
return; /* we have found a device */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic("\n! Cannot locate virtio-scsi device !\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
int virtio_scsi_read_many(VDev *vdev,
|
|
|
|
ulong sector, void *load_addr, int sec_num)
|
|
|
|
{
|
2017-05-10 17:53:54 +02:00
|
|
|
int sector_count;
|
2017-05-10 17:53:53 +02:00
|
|
|
int f = vdev->blk_factor;
|
2017-05-10 17:53:54 +02:00
|
|
|
unsigned int data_size;
|
pc-bios/s390-ccw: Get Block Limits VPD device data
The "Block Limits" Inquiry VPD page is optional for any SCSI device,
but if it's supported it provides a hint of the maximum I/O transfer
length for this particular device. If this page is supported by the
disk, let's issue that Inquiry and use the minimum of it and the
SCSI controller limit. That will cover this scenario:
qemu-system-s390x ...
-device virtio-scsi-ccw,id=scsi0,max_sectors=32768 ...
-drive file=/dev/sda,if=none,id=drive0,format=raw ...
-device scsi-hd,bus=scsi0.0,channel=0,scsi-id=0,
drive=drive0,id=disk0,max_io_size=1048576
controller: 32768 sectors x 512 bytes/sector = 16777216 bytes
disk: 1048576 bytes
Now that we have a limit for a virtio-scsi disk, compare that with the
limit for the virtio-scsi controller when we actually build the I/O.
The minimum of these two limits should be the one we use.
Signed-off-by: Eric Farman <farman@linux.vnet.ibm.com>
Message-Id: <20170510155359.32727-7-farman@linux.vnet.ibm.com>
Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com>
2017-05-10 17:53:57 +02:00
|
|
|
unsigned int max_transfer = MIN_NON_ZERO(vdev->config.scsi.max_sectors,
|
|
|
|
vdev->max_transfer);
|
2017-05-10 17:53:54 +02:00
|
|
|
|
|
|
|
do {
|
pc-bios/s390-ccw: Get Block Limits VPD device data
The "Block Limits" Inquiry VPD page is optional for any SCSI device,
but if it's supported it provides a hint of the maximum I/O transfer
length for this particular device. If this page is supported by the
disk, let's issue that Inquiry and use the minimum of it and the
SCSI controller limit. That will cover this scenario:
qemu-system-s390x ...
-device virtio-scsi-ccw,id=scsi0,max_sectors=32768 ...
-drive file=/dev/sda,if=none,id=drive0,format=raw ...
-device scsi-hd,bus=scsi0.0,channel=0,scsi-id=0,
drive=drive0,id=disk0,max_io_size=1048576
controller: 32768 sectors x 512 bytes/sector = 16777216 bytes
disk: 1048576 bytes
Now that we have a limit for a virtio-scsi disk, compare that with the
limit for the virtio-scsi controller when we actually build the I/O.
The minimum of these two limits should be the one we use.
Signed-off-by: Eric Farman <farman@linux.vnet.ibm.com>
Message-Id: <20170510155359.32727-7-farman@linux.vnet.ibm.com>
Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com>
2017-05-10 17:53:57 +02:00
|
|
|
sector_count = MIN_NON_ZERO(sec_num, max_transfer);
|
2017-05-10 17:53:54 +02:00
|
|
|
data_size = sector_count * virtio_get_block_size() * f;
|
|
|
|
if (!scsi_read_10(vdev, sector * f, sector_count * f, load_addr,
|
|
|
|
data_size)) {
|
|
|
|
virtio_scsi_verify_response(&resp, "virtio-scsi:read_many");
|
|
|
|
}
|
|
|
|
load_addr += data_size;
|
|
|
|
sector += sector_count;
|
|
|
|
sec_num -= sector_count;
|
|
|
|
} while (sec_num > 0);
|
2015-11-10 15:36:13 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool virtio_scsi_inquiry_response_is_cdrom(void *data)
|
|
|
|
{
|
|
|
|
const ScsiInquiryStd *response = data;
|
|
|
|
const int resp_data_fmt = response->b3 & 0x0f;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
IPL_check(resp_data_fmt == 2, "Wrong INQUIRY response format");
|
|
|
|
if (resp_data_fmt != 2) {
|
|
|
|
return false; /* cannot decode */
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((response->peripheral_qdt & 0x1f) == SCSI_INQ_RDT_CDROM) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < sizeof(response->prod_id); i++) {
|
|
|
|
if (response->prod_id[i] != QEMU_CDROM_SIGNATURE[i]) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_parse_capacity_report(void *data,
|
|
|
|
uint64_t *last_lba, uint32_t *lb_len)
|
|
|
|
{
|
|
|
|
ScsiReadCapacity16Data *p = data;
|
|
|
|
|
|
|
|
if (last_lba) {
|
|
|
|
*last_lba = p->ret_lba;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lb_len) {
|
|
|
|
*lb_len = p->lb_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void virtio_scsi_setup(VDev *vdev)
|
|
|
|
{
|
|
|
|
int retry_test_unit_ready = 3;
|
|
|
|
uint8_t data[256];
|
|
|
|
uint32_t data_size = sizeof(data);
|
2017-05-10 17:53:56 +02:00
|
|
|
ScsiInquiryEvpdPages *evpd = &scsi_inquiry_evpd_pages_response;
|
pc-bios/s390-ccw: Get Block Limits VPD device data
The "Block Limits" Inquiry VPD page is optional for any SCSI device,
but if it's supported it provides a hint of the maximum I/O transfer
length for this particular device. If this page is supported by the
disk, let's issue that Inquiry and use the minimum of it and the
SCSI controller limit. That will cover this scenario:
qemu-system-s390x ...
-device virtio-scsi-ccw,id=scsi0,max_sectors=32768 ...
-drive file=/dev/sda,if=none,id=drive0,format=raw ...
-device scsi-hd,bus=scsi0.0,channel=0,scsi-id=0,
drive=drive0,id=disk0,max_io_size=1048576
controller: 32768 sectors x 512 bytes/sector = 16777216 bytes
disk: 1048576 bytes
Now that we have a limit for a virtio-scsi disk, compare that with the
limit for the virtio-scsi controller when we actually build the I/O.
The minimum of these two limits should be the one we use.
Signed-off-by: Eric Farman <farman@linux.vnet.ibm.com>
Message-Id: <20170510155359.32727-7-farman@linux.vnet.ibm.com>
Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com>
2017-05-10 17:53:57 +02:00
|
|
|
ScsiInquiryEvpdBl *evpd_bl = &scsi_inquiry_evpd_bl_response;
|
2017-05-10 17:53:56 +02:00
|
|
|
int i;
|
2015-11-10 15:36:13 +01:00
|
|
|
|
|
|
|
vdev->scsi_device = &default_scsi_device;
|
|
|
|
virtio_scsi_locate_device(vdev);
|
|
|
|
|
|
|
|
/* We have to "ping" the device before it becomes readable */
|
|
|
|
while (!scsi_test_unit_ready(vdev)) {
|
|
|
|
|
|
|
|
if (!virtio_scsi_response_ok(&resp)) {
|
|
|
|
uint8_t code = resp.sense[0] & SCSI_SENSE_CODE_MASK;
|
|
|
|
uint8_t sense_key = resp.sense[2] & SCSI_SENSE_KEY_MASK;
|
|
|
|
|
|
|
|
IPL_assert(resp.sense_len != 0, "virtio-scsi:setup: no SENSE data");
|
|
|
|
|
|
|
|
IPL_assert(retry_test_unit_ready && code == 0x70 &&
|
|
|
|
sense_key == SCSI_SENSE_KEY_UNIT_ATTENTION,
|
|
|
|
"virtio-scsi:setup: cannot retry");
|
|
|
|
|
|
|
|
/* retry on CHECK_CONDITION/UNIT_ATTENTION as it
|
|
|
|
* may not designate a real error, but it may be
|
|
|
|
* a result of device reset, etc.
|
|
|
|
*/
|
|
|
|
retry_test_unit_ready--;
|
|
|
|
sleep(1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtio_scsi_verify_response(&resp, "virtio-scsi:setup");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* read and cache SCSI INQUIRY response */
|
2017-05-10 17:53:55 +02:00
|
|
|
if (!scsi_inquiry(vdev,
|
|
|
|
SCSI_INQUIRY_STANDARD,
|
|
|
|
SCSI_INQUIRY_STANDARD_NONE,
|
|
|
|
scsi_inquiry_std_response,
|
2015-11-10 15:36:13 +01:00
|
|
|
sizeof(scsi_inquiry_std_response))) {
|
|
|
|
virtio_scsi_verify_response(&resp, "virtio-scsi:setup:inquiry");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virtio_scsi_inquiry_response_is_cdrom(scsi_inquiry_std_response)) {
|
|
|
|
sclp_print("SCSI CD-ROM detected.\n");
|
|
|
|
vdev->is_cdrom = true;
|
|
|
|
vdev->scsi_block_size = VIRTIO_ISO_BLOCK_SIZE;
|
|
|
|
}
|
|
|
|
|
2017-05-10 17:53:56 +02:00
|
|
|
if (!scsi_inquiry(vdev,
|
|
|
|
SCSI_INQUIRY_EVPD,
|
|
|
|
SCSI_INQUIRY_EVPD_SUPPORTED_PAGES,
|
|
|
|
evpd,
|
|
|
|
sizeof(*evpd))) {
|
|
|
|
virtio_scsi_verify_response(&resp, "virtio-scsi:setup:supported_pages");
|
|
|
|
}
|
|
|
|
|
|
|
|
debug_print_int("EVPD length", evpd->page_length);
|
|
|
|
|
|
|
|
for (i = 0; i <= evpd->page_length; i++) {
|
|
|
|
debug_print_int("supported EVPD page", evpd->byte[i]);
|
pc-bios/s390-ccw: Get Block Limits VPD device data
The "Block Limits" Inquiry VPD page is optional for any SCSI device,
but if it's supported it provides a hint of the maximum I/O transfer
length for this particular device. If this page is supported by the
disk, let's issue that Inquiry and use the minimum of it and the
SCSI controller limit. That will cover this scenario:
qemu-system-s390x ...
-device virtio-scsi-ccw,id=scsi0,max_sectors=32768 ...
-drive file=/dev/sda,if=none,id=drive0,format=raw ...
-device scsi-hd,bus=scsi0.0,channel=0,scsi-id=0,
drive=drive0,id=disk0,max_io_size=1048576
controller: 32768 sectors x 512 bytes/sector = 16777216 bytes
disk: 1048576 bytes
Now that we have a limit for a virtio-scsi disk, compare that with the
limit for the virtio-scsi controller when we actually build the I/O.
The minimum of these two limits should be the one we use.
Signed-off-by: Eric Farman <farman@linux.vnet.ibm.com>
Message-Id: <20170510155359.32727-7-farman@linux.vnet.ibm.com>
Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com>
2017-05-10 17:53:57 +02:00
|
|
|
|
|
|
|
if (evpd->byte[i] != SCSI_INQUIRY_EVPD_BLOCK_LIMITS) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!scsi_inquiry(vdev,
|
|
|
|
SCSI_INQUIRY_EVPD,
|
|
|
|
SCSI_INQUIRY_EVPD_BLOCK_LIMITS,
|
|
|
|
evpd_bl,
|
|
|
|
sizeof(*evpd_bl))) {
|
|
|
|
virtio_scsi_verify_response(&resp, "virtio-scsi:setup:blocklimits");
|
|
|
|
}
|
|
|
|
|
|
|
|
debug_print_int("max transfer", evpd_bl->max_transfer);
|
|
|
|
vdev->max_transfer = evpd_bl->max_transfer;
|
2017-05-10 17:53:56 +02:00
|
|
|
}
|
|
|
|
|
2017-05-10 17:53:58 +02:00
|
|
|
/*
|
|
|
|
* The host sg driver will often be unhappy with particularly large
|
|
|
|
* I/Os that exceed the block iovec limits. Let's enforce something
|
|
|
|
* reasonable, despite what the device configuration tells us.
|
|
|
|
*/
|
|
|
|
|
|
|
|
vdev->max_transfer = MIN_NON_ZERO(VIRTIO_SCSI_MAX_SECTORS,
|
|
|
|
vdev->max_transfer);
|
|
|
|
|
2015-11-10 15:36:13 +01:00
|
|
|
if (!scsi_read_capacity(vdev, data, data_size)) {
|
|
|
|
virtio_scsi_verify_response(&resp, "virtio-scsi:setup:read_capacity");
|
|
|
|
}
|
|
|
|
scsi_parse_capacity_report(data, &vdev->scsi_last_block,
|
|
|
|
(uint32_t *) &vdev->scsi_block_size);
|
|
|
|
}
|