2007-09-16 23:08:06 +02:00
|
|
|
/*
|
2006-05-26 01:58:51 +02:00
|
|
|
* USB Mass Storage Device emulation
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 CodeSourcery.
|
|
|
|
* Written by Paul Brook
|
|
|
|
*
|
2011-06-26 04:21:35 +02:00
|
|
|
* This code is licensed under the LGPL.
|
2006-05-26 01:58:51 +02:00
|
|
|
*/
|
|
|
|
|
2007-11-17 18:14:51 +01:00
|
|
|
#include "qemu-common.h"
|
2009-08-31 14:24:05 +02:00
|
|
|
#include "qemu-option.h"
|
|
|
|
#include "qemu-config.h"
|
2012-03-07 14:55:18 +01:00
|
|
|
#include "hw/usb.h"
|
|
|
|
#include "hw/usb/desc.h"
|
|
|
|
#include "hw/scsi.h"
|
2009-03-06 00:01:01 +01:00
|
|
|
#include "console.h"
|
2009-10-26 15:56:49 +01:00
|
|
|
#include "monitor.h"
|
2010-06-02 18:48:27 +02:00
|
|
|
#include "sysemu.h"
|
2010-08-24 17:22:24 +02:00
|
|
|
#include "blockdev.h"
|
2006-05-26 01:58:51 +02:00
|
|
|
|
|
|
|
//#define DEBUG_MSD
|
|
|
|
|
|
|
|
#ifdef DEBUG_MSD
|
2009-05-13 19:53:17 +02:00
|
|
|
#define DPRINTF(fmt, ...) \
|
|
|
|
do { printf("usb-msd: " fmt , ## __VA_ARGS__); } while (0)
|
2006-05-26 01:58:51 +02:00
|
|
|
#else
|
2009-05-13 19:53:17 +02:00
|
|
|
#define DPRINTF(fmt, ...) do {} while(0)
|
2006-05-26 01:58:51 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* USB requests. */
|
|
|
|
#define MassStorageReset 0xff
|
|
|
|
#define GetMaxLun 0xfe
|
|
|
|
|
|
|
|
enum USBMSDMode {
|
|
|
|
USB_MSDM_CBW, /* Command Block. */
|
2011-04-13 11:45:31 +02:00
|
|
|
USB_MSDM_DATAOUT, /* Transfer data to device. */
|
2006-05-26 01:58:51 +02:00
|
|
|
USB_MSDM_DATAIN, /* Transfer data from device. */
|
|
|
|
USB_MSDM_CSW /* Command Status. */
|
|
|
|
};
|
|
|
|
|
2011-11-21 11:29:27 +01:00
|
|
|
struct usb_msd_csw {
|
|
|
|
uint32_t sig;
|
|
|
|
uint32_t tag;
|
|
|
|
uint32_t residue;
|
|
|
|
uint8_t status;
|
|
|
|
};
|
|
|
|
|
2006-05-26 01:58:51 +02:00
|
|
|
typedef struct {
|
|
|
|
USBDevice dev;
|
|
|
|
enum USBMSDMode mode;
|
2012-05-16 15:03:40 +02:00
|
|
|
uint32_t scsi_off;
|
2006-08-29 06:52:16 +02:00
|
|
|
uint32_t scsi_len;
|
2006-05-26 01:58:51 +02:00
|
|
|
uint32_t data_len;
|
2011-11-21 11:29:27 +01:00
|
|
|
struct usb_msd_csw csw;
|
2011-04-18 12:35:39 +02:00
|
|
|
SCSIRequest *req;
|
2009-09-16 22:25:28 +02:00
|
|
|
SCSIBus bus;
|
block: add topology qdev properties
Add three new qdev properties to export block topology information to
the guest. This is needed to get optimal I/O alignment for RAID arrays
or SSDs.
The options are:
- physical_block_size to specify the physical block size of the device,
this is going to increase from 512 bytes to 4096 kilobytes for many
modern storage devices
- min_io_size to specify the minimal I/O size without performance impact,
this is typically set to the RAID chunk size for arrays.
- opt_io_size to specify the optimal sustained I/O size, this is
typically the RAID stripe width for arrays.
I decided to not auto-probe these values from blkid which might easily
be possible as I don't know how to deal with these issues on migration.
Note that we specificly only set the physical_block_size, and not the
logial one which is the unit all I/O is described in. The reason for
that is that IDE does not support increasing the logical block size and
at last for now I want to stick to one meachnisms in queue and allow
for easy switching of transports for a given backing image which would
not be possible if scsi and virtio use real 4k sectors, while ide only
uses the physical block exponent.
To make this more common for the different block drivers introduce a
new BlockConf structure holding all common block properties and a
DEFINE_BLOCK_PROPERTIES macro to add them all together, mirroring
what is done for network drivers. Also switch over all block drivers
to use it, except for the floppy driver which has weird driveA/driveB
properties and probably won't require any advanced block options ever.
Example usage for a virtio device with 4k physical block size and
8k optimal I/O size:
-drive file=scratch.img,media=disk,cache=none,id=scratch \
-device virtio-blk-pci,drive=scratch,physical_block_size=4096,opt_io_size=8192
aliguori: updated patch to take into account BLOCK events
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-02-10 23:37:09 +01:00
|
|
|
BlockConf conf;
|
2011-06-17 10:52:36 +02:00
|
|
|
char *serial;
|
2006-05-26 01:58:51 +02:00
|
|
|
SCSIDevice *scsi_dev;
|
2011-01-24 16:35:00 +01:00
|
|
|
uint32_t removable;
|
2006-08-12 03:04:27 +02:00
|
|
|
/* For async completion. */
|
|
|
|
USBPacket *packet;
|
2006-05-26 01:58:51 +02:00
|
|
|
} MSDState;
|
|
|
|
|
2006-08-29 06:52:16 +02:00
|
|
|
struct usb_msd_cbw {
|
|
|
|
uint32_t sig;
|
|
|
|
uint32_t tag;
|
|
|
|
uint32_t data_len;
|
|
|
|
uint8_t flags;
|
|
|
|
uint8_t lun;
|
|
|
|
uint8_t cmd_len;
|
|
|
|
uint8_t cmd[16];
|
|
|
|
};
|
|
|
|
|
2010-11-17 11:05:41 +01:00
|
|
|
enum {
|
|
|
|
STR_MANUFACTURER = 1,
|
|
|
|
STR_PRODUCT,
|
|
|
|
STR_SERIALNUMBER,
|
2010-12-03 17:12:49 +01:00
|
|
|
STR_CONFIG_FULL,
|
|
|
|
STR_CONFIG_HIGH,
|
2006-05-26 01:58:51 +02:00
|
|
|
};
|
|
|
|
|
2010-11-17 11:05:41 +01:00
|
|
|
static const USBDescStrings desc_strings = {
|
2012-05-30 05:35:51 +02:00
|
|
|
[STR_MANUFACTURER] = "QEMU",
|
2010-11-17 11:05:41 +01:00
|
|
|
[STR_PRODUCT] = "QEMU USB HARDDRIVE",
|
|
|
|
[STR_SERIALNUMBER] = "1",
|
2010-12-03 17:12:49 +01:00
|
|
|
[STR_CONFIG_FULL] = "Full speed config (usb 1.1)",
|
|
|
|
[STR_CONFIG_HIGH] = "High speed config (usb 2.0)",
|
2010-11-17 11:05:41 +01:00
|
|
|
};
|
|
|
|
|
2010-12-03 17:12:49 +01:00
|
|
|
static const USBDescIface desc_iface_full = {
|
2010-11-17 11:05:41 +01:00
|
|
|
.bInterfaceNumber = 0,
|
|
|
|
.bNumEndpoints = 2,
|
|
|
|
.bInterfaceClass = USB_CLASS_MASS_STORAGE,
|
|
|
|
.bInterfaceSubClass = 0x06, /* SCSI */
|
|
|
|
.bInterfaceProtocol = 0x50, /* Bulk */
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x01,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 64,
|
|
|
|
},{
|
|
|
|
.bEndpointAddress = USB_DIR_OUT | 0x02,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 64,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-12-03 17:12:49 +01:00
|
|
|
static const USBDescDevice desc_device_full = {
|
|
|
|
.bcdUSB = 0x0200,
|
2010-11-17 11:05:41 +01:00
|
|
|
.bMaxPacketSize0 = 8,
|
|
|
|
.bNumConfigurations = 1,
|
|
|
|
.confs = (USBDescConfig[]) {
|
|
|
|
{
|
|
|
|
.bNumInterfaces = 1,
|
|
|
|
.bConfigurationValue = 1,
|
2010-12-03 17:12:49 +01:00
|
|
|
.iConfiguration = STR_CONFIG_FULL,
|
2010-11-17 11:05:41 +01:00
|
|
|
.bmAttributes = 0xc0,
|
2011-04-03 07:33:19 +02:00
|
|
|
.nif = 1,
|
2010-12-03 17:12:49 +01:00
|
|
|
.ifs = &desc_iface_full,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescIface desc_iface_high = {
|
|
|
|
.bInterfaceNumber = 0,
|
|
|
|
.bNumEndpoints = 2,
|
|
|
|
.bInterfaceClass = USB_CLASS_MASS_STORAGE,
|
|
|
|
.bInterfaceSubClass = 0x06, /* SCSI */
|
|
|
|
.bInterfaceProtocol = 0x50, /* Bulk */
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x01,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 512,
|
|
|
|
},{
|
|
|
|
.bEndpointAddress = USB_DIR_OUT | 0x02,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 512,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescDevice desc_device_high = {
|
|
|
|
.bcdUSB = 0x0200,
|
|
|
|
.bMaxPacketSize0 = 64,
|
|
|
|
.bNumConfigurations = 1,
|
|
|
|
.confs = (USBDescConfig[]) {
|
|
|
|
{
|
|
|
|
.bNumInterfaces = 1,
|
|
|
|
.bConfigurationValue = 1,
|
|
|
|
.iConfiguration = STR_CONFIG_HIGH,
|
|
|
|
.bmAttributes = 0xc0,
|
2011-04-03 07:33:19 +02:00
|
|
|
.nif = 1,
|
2010-12-03 17:12:49 +01:00
|
|
|
.ifs = &desc_iface_high,
|
2010-11-17 11:05:41 +01:00
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDesc desc = {
|
|
|
|
.id = {
|
2011-09-15 05:25:47 +02:00
|
|
|
.idVendor = 0x46f4, /* CRC16() of "QEMU" */
|
|
|
|
.idProduct = 0x0001,
|
2010-11-17 11:05:41 +01:00
|
|
|
.bcdDevice = 0,
|
|
|
|
.iManufacturer = STR_MANUFACTURER,
|
|
|
|
.iProduct = STR_PRODUCT,
|
|
|
|
.iSerialNumber = STR_SERIALNUMBER,
|
|
|
|
},
|
2010-12-03 17:12:49 +01:00
|
|
|
.full = &desc_device_full,
|
|
|
|
.high = &desc_device_high,
|
2010-11-17 11:05:41 +01:00
|
|
|
.str = desc_strings,
|
2006-05-26 01:58:51 +02:00
|
|
|
};
|
|
|
|
|
2011-07-13 12:32:06 +02:00
|
|
|
static void usb_msd_copy_data(MSDState *s, USBPacket *p)
|
2006-08-29 06:52:16 +02:00
|
|
|
{
|
|
|
|
uint32_t len;
|
2011-07-13 12:32:06 +02:00
|
|
|
len = p->iov.size - p->result;
|
2006-08-29 06:52:16 +02:00
|
|
|
if (len > s->scsi_len)
|
|
|
|
len = s->scsi_len;
|
2012-05-16 15:03:40 +02:00
|
|
|
usb_packet_copy(p, scsi_req_get_buf(s->req) + s->scsi_off, len);
|
2006-08-29 06:52:16 +02:00
|
|
|
s->scsi_len -= len;
|
2012-05-16 15:03:40 +02:00
|
|
|
s->scsi_off += len;
|
2006-08-29 06:52:16 +02:00
|
|
|
s->data_len -= len;
|
2010-12-09 23:31:49 +01:00
|
|
|
if (s->scsi_len == 0 || s->data_len == 0) {
|
2011-04-18 15:28:11 +02:00
|
|
|
scsi_req_continue(s->req);
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-09 10:36:35 +01:00
|
|
|
static void usb_msd_send_status(MSDState *s, USBPacket *p)
|
2006-08-29 06:52:16 +02:00
|
|
|
{
|
2010-12-09 10:36:35 +01:00
|
|
|
int len;
|
2006-08-29 06:52:16 +02:00
|
|
|
|
2011-11-21 11:17:59 +01:00
|
|
|
DPRINTF("Command status %d tag 0x%x, len %zd\n",
|
2012-03-08 01:41:10 +01:00
|
|
|
s->csw.status, le32_to_cpu(s->csw.tag), p->iov.size);
|
2011-11-21 11:29:27 +01:00
|
|
|
|
2012-03-08 01:41:10 +01:00
|
|
|
assert(s->csw.sig == cpu_to_le32(0x53425355));
|
2011-11-21 11:29:27 +01:00
|
|
|
len = MIN(sizeof(s->csw), p->iov.size);
|
|
|
|
usb_packet_copy(p, &s->csw, len);
|
|
|
|
memset(&s->csw, 0, sizeof(s->csw));
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
|
|
|
|
2012-05-22 14:30:20 +02:00
|
|
|
static void usb_msd_packet_complete(MSDState *s)
|
|
|
|
{
|
|
|
|
USBPacket *p = s->packet;
|
|
|
|
|
|
|
|
/* Set s->packet to NULL before calling usb_packet_complete
|
|
|
|
because another request may be issued before
|
|
|
|
usb_packet_complete returns. */
|
|
|
|
DPRINTF("Packet complete %p\n", p);
|
|
|
|
s->packet = NULL;
|
|
|
|
usb_packet_complete(&s->dev, p);
|
|
|
|
}
|
|
|
|
|
2011-05-20 20:18:07 +02:00
|
|
|
static void usb_msd_transfer_data(SCSIRequest *req, uint32_t len)
|
2006-05-26 01:58:51 +02:00
|
|
|
{
|
2011-04-18 12:35:39 +02:00
|
|
|
MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
|
2006-08-29 06:52:16 +02:00
|
|
|
USBPacket *p = s->packet;
|
2006-08-12 03:04:27 +02:00
|
|
|
|
2011-04-18 15:28:11 +02:00
|
|
|
assert((s->mode == USB_MSDM_DATAOUT) == (req->cmd.mode == SCSI_XFER_TO_DEV));
|
2011-05-20 20:18:07 +02:00
|
|
|
s->scsi_len = len;
|
2012-05-16 15:03:40 +02:00
|
|
|
s->scsi_off = 0;
|
2006-08-29 06:52:16 +02:00
|
|
|
if (p) {
|
2011-07-13 12:32:06 +02:00
|
|
|
usb_msd_copy_data(s, p);
|
|
|
|
p = s->packet;
|
|
|
|
if (p && p->result == p->iov.size) {
|
2012-05-22 14:30:20 +02:00
|
|
|
usb_msd_packet_complete(s);
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
2006-08-12 03:04:27 +02:00
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
}
|
|
|
|
|
2011-07-06 11:55:37 +02:00
|
|
|
static void usb_msd_command_complete(SCSIRequest *req, uint32_t status, size_t resid)
|
2011-04-22 12:27:30 +02:00
|
|
|
{
|
|
|
|
MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
|
|
|
|
USBPacket *p = s->packet;
|
|
|
|
|
2011-11-21 11:36:17 +01:00
|
|
|
DPRINTF("Command complete %d tag 0x%x\n", status, req->tag);
|
2011-11-21 11:29:27 +01:00
|
|
|
|
|
|
|
s->csw.sig = cpu_to_le32(0x53425355);
|
2011-11-21 11:36:17 +01:00
|
|
|
s->csw.tag = cpu_to_le32(req->tag);
|
2012-05-14 14:00:02 +02:00
|
|
|
s->csw.residue = cpu_to_le32(s->data_len);
|
2011-11-21 11:41:30 +01:00
|
|
|
s->csw.status = status != 0;
|
2011-11-21 11:29:27 +01:00
|
|
|
|
2011-04-22 12:27:30 +02:00
|
|
|
if (s->packet) {
|
|
|
|
if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) {
|
|
|
|
/* A deferred packet with no write data remaining must be
|
|
|
|
the status read packet. */
|
|
|
|
usb_msd_send_status(s, p);
|
|
|
|
s->mode = USB_MSDM_CBW;
|
|
|
|
} else {
|
|
|
|
if (s->data_len) {
|
2011-07-13 12:32:06 +02:00
|
|
|
int len = (p->iov.size - p->result);
|
|
|
|
usb_packet_skip(p, len);
|
|
|
|
s->data_len -= len;
|
2011-04-22 12:27:30 +02:00
|
|
|
}
|
|
|
|
if (s->data_len == 0) {
|
|
|
|
s->mode = USB_MSDM_CSW;
|
|
|
|
}
|
|
|
|
}
|
2012-05-22 14:30:20 +02:00
|
|
|
usb_msd_packet_complete(s);
|
2011-04-22 12:27:30 +02:00
|
|
|
} else if (s->data_len == 0) {
|
|
|
|
s->mode = USB_MSDM_CSW;
|
|
|
|
}
|
|
|
|
scsi_req_unref(req);
|
|
|
|
s->req = NULL;
|
|
|
|
}
|
|
|
|
|
2011-04-18 22:53:08 +02:00
|
|
|
static void usb_msd_request_cancelled(SCSIRequest *req)
|
|
|
|
{
|
|
|
|
MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
|
|
|
|
|
|
|
|
if (req == s->req) {
|
|
|
|
scsi_req_unref(s->req);
|
|
|
|
s->req = NULL;
|
|
|
|
s->scsi_len = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-19 20:06:15 +02:00
|
|
|
static void usb_msd_handle_reset(USBDevice *dev)
|
2006-05-26 01:58:51 +02:00
|
|
|
{
|
|
|
|
MSDState *s = (MSDState *)dev;
|
|
|
|
|
|
|
|
DPRINTF("Reset\n");
|
2012-01-04 18:13:54 +01:00
|
|
|
if (s->req) {
|
|
|
|
scsi_req_cancel(s->req);
|
|
|
|
}
|
|
|
|
assert(s->req == NULL);
|
|
|
|
|
|
|
|
if (s->packet) {
|
2012-05-22 14:30:20 +02:00
|
|
|
s->packet->result = USB_RET_STALL;
|
|
|
|
usb_msd_packet_complete(s);
|
2012-01-04 18:13:54 +01:00
|
|
|
}
|
|
|
|
|
2006-05-26 01:58:51 +02:00
|
|
|
s->mode = USB_MSDM_CBW;
|
|
|
|
}
|
|
|
|
|
2011-02-02 16:33:13 +01:00
|
|
|
static int usb_msd_handle_control(USBDevice *dev, USBPacket *p,
|
|
|
|
int request, int value, int index, int length, uint8_t *data)
|
2006-05-26 01:58:51 +02:00
|
|
|
{
|
|
|
|
MSDState *s = (MSDState *)dev;
|
2010-11-17 11:05:41 +01:00
|
|
|
int ret;
|
2006-05-26 01:58:51 +02:00
|
|
|
|
2011-02-02 16:33:13 +01:00
|
|
|
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
2010-11-17 11:05:41 +01:00
|
|
|
if (ret >= 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
2006-05-26 01:58:51 +02:00
|
|
|
switch (request) {
|
|
|
|
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
|
2010-03-10 10:45:12 +01:00
|
|
|
ret = 0;
|
|
|
|
break;
|
2006-05-26 01:58:51 +02:00
|
|
|
/* Class specific requests. */
|
2010-03-14 12:19:03 +01:00
|
|
|
case ClassInterfaceOutRequest | MassStorageReset:
|
2006-05-26 01:58:51 +02:00
|
|
|
/* Reset state ready for the next CBW. */
|
|
|
|
s->mode = USB_MSDM_CBW;
|
|
|
|
ret = 0;
|
|
|
|
break;
|
2010-03-14 12:19:03 +01:00
|
|
|
case ClassInterfaceRequest | GetMaxLun:
|
2006-05-26 01:58:51 +02:00
|
|
|
data[0] = 0;
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = USB_RET_STALL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-05-16 10:34:53 +02:00
|
|
|
static void usb_msd_cancel_io(USBDevice *dev, USBPacket *p)
|
2006-08-12 03:04:27 +02:00
|
|
|
{
|
2011-05-16 10:34:53 +02:00
|
|
|
MSDState *s = DO_UPCAST(MSDState, dev, dev);
|
2011-09-02 13:05:13 +02:00
|
|
|
|
2012-04-18 12:08:29 +02:00
|
|
|
assert(s->packet == p);
|
|
|
|
s->packet = NULL;
|
|
|
|
|
2011-09-02 13:05:13 +02:00
|
|
|
if (s->req) {
|
|
|
|
scsi_req_cancel(s->req);
|
|
|
|
}
|
2006-08-12 03:04:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int usb_msd_handle_data(USBDevice *dev, USBPacket *p)
|
2006-05-26 01:58:51 +02:00
|
|
|
{
|
|
|
|
MSDState *s = (MSDState *)dev;
|
2011-11-21 11:36:17 +01:00
|
|
|
uint32_t tag;
|
2006-05-26 01:58:51 +02:00
|
|
|
int ret = 0;
|
|
|
|
struct usb_msd_cbw cbw;
|
2012-01-12 13:23:01 +01:00
|
|
|
uint8_t devep = p->ep->nr;
|
2006-05-26 01:58:51 +02:00
|
|
|
|
2006-08-12 03:04:27 +02:00
|
|
|
switch (p->pid) {
|
2006-05-26 01:58:51 +02:00
|
|
|
case USB_TOKEN_OUT:
|
|
|
|
if (devep != 2)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
switch (s->mode) {
|
|
|
|
case USB_MSDM_CBW:
|
2011-07-13 12:32:06 +02:00
|
|
|
if (p->iov.size != 31) {
|
2006-05-26 01:58:51 +02:00
|
|
|
fprintf(stderr, "usb-msd: Bad CBW size");
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-07-13 12:32:06 +02:00
|
|
|
usb_packet_copy(p, &cbw, 31);
|
2006-05-26 01:58:51 +02:00
|
|
|
if (le32_to_cpu(cbw.sig) != 0x43425355) {
|
|
|
|
fprintf(stderr, "usb-msd: Bad signature %08x\n",
|
|
|
|
le32_to_cpu(cbw.sig));
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
DPRINTF("Command on LUN %d\n", cbw.lun);
|
|
|
|
if (cbw.lun != 0) {
|
|
|
|
fprintf(stderr, "usb-msd: Bad LUN %d\n", cbw.lun);
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-11-21 11:36:17 +01:00
|
|
|
tag = le32_to_cpu(cbw.tag);
|
2006-05-26 01:58:51 +02:00
|
|
|
s->data_len = le32_to_cpu(cbw.data_len);
|
|
|
|
if (s->data_len == 0) {
|
|
|
|
s->mode = USB_MSDM_CSW;
|
|
|
|
} else if (cbw.flags & 0x80) {
|
|
|
|
s->mode = USB_MSDM_DATAIN;
|
|
|
|
} else {
|
|
|
|
s->mode = USB_MSDM_DATAOUT;
|
|
|
|
}
|
|
|
|
DPRINTF("Command tag 0x%x flags %08x len %d data %d\n",
|
2011-11-21 11:36:17 +01:00
|
|
|
tag, cbw.flags, cbw.cmd_len, s->data_len);
|
2012-05-14 14:00:02 +02:00
|
|
|
assert(le32_to_cpu(s->csw.residue) == 0);
|
2011-05-04 16:49:56 +02:00
|
|
|
s->scsi_len = 0;
|
2011-11-21 11:36:17 +01:00
|
|
|
s->req = scsi_req_new(s->scsi_dev, tag, 0, cbw.cmd, NULL);
|
2012-07-13 11:35:51 +02:00
|
|
|
#ifdef DEBUG_MSD
|
|
|
|
scsi_req_print(s->req);
|
|
|
|
#endif
|
2011-08-03 10:49:10 +02:00
|
|
|
scsi_req_enqueue(s->req);
|
2011-11-21 14:01:26 +01:00
|
|
|
if (s->req && s->req->cmd.xfer != SCSI_XFER_NONE) {
|
2011-04-18 15:28:11 +02:00
|
|
|
scsi_req_continue(s->req);
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
2011-07-13 12:32:06 +02:00
|
|
|
ret = p->result;
|
2006-05-26 01:58:51 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_MSDM_DATAOUT:
|
2011-07-13 12:32:06 +02:00
|
|
|
DPRINTF("Data out %zd/%d\n", p->iov.size, s->data_len);
|
|
|
|
if (p->iov.size > s->data_len) {
|
2006-05-26 01:58:51 +02:00
|
|
|
goto fail;
|
2011-07-13 12:32:06 +02:00
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
|
2006-08-29 06:52:16 +02:00
|
|
|
if (s->scsi_len) {
|
2011-07-13 12:32:06 +02:00
|
|
|
usb_msd_copy_data(s, p);
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
2012-05-14 14:00:02 +02:00
|
|
|
if (le32_to_cpu(s->csw.residue)) {
|
2011-07-13 12:32:06 +02:00
|
|
|
int len = p->iov.size - p->result;
|
|
|
|
if (len) {
|
|
|
|
usb_packet_skip(p, len);
|
|
|
|
s->data_len -= len;
|
|
|
|
if (s->data_len == 0) {
|
|
|
|
s->mode = USB_MSDM_CSW;
|
|
|
|
}
|
|
|
|
}
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
2011-07-13 12:32:06 +02:00
|
|
|
if (p->result < p->iov.size) {
|
2012-07-13 11:35:51 +02:00
|
|
|
DPRINTF("Deferring packet %p [wait data-out]\n", p);
|
2006-08-12 03:04:27 +02:00
|
|
|
s->packet = p;
|
|
|
|
ret = USB_RET_ASYNC;
|
2006-08-29 06:52:16 +02:00
|
|
|
} else {
|
2011-07-13 12:32:06 +02:00
|
|
|
ret = p->result;
|
2006-08-12 03:04:27 +02:00
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2011-07-13 12:32:06 +02:00
|
|
|
DPRINTF("Unexpected write (len %zd)\n", p->iov.size);
|
2006-05-26 01:58:51 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_TOKEN_IN:
|
|
|
|
if (devep != 1)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
switch (s->mode) {
|
2006-08-29 06:52:16 +02:00
|
|
|
case USB_MSDM_DATAOUT:
|
2011-07-13 12:32:06 +02:00
|
|
|
if (s->data_len != 0 || p->iov.size < 13) {
|
2006-08-29 06:52:16 +02:00
|
|
|
goto fail;
|
2011-07-13 12:32:06 +02:00
|
|
|
}
|
2006-08-29 06:52:16 +02:00
|
|
|
/* Waiting for SCSI write to complete. */
|
|
|
|
s->packet = p;
|
|
|
|
ret = USB_RET_ASYNC;
|
|
|
|
break;
|
|
|
|
|
2006-05-26 01:58:51 +02:00
|
|
|
case USB_MSDM_CSW:
|
2011-07-13 12:32:06 +02:00
|
|
|
if (p->iov.size < 13) {
|
2006-05-26 01:58:51 +02:00
|
|
|
goto fail;
|
2011-07-13 12:32:06 +02:00
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
|
2011-11-21 14:01:26 +01:00
|
|
|
if (s->req) {
|
|
|
|
/* still in flight */
|
2012-07-13 11:35:51 +02:00
|
|
|
DPRINTF("Deferring packet %p [wait status]\n", p);
|
2011-11-21 14:01:26 +01:00
|
|
|
s->packet = p;
|
|
|
|
ret = USB_RET_ASYNC;
|
|
|
|
} else {
|
|
|
|
usb_msd_send_status(s, p);
|
|
|
|
s->mode = USB_MSDM_CBW;
|
|
|
|
ret = 13;
|
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_MSDM_DATAIN:
|
2011-07-13 12:32:06 +02:00
|
|
|
DPRINTF("Data in %zd/%d, scsi_len %d\n",
|
|
|
|
p->iov.size, s->data_len, s->scsi_len);
|
2006-08-29 06:52:16 +02:00
|
|
|
if (s->scsi_len) {
|
2011-07-13 12:32:06 +02:00
|
|
|
usb_msd_copy_data(s, p);
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
2012-05-14 14:00:02 +02:00
|
|
|
if (le32_to_cpu(s->csw.residue)) {
|
2011-07-13 12:32:06 +02:00
|
|
|
int len = p->iov.size - p->result;
|
|
|
|
if (len) {
|
|
|
|
usb_packet_skip(p, len);
|
|
|
|
s->data_len -= len;
|
|
|
|
if (s->data_len == 0) {
|
|
|
|
s->mode = USB_MSDM_CSW;
|
|
|
|
}
|
|
|
|
}
|
2006-08-29 06:52:16 +02:00
|
|
|
}
|
2011-07-13 12:32:06 +02:00
|
|
|
if (p->result < p->iov.size) {
|
2012-07-13 11:35:51 +02:00
|
|
|
DPRINTF("Deferring packet %p [wait data-in]\n", p);
|
2006-08-12 03:04:27 +02:00
|
|
|
s->packet = p;
|
|
|
|
ret = USB_RET_ASYNC;
|
2006-08-29 06:52:16 +02:00
|
|
|
} else {
|
2011-07-13 12:32:06 +02:00
|
|
|
ret = p->result;
|
2006-08-12 03:04:27 +02:00
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2011-07-13 12:32:06 +02:00
|
|
|
DPRINTF("Unexpected read (len %zd)\n", p->iov.size);
|
2006-05-26 01:58:51 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
DPRINTF("Bad token\n");
|
|
|
|
fail:
|
|
|
|
ret = USB_RET_STALL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-10-26 15:56:49 +01:00
|
|
|
static void usb_msd_password_cb(void *opaque, int err)
|
|
|
|
{
|
|
|
|
MSDState *s = opaque;
|
|
|
|
|
|
|
|
if (!err)
|
2011-05-27 19:05:15 +02:00
|
|
|
err = usb_device_attach(&s->dev);
|
|
|
|
|
|
|
|
if (err)
|
2012-03-14 21:37:38 +01:00
|
|
|
qdev_unplug(&s->dev.qdev, NULL);
|
2009-10-26 15:56:49 +01:00
|
|
|
}
|
|
|
|
|
2012-05-14 13:56:40 +02:00
|
|
|
static void *usb_msd_load_request(QEMUFile *f, SCSIRequest *req)
|
|
|
|
{
|
|
|
|
MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
|
|
|
|
|
|
|
|
/* nothing to load, just store req in our state struct */
|
|
|
|
assert(s->req == NULL);
|
|
|
|
scsi_req_ref(req);
|
|
|
|
s->req = req;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-08-13 15:44:45 +02:00
|
|
|
static const struct SCSIBusInfo usb_msd_scsi_info = {
|
|
|
|
.tcq = false,
|
2011-08-13 18:55:17 +02:00
|
|
|
.max_target = 0,
|
|
|
|
.max_lun = 0,
|
2011-08-13 15:44:45 +02:00
|
|
|
|
2011-04-22 12:27:30 +02:00
|
|
|
.transfer_data = usb_msd_transfer_data,
|
2011-04-18 22:53:08 +02:00
|
|
|
.complete = usb_msd_command_complete,
|
2012-05-14 13:56:40 +02:00
|
|
|
.cancel = usb_msd_request_cancelled,
|
|
|
|
.load_request = usb_msd_load_request,
|
2011-04-18 17:11:14 +02:00
|
|
|
};
|
|
|
|
|
2009-08-31 14:23:59 +02:00
|
|
|
static int usb_msd_initfn(USBDevice *dev)
|
|
|
|
{
|
|
|
|
MSDState *s = DO_UPCAST(MSDState, dev, dev);
|
2010-05-05 16:36:52 +02:00
|
|
|
BlockDriverState *bs = s->conf.bs;
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2010-05-05 16:36:52 +02:00
|
|
|
if (!bs) {
|
2011-12-21 11:37:57 +01:00
|
|
|
error_report("drive property not set");
|
2009-08-31 14:24:05 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-07-11 15:08:37 +02:00
|
|
|
blkconf_serial(&s->conf, &s->serial);
|
|
|
|
|
2010-06-25 08:09:10 +02:00
|
|
|
/*
|
|
|
|
* Hack alert: this pretends to be a block device, but it's really
|
|
|
|
* a SCSI bus that can serve only a single device, which it
|
2010-06-29 16:58:30 +02:00
|
|
|
* creates automatically. But first it needs to detach from its
|
|
|
|
* blockdev, or else scsi_bus_legacy_add_drive() dies when it
|
|
|
|
* attaches again.
|
2010-06-25 08:09:10 +02:00
|
|
|
*
|
|
|
|
* The hack is probably a bad idea.
|
|
|
|
*/
|
2011-08-03 15:07:40 +02:00
|
|
|
bdrv_detach_dev(bs, &s->dev.qdev);
|
2010-05-05 16:36:52 +02:00
|
|
|
s->conf.bs = NULL;
|
2010-06-25 08:09:10 +02:00
|
|
|
|
2011-06-17 10:52:36 +02:00
|
|
|
if (s->serial) {
|
|
|
|
usb_desc_set_string(dev, STR_SERIALNUMBER, s->serial);
|
2012-04-20 12:33:30 +02:00
|
|
|
} else {
|
|
|
|
usb_desc_create_serial(dev);
|
2010-11-26 12:26:17 +01:00
|
|
|
}
|
|
|
|
|
2010-11-26 20:20:41 +01:00
|
|
|
usb_desc_init(dev);
|
2011-08-13 15:44:45 +02:00
|
|
|
scsi_bus_new(&s->bus, &s->dev.qdev, &usb_msd_scsi_info);
|
2011-11-18 16:32:00 +01:00
|
|
|
s->scsi_dev = scsi_bus_legacy_add_drive(&s->bus, bs, 0, !!s->removable,
|
|
|
|
s->conf.bootindex);
|
2010-06-25 18:53:21 +02:00
|
|
|
if (!s->scsi_dev) {
|
|
|
|
return -1;
|
|
|
|
}
|
2009-09-25 21:42:43 +02:00
|
|
|
s->bus.qbus.allow_hotplug = 0;
|
2009-08-31 14:24:05 +02:00
|
|
|
usb_msd_handle_reset(dev);
|
2009-10-26 15:56:49 +01:00
|
|
|
|
2010-05-05 16:36:52 +02:00
|
|
|
if (bdrv_key_required(bs)) {
|
2010-02-18 11:49:42 +01:00
|
|
|
if (cur_mon) {
|
2010-05-05 16:36:52 +02:00
|
|
|
monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb, s);
|
2009-10-26 15:56:49 +01:00
|
|
|
s->dev.auto_attach = 0;
|
|
|
|
} else {
|
|
|
|
autostart = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-31 14:23:59 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-27 15:18:47 +01:00
|
|
|
static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
|
2006-05-26 01:58:51 +02:00
|
|
|
{
|
2009-08-31 14:24:05 +02:00
|
|
|
static int nr=0;
|
|
|
|
char id[8];
|
|
|
|
QemuOpts *opts;
|
|
|
|
DriveInfo *dinfo;
|
2009-08-31 14:23:59 +02:00
|
|
|
USBDevice *dev;
|
2008-08-22 00:24:32 +02:00
|
|
|
const char *p1;
|
|
|
|
char fmt[32];
|
|
|
|
|
2009-08-31 14:24:05 +02:00
|
|
|
/* parse -usbdevice disk: syntax into drive opts */
|
|
|
|
snprintf(id, sizeof(id), "usb%d", nr++);
|
2012-03-20 19:51:57 +01:00
|
|
|
opts = qemu_opts_create(qemu_find_opts("drive"), id, 0, NULL);
|
2009-08-31 14:24:05 +02:00
|
|
|
|
2008-08-22 00:24:32 +02:00
|
|
|
p1 = strchr(filename, ':');
|
|
|
|
if (p1++) {
|
|
|
|
const char *p2;
|
|
|
|
|
|
|
|
if (strstart(filename, "format=", &p2)) {
|
|
|
|
int len = MIN(p1 - p2, sizeof(fmt));
|
|
|
|
pstrcpy(fmt, len, p2);
|
2009-08-31 14:24:05 +02:00
|
|
|
qemu_opt_set(opts, "format", fmt);
|
2008-08-22 00:24:32 +02:00
|
|
|
} else if (*filename != ':') {
|
|
|
|
printf("unrecognized USB mass-storage option %s\n", filename);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
filename = p1;
|
|
|
|
}
|
|
|
|
if (!*filename) {
|
|
|
|
printf("block device specification needed\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-08-31 14:24:05 +02:00
|
|
|
qemu_opt_set(opts, "file", filename);
|
|
|
|
qemu_opt_set(opts, "if", "none");
|
2006-05-26 01:58:51 +02:00
|
|
|
|
2009-08-31 14:24:05 +02:00
|
|
|
/* create host drive */
|
2011-01-28 11:21:46 +01:00
|
|
|
dinfo = drive_init(opts, 0);
|
2009-08-31 14:24:05 +02:00
|
|
|
if (!dinfo) {
|
|
|
|
qemu_opts_del(opts);
|
2009-08-31 14:23:59 +02:00
|
|
|
return NULL;
|
2009-08-31 14:24:05 +02:00
|
|
|
}
|
2006-05-26 01:58:51 +02:00
|
|
|
|
2009-08-31 14:24:05 +02:00
|
|
|
/* create guest device */
|
2012-02-27 15:18:47 +01:00
|
|
|
dev = usb_create(bus, "usb-storage");
|
2010-02-25 14:29:06 +01:00
|
|
|
if (!dev) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-06-29 16:58:30 +02:00
|
|
|
if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) {
|
|
|
|
qdev_free(&dev->qdev);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-10-07 01:15:57 +02:00
|
|
|
if (qdev_init(&dev->qdev) < 0)
|
|
|
|
return NULL;
|
2006-06-26 23:00:51 +02:00
|
|
|
|
2009-08-31 14:24:05 +02:00
|
|
|
return dev;
|
2006-05-26 01:58:51 +02:00
|
|
|
}
|
2009-03-06 00:01:15 +01:00
|
|
|
|
2010-12-10 14:58:41 +01:00
|
|
|
static const VMStateDescription vmstate_usb_msd = {
|
|
|
|
.name = "usb-storage",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.fields = (VMStateField []) {
|
|
|
|
VMSTATE_USB_DEVICE(dev, MSDState),
|
2012-05-14 13:56:40 +02:00
|
|
|
VMSTATE_UINT32(mode, MSDState),
|
|
|
|
VMSTATE_UINT32(scsi_len, MSDState),
|
|
|
|
VMSTATE_UINT32(scsi_off, MSDState),
|
|
|
|
VMSTATE_UINT32(data_len, MSDState),
|
|
|
|
VMSTATE_UINT32(csw.sig, MSDState),
|
|
|
|
VMSTATE_UINT32(csw.tag, MSDState),
|
|
|
|
VMSTATE_UINT32(csw.residue, MSDState),
|
|
|
|
VMSTATE_UINT8(csw.status, MSDState),
|
2010-12-10 14:58:41 +01:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static Property msd_properties[] = {
|
|
|
|
DEFINE_BLOCK_PROPERTIES(MSDState, conf),
|
|
|
|
DEFINE_PROP_STRING("serial", MSDState, serial),
|
|
|
|
DEFINE_PROP_BIT("removable", MSDState, removable, 0, false),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2011-12-15 21:53:10 +01:00
|
|
|
static void usb_msd_class_initfn(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
uc->init = usb_msd_initfn;
|
|
|
|
uc->product_desc = "QEMU USB MSD";
|
|
|
|
uc->usb_desc = &desc;
|
|
|
|
uc->cancel_packet = usb_msd_cancel_io;
|
|
|
|
uc->handle_attach = usb_desc_attach;
|
|
|
|
uc->handle_reset = usb_msd_handle_reset;
|
|
|
|
uc->handle_control = usb_msd_handle_control;
|
|
|
|
uc->handle_data = usb_msd_handle_data;
|
2011-12-08 04:34:16 +01:00
|
|
|
dc->fw_name = "storage";
|
|
|
|
dc->vmsd = &vmstate_usb_msd;
|
|
|
|
dc->props = msd_properties;
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static TypeInfo msd_info = {
|
|
|
|
.name = "usb-storage",
|
|
|
|
.parent = TYPE_USB_DEVICE,
|
|
|
|
.instance_size = sizeof(MSDState),
|
|
|
|
.class_init = usb_msd_class_initfn,
|
2009-08-31 14:23:59 +02:00
|
|
|
};
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
static void usb_msd_register_types(void)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
type_register_static(&msd_info);
|
2011-12-08 21:56:53 +01:00
|
|
|
usb_legacy_register("usb-storage", "disk", usb_msd_init);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
2012-02-09 15:20:55 +01:00
|
|
|
|
|
|
|
type_init(usb_msd_register_types)
|