On Sun, Jul 15, 2012 at 7:55 AM, Deep Debroy <ddeb...@gmail.com> wrote:
> On Thu, Jul 12, 2012 at 6:08 AM, Gerd Hoffmann <kra...@redhat.com> wrote:
>> $subject says all. First cut.
>>
>> It's a pure UAS (usb attached scsi) emulation, without BOT (bulk-only
>> transport) compatibility. If your guest can't handle it use usb-storage
>> instead.
>>
>> The emulation works like any other scsi hba emulation (eps, lsi, virtio,
>> megasas, ...). It provides just the HBA where you can attach scsi
>> devices as you like using '-device'. A single scsi target with up to
>> 256 luns is supported.
>>
>> For now only usb 2.0 transport is supported. This will change in the
>> future though as I plan to use this as playground when codeing up &
>> testing usb 3.0 transport and streams support in the qemu usb core and
>> the xhci emulation.
>>
>> No migration support yet. I'm planning to add usb 3.0 support first as
>> this probably requires saving additional state.
>>
>> Special thanks go to Paolo for bringing the qemu scsi emulation into
>> shape, so this can be added nicely without having to touch a single line
>> of scsi code.
>>
>> Signed-off-by: Gerd Hoffmann <kra...@redhat.com>
>> ---
>> docs/usb-storage.txt | 38 +++
>> hw/usb/Makefile.objs | 1 +
>> hw/usb/dev-uas.c | 779
>> ++++++++++++++++++++++++++++++++++++++++++++++++++
>> trace-events | 14 +
>> 4 files changed, 832 insertions(+), 0 deletions(-)
>> create mode 100644 docs/usb-storage.txt
>> create mode 100644 hw/usb/dev-uas.c
>>
>> diff --git a/docs/usb-storage.txt b/docs/usb-storage.txt
>> new file mode 100644
>> index 0000000..ff97559
>> --- /dev/null
>> +++ b/docs/usb-storage.txt
>> @@ -0,0 +1,38 @@
>> +
>> +qemu usb storage emulation
>> +--------------------------
>> +
>> +Qemu has two emulations for usb storage devices.
>> +
>> +Number one emulates the classic bulk-only transport protocol which is
>> +used by 99% of the usb sticks on the marked today and is called
>> +"usb-storage". Usage (hooking up to xhci, other host controllers work
>> +too):
>> +
>> + qemu ${other_vm_args} \
>> + -drive if=none,id=stick,file=/path/to/file.img \
>> + -device nec-usb-xhci,id=xhci \
>> + -device usb-storage,bus=xhci.0,drive=stick
>> +
>> +
>> +Number two is the newer usb attached scsi transport. This one doesn't
>> +automagically create a scsi disk, so you have to explicitly attach one
>> +manually. Multiple logical units are supported. Here is an example
>> +with tree logical units:
>> +
>> + qemu ${other_vm_args} \
>> + -drive if=none,id=uas-disk1,file=/path/to/file1.img \
>> + -drive if=none,id=uas-disk2,file=/path/to/file2.img \
>> + -drive if=none,id=uas-cdrom,media=cdrom,file=/path/to/image.iso \
>> + -device nec-usb-xhci,id=xhci \
>> + -device usb-uas,id=uas,bus=xhci.0 \
>> + -device scsi-hd,bus=uas.0,scsi-id=0,lun=0,drive=uas-disk1 \
>> + -device scsi-hd,bus=uas.0,scsi-id=0,lun=1,drive=uas-disk2 \
>> + -device scsi-cd,bus=uas.0,scsi-id=0,lun=5,drive=uas-cdrom
>> +
>> +
>> +enjoy,
>> + Gerd
>> +
>> +--
>> +Gerd Hoffmann <kra...@redhat.com>
>> diff --git a/hw/usb/Makefile.objs b/hw/usb/Makefile.objs
>> index 9c7ddf5..4225136 100644
>> --- a/hw/usb/Makefile.objs
>> +++ b/hw/usb/Makefile.objs
>> @@ -11,3 +11,4 @@ common-obj-y += core.o bus.o desc.o dev-hub.o
>> common-obj-y += host-$(HOST_USB).o dev-bluetooth.o
>> common-obj-y += dev-hid.o dev-storage.o dev-wacom.o
>> common-obj-y += dev-serial.o dev-network.o dev-audio.o
>> +common-obj-y += dev-uas.o
>> diff --git a/hw/usb/dev-uas.c b/hw/usb/dev-uas.c
>> new file mode 100644
>> index 0000000..9b02ff4
>> --- /dev/null
>> +++ b/hw/usb/dev-uas.c
>> @@ -0,0 +1,779 @@
>> +/*
>> + * UAS (USB Attached SCSI) emulation
>> + *
>> + * Copyright Red Hat, Inc. 2012
>> + *
>> + * Author: Gerd Hoffmann <kra...@redhat.com>
>> + *
>> + * This work is licensed under the terms of the GNU GPL, version 2 or later.
>> + * See the COPYING file in the top-level directory.
>> + */
>> +
>> +#include "qemu-common.h"
>> +#include "qemu-option.h"
>> +#include "qemu-config.h"
>> +#include "trace.h"
>> +
>> +#include "hw/usb.h"
>> +#include "hw/usb/desc.h"
>> +#include "hw/scsi.h"
>> +#include "hw/scsi-defs.h"
>> +
>> +/* --------------------------------------------------------------------- */
>> +
>> +#define UAS_UI_COMMAND 0x01
>> +#define UAS_UI_SENSE 0x03
>> +#define UAS_UI_RESPONSE 0x04
>> +#define UAS_UI_TASK_MGMT 0x05
>> +#define UAS_UI_READ_READY 0x06
>> +#define UAS_UI_WRITE_READY 0x07
>> +
>> +#define UAS_RC_TMF_COMPLETE 0x00
>> +#define UAS_RC_INVALID_INFO_UNIT 0x02
>> +#define UAS_RC_TMF_NOT_SUPPORTED 0x04
>> +#define UAS_RC_TMF_FAILED 0x05
>> +#define UAS_RC_TMF_SUCCEEDED 0x08
>> +#define UAS_RC_INCORRECT_LUN 0x09
>> +#define UAS_RC_OVERLAPPED_TAG 0x0a
>> +
>> +#define UAS_TMF_ABORT_TASK 0x01
>> +#define UAS_TMF_ABORT_TASK_SET 0x02
>> +#define UAS_TMF_CLEAR_TASK_SET 0x04
>> +#define UAS_TMF_LOGICAL_UNIT_RESET 0x08
>> +#define UAS_TMF_I_T_NEXUS_RESET 0x10
>> +#define UAS_TMF_CLEAR_ACA 0x40
>> +#define UAS_TMF_QUERY_TASK 0x80
>> +#define UAS_TMF_QUERY_TASK_SET 0x81
>> +#define UAS_TMF_QUERY_ASYNC_EVENT 0x82
>> +
>> +#define UAS_PIPE_ID_COMMAND 0x01
>> +#define UAS_PIPE_ID_STATUS 0x02
>> +#define UAS_PIPE_ID_DATA_IN 0x03
>> +#define UAS_PIPE_ID_DATA_OUT 0x04
>> +
>> +typedef struct {
>> + uint8_t id;
>> + uint8_t reserved;
>> + uint16_t tag;
>> +} QEMU_PACKED uas_ui_header;
>> +
>> +typedef struct {
>> + uint8_t prio_taskattr; /* 6:3 priority, 2:0 task attribute */
>> + uint8_t reserved_1;
>> + uint8_t add_cdb_length; /* 7:2 additional adb length (dwords) */
>> + uint8_t reserved_2;
>> + uint64_t lun;
>> + uint8_t cdb[16];
>> + uint8_t add_cdb[];
>> +} QEMU_PACKED uas_ui_command;
>> +
>> +typedef struct {
>> + uint16_t status_qualifier;
>> + uint8_t status;
>> + uint8_t reserved[7];
>> + uint16_t sense_length;
>> + uint8_t sense_data[18];
>> +} QEMU_PACKED uas_ui_sense;
>> +
>> +typedef struct {
>> + uint16_t add_response_info;
>> + uint8_t response_code;
>> +} QEMU_PACKED uas_ui_response;
>> +
>> +typedef struct {
>> + uint8_t function;
>> + uint8_t reserved;
>> + uint16_t task_tag;
>> + uint64_t lun;
>> +} QEMU_PACKED uas_ui_task_mgmt;
>> +
>> +typedef struct {
>> + uas_ui_header hdr;
>> + union {
>> + uas_ui_command command;
>> + uas_ui_sense sense;
>> + uas_ui_task_mgmt task;
>> + uas_ui_response response;
>> + };
>> +} QEMU_PACKED uas_ui;
>> +
>> +/* --------------------------------------------------------------------- */
>> +
>> +typedef struct UASDevice UASDevice;
>> +typedef struct UASRequest UASRequest;
>> +typedef struct UASStatus UASStatus;
>> +
>> +struct UASDevice {
>> + USBDevice dev;
>> + SCSIBus bus;
>> + UASRequest *datain;
>> + UASRequest *dataout;
>> + USBPacket *status;
>> + QEMUBH *status_bh;
>> + QTAILQ_HEAD(, UASStatus) results;
>> + QTAILQ_HEAD(, UASRequest) requests;
>> +};
>> +
>> +struct UASRequest {
>> + uint16_t tag;
>> + uint64_t lun;
>> + UASDevice *uas;
>> + SCSIDevice *dev;
>> + SCSIRequest *req;
>> + USBPacket *data;
>> + bool data_async;
>> + bool active;
>> + bool complete;
>> + uint32_t buf_off;
>> + uint32_t buf_size;
>> + uint32_t data_off;
>> + uint32_t data_size;
>> + QTAILQ_ENTRY(UASRequest) next;
>> +};
>> +
>> +struct UASStatus {
>> + uas_ui status;
>> + uint32_t length;
>> + QTAILQ_ENTRY(UASStatus) next;
>> +};
>> +
>> +/* --------------------------------------------------------------------- */
>> +
>> +enum {
>> + STR_MANUFACTURER = 1,
>> + STR_PRODUCT,
>> + STR_SERIALNUMBER,
>> + STR_CONFIG_HIGH,
>> +};
>> +
>> +static const USBDescStrings desc_strings = {
>> + [STR_MANUFACTURER] = "QEMU",
>> + [STR_PRODUCT] = "USB Attached SCSI HBA",
>> + [STR_SERIALNUMBER] = "27842",
>> + [STR_CONFIG_HIGH] = "High speed config (usb 2.0)",
>> +};
>> +
>> +static const USBDescIface desc_iface_high = {
>> + .bInterfaceNumber = 0,
>> + .bNumEndpoints = 4,
>> + .bInterfaceClass = USB_CLASS_MASS_STORAGE,
>> + .bInterfaceSubClass = 0x06, /* SCSI */
>> + .bInterfaceProtocol = 0x62, /* UAS */
>> + .eps = (USBDescEndpoint[]) {
>> + {
>> + .bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_COMMAND,
>> + .bmAttributes = USB_ENDPOINT_XFER_BULK,
>> + .wMaxPacketSize = 512,
>> + .extra = (uint8_t[]) {
>> + 0x04, /* u8 bLength */
>> + 0x24, /* u8 bDescriptorType */
>> + UAS_PIPE_ID_COMMAND,
>> + 0x00, /* u8 bReserved */
>> + },
>> + },{
>> + .bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_STATUS,
>> + .bmAttributes = USB_ENDPOINT_XFER_BULK,
>> + .wMaxPacketSize = 512,
>> + .extra = (uint8_t[]) {
>> + 0x04, /* u8 bLength */
>> + 0x24, /* u8 bDescriptorType */
>> + UAS_PIPE_ID_STATUS,
>> + 0x00, /* u8 bReserved */
>> + },
>> + },{
>> + .bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_DATA_IN,
>> + .bmAttributes = USB_ENDPOINT_XFER_BULK,
>> + .wMaxPacketSize = 512,
>> + .extra = (uint8_t[]) {
>> + 0x04, /* u8 bLength */
>> + 0x24, /* u8 bDescriptorType */
>> + UAS_PIPE_ID_DATA_IN,
>> + 0x00, /* u8 bReserved */
>> + },
>> + },{
>> + .bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_DATA_OUT,
>> + .bmAttributes = USB_ENDPOINT_XFER_BULK,
>> + .wMaxPacketSize = 512,
>> + .extra = (uint8_t[]) {
>> + 0x04, /* u8 bLength */
>> + 0x24, /* u8 bDescriptorType */
>> + UAS_PIPE_ID_DATA_OUT,
>> + 0x00, /* u8 bReserved */
>> + },
>> + },
>> + }
>> +};
>> +
>> +static const USBDescDevice desc_device_high = {
>> + .bcdUSB = 0x0200,
>> + .bMaxPacketSize0 = 64,
>> + .bNumConfigurations = 1,
>> + .confs = (USBDescConfig[]) {
>> + {
>> + .bNumInterfaces = 1,
>> + .bConfigurationValue = 1,
>> + .iConfiguration = STR_CONFIG_HIGH,
>> + .bmAttributes = 0xc0,
>> + .nif = 1,
>> + .ifs = &desc_iface_high,
>> + },
>> + },
>> +};
>> +
>> +static const USBDesc desc = {
>> + .id = {
>> + .idVendor = 0x46f4, /* CRC16() of "QEMU" */
>> + .idProduct = 0x0002,
>> + .bcdDevice = 0,
>> + .iManufacturer = STR_MANUFACTURER,
>> + .iProduct = STR_PRODUCT,
>> + .iSerialNumber = STR_SERIALNUMBER,
>> + },
>> + .high = &desc_device_high,
>> + .str = desc_strings,
>> +};
>> +
>> +/* --------------------------------------------------------------------- */
>> +
>> +static UASStatus *usb_uas_alloc_status(uint8_t id, uint16_t tag)
>> +{
>> + UASStatus *st = g_new0(UASStatus, 1);
>> +
>> + st->status.hdr.id = id;
>> + st->status.hdr.tag = cpu_to_be16(tag);
>> + st->length = sizeof(uas_ui_header);
>> + return st;
>> +}
>> +
>> +static void usb_uas_send_status_bh(void *opaque)
>> +{
>> + UASDevice *uas = opaque;
>> + UASStatus *st = QTAILQ_FIRST(&uas->results);
>> + USBPacket *p = uas->status;
>> +
>> + assert(p != NULL);
>> + assert(st != NULL);
>> +
>> + uas->status = NULL;
>> + usb_packet_copy(p, &st->status, st->length);
>> + p->result = st->length;
>> + QTAILQ_REMOVE(&uas->results, st, next);
>> + g_free(st);
>> +
>> + usb_packet_complete(&uas->dev, p);
>> +}
>> +
>> +static void usb_uas_queue_status(UASDevice *uas, UASStatus *st, int length)
>> +{
>> + st->length += length;
>> + QTAILQ_INSERT_TAIL(&uas->results, st, next);
>> + if (uas->status) {
>> + /*
>> + * Just schedule bh make sure any in-flight data transaction
>> + * is finished before completing (sending) the status packet.
>> + */
>> + qemu_bh_schedule(uas->status_bh);
>> + } else {
>> + USBEndpoint *ep = usb_ep_get(&uas->dev, USB_TOKEN_IN,
>> + UAS_PIPE_ID_STATUS);
>> + usb_wakeup(ep);
>> + }
>> +}
>> +
>> +static void usb_uas_queue_response(UASDevice *uas, uint16_t tag,
>> + uint8_t code, uint16_t add_info)
>> +{
>> + UASStatus *st = usb_uas_alloc_status(UAS_UI_RESPONSE, tag);
>> +
>> + trace_usb_uas_response(uas->dev.addr, tag, code);
>> + st->status.response.response_code = code;
>> + st->status.response.add_response_info = cpu_to_be16(add_info);
>> + usb_uas_queue_status(uas, st, sizeof(uas_ui_response));
>> +}
>> +
>> +static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
>> +{
>> + UASStatus *st = usb_uas_alloc_status(UAS_UI_SENSE, req->tag);
>> + int len, slen = 0;
>> +
>> + trace_usb_uas_sense(req->uas->dev.addr, req->tag, status);
>> + st->status.sense.status = status;
>> + st->status.sense.status_qualifier = cpu_to_be16(0);
>> + if (status != GOOD) {
>> + slen = scsi_req_get_sense(req->req, st->status.sense.sense_data,
>> + sizeof(st->status.sense.sense_data));
>> + st->status.sense.sense_length = cpu_to_be16(slen);
>> + }
>> + len = sizeof(uas_ui_sense) - sizeof(st->status.sense.sense_data) + slen;
>> + usb_uas_queue_status(req->uas, st, len);
>> +}
>> +
>> +static void usb_uas_queue_read_ready(UASRequest *req)
>> +{
>> + UASStatus *st = usb_uas_alloc_status(UAS_UI_READ_READY, req->tag);
>> +
>> + trace_usb_uas_read_ready(req->uas->dev.addr, req->tag);
>> + usb_uas_queue_status(req->uas, st, 0);
>> +}
>> +
>> +static void usb_uas_queue_write_ready(UASRequest *req)
>> +{
>> + UASStatus *st = usb_uas_alloc_status(UAS_UI_WRITE_READY, req->tag);
>> +
>> + trace_usb_uas_write_ready(req->uas->dev.addr, req->tag);
>> + usb_uas_queue_status(req->uas, st, 0);
>> +}
>> +
>> +/* --------------------------------------------------------------------- */
>> +
>> +static int usb_uas_get_lun(uint64_t lun64)
>> +{
>> + return (lun64 >> 48) & 0xff;
>> +}
>> +
>> +static SCSIDevice *usb_uas_get_dev(UASDevice *uas, uint64_t lun64)
>> +{
>> + if ((lun64 >> 56) != 0x00) {
>> + return NULL;
>> + }
>> + return scsi_device_find(&uas->bus, 0, 0, usb_uas_get_lun(lun64));
>> +}
>> +
>> +static void usb_uas_complete_data_packet(UASRequest *req)
>> +{
>> + USBPacket *p;
>> +
>> + if (!req->data_async) {
>> + return;
>> + }
>> + p = req->data;
>> + req->data = NULL;
>> + req->data_async = false;
>> + usb_packet_complete(&req->uas->dev, p);
>> +}
>> +
>> +static void usb_uas_copy_data(UASRequest *req)
>> +{
>> + uint32_t length;
>> +
>> + length = MIN(req->buf_size - req->buf_off,
>> + req->data->iov.size - req->data->result);
>> + trace_usb_uas_xfer_data(req->uas->dev.addr, req->tag, length,
>> + req->data->result, req->data->iov.size,
>> + req->buf_off, req->buf_size);
>> + usb_packet_copy(req->data, scsi_req_get_buf(req->req) + req->buf_off,
>> + length);
>> + req->buf_off += length;
>> + req->data_off += length;
>> +
>> + if (req->data->result == req->data->iov.size) {
>> + usb_uas_complete_data_packet(req);
>> + }
>> + if (req->buf_size && req->buf_off == req->buf_size) {
>> + req->buf_off = 0;
>> + req->buf_size = 0;
>> + scsi_req_continue(req->req);
>> + }
>> +}
>> +
>> +static void usb_uas_start_next_transfer(UASDevice *uas)
>> +{
>> + UASRequest *req;
>> +
>> + QTAILQ_FOREACH(req, &uas->requests, next) {
>> + if (req->active || req->complete) {
>> + continue;
>> + }
>> + if (req->req->cmd.mode == SCSI_XFER_FROM_DEV && uas->datain ==
>> NULL) {
>> + uas->datain = req;
>> + usb_uas_queue_read_ready(req);
>> + req->active = true;
>> + return;
>> + }
>> + if (req->req->cmd.mode == SCSI_XFER_TO_DEV && uas->dataout == NULL)
>> {
>> + uas->dataout = req;
>> + usb_uas_queue_write_ready(req);
>> + req->active = true;
>> + return;
>> + }
>> + }
>> +}
>> +
>> +static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_ui *ui)
>> +{
>> + UASRequest *req;
>> +
>> + req = g_new0(UASRequest, 1);
>> + req->uas = uas;
>> + req->tag = be16_to_cpu(ui->hdr.tag);
>> + req->lun = be64_to_cpu(ui->command.lun);
>> + req->dev = usb_uas_get_dev(req->uas, req->lun);
>> + return req;
>> +}
>> +
>> +static void usb_uas_scsi_free_request(SCSIBus *bus, void *priv)
>> +{
>> + UASRequest *req = priv;
>> + UASDevice *uas = req->uas;
>> +
>> + if (req == uas->datain) {
>> + uas->datain = NULL;
>> + }
>> + if (req == uas->dataout) {
>> + uas->dataout = NULL;
>> + }
>> + QTAILQ_REMOVE(&uas->requests, req, next);
>> + g_free(req);
>> +}
>> +
>> +static UASRequest *usb_uas_find_request(UASDevice *uas, uint16_t tag)
>> +{
>> + UASRequest *req;
>> +
>> + QTAILQ_FOREACH(req, &uas->requests, next) {
>> + if (req->tag == tag) {
>> + return req;
>> + }
>> + }
>> + return NULL;
>> +}
>> +
>> +static void usb_uas_scsi_transfer_data(SCSIRequest *r, uint32_t len)
>> +{
>> + UASRequest *req = r->hba_private;
>> +
>> + trace_usb_uas_scsi_data(req->uas->dev.addr, req->tag, len);
>> + req->buf_off = 0;
>> + req->buf_size = len;
>> + if (req->data) {
>> + usb_uas_copy_data(req);
>> + } else {
>> + usb_uas_start_next_transfer(req->uas);
>> + }
>> +}
>> +
>> +static void usb_uas_scsi_command_complete(SCSIRequest *r,
>> + uint32_t status, size_t resid)
>> +{
>> + UASRequest *req = r->hba_private;
>> + UASDevice *uas = req->uas;
>> +
>> + trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, status,
>> resid);
>> + req->complete = true;
>> + if (req->data) {
>> + usb_uas_complete_data_packet(req);
>> + }
>> + usb_uas_queue_sense(req, status);
>> + scsi_req_unref(req->req);
>> + usb_uas_start_next_transfer(uas);
>> +}
>> +
>> +static void usb_uas_scsi_request_cancelled(SCSIRequest *r)
>> +{
>> + UASRequest *req = r->hba_private;
>> +
>> + /* FIXME: queue notification to status pipe? */
>> + scsi_req_unref(req->req);
>> +}
>> +
>> +static const struct SCSIBusInfo usb_uas_scsi_info = {
>> + .tcq = true,
>> + .max_target = 0,
>> + .max_lun = 255,
>> +
>> + .transfer_data = usb_uas_scsi_transfer_data,
>> + .complete = usb_uas_scsi_command_complete,
>> + .cancel = usb_uas_scsi_request_cancelled,
>> + .free_request = usb_uas_scsi_free_request,
>> +};
>> +
>> +/* --------------------------------------------------------------------- */
>> +
>> +static void usb_uas_handle_reset(USBDevice *dev)
>> +{
>> + UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
>> + UASRequest *req, *nreq;
>> + UASStatus *st, *nst;
>> +
>> + trace_usb_uas_reset(dev->addr);
>> + QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
>> + scsi_req_cancel(req->req);
>> + }
>> + QTAILQ_FOREACH_SAFE(st, &uas->results, next, nst) {
>> + QTAILQ_REMOVE(&uas->results, st, next);
>> + g_free(st);
>> + }
>> +}
>> +
>> +static int usb_uas_handle_control(USBDevice *dev, USBPacket *p,
>> + int request, int value, int index, int length, uint8_t *data)
>> +{
>> + int ret;
>> +
>> + ret = usb_desc_handle_control(dev, p, request, value, index, length,
>> data);
>> + if (ret >= 0) {
>> + return ret;
>> + }
>> + fprintf(stderr, "%s: unhandled control request\n", __func__);
>> + return USB_RET_STALL;
>> +}
>> +
>> +static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
>> +{
>> + UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
>> + UASRequest *req, *nreq;
>> +
>> + if (uas->status == p) {
>> + uas->status = NULL;
>> + qemu_bh_cancel(uas->status_bh);
>> + return;
>> + }
>> + QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
>> + if (req->data == p) {
>> + req->data = NULL;
>> + return;
>> + }
>> + }
>> + assert(!"canceled usb packet not found");
>> +}
>> +
>> +static void usb_uas_command(UASDevice *uas, uas_ui *ui)
>> +{
>> + UASRequest *req;
>> + uint32_t len;
>> +
>> + req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
>> + if (req) {
>> + goto overlapped_tag;
>> + }
>> + req = usb_uas_alloc_request(uas, ui);
>> + if (req->dev == NULL) {
>> + goto bad_target;
>> + }
>> +
>> + trace_usb_uas_command(uas->dev.addr, req->tag,
>> + usb_uas_get_lun(req->lun),
>> + req->lun >> 32, req->lun & 0xffffffff);
>> + QTAILQ_INSERT_TAIL(&uas->requests, req, next);
>> + req->req = scsi_req_new(req->dev, req->tag,
>> + usb_uas_get_lun(req->lun),
>> + ui->command.cdb, req);
>> + len = scsi_req_enqueue(req->req);
>> + if (len) {
>> + req->data_size = len;
>> + scsi_req_continue(req->req);
>> + }
>> + return;
>> +
>> +overlapped_tag:
>> + usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
>> + return;
>> +
>> +bad_target:
>> + /*
>> + * FIXME: Seems to upset linux, is this wrong?
>> + * NOTE: Happens only with no scsi devices at the bus, not sure
>> + * this is a valid UAS setup in the first place.
>> + */
>> + usb_uas_queue_response(uas, req->tag, UAS_RC_INVALID_INFO_UNIT, 0);
>> + g_free(req);
>> + return;
>> +}
>> +
>> +static void usb_uas_task(UASDevice *uas, uas_ui *ui)
>> +{
>> + uint16_t tag = be16_to_cpu(ui->hdr.tag);
>> + uint64_t lun64 = be64_to_cpu(ui->task.lun);
>> + SCSIDevice *dev = usb_uas_get_dev(uas, lun64);
>> + int lun = usb_uas_get_lun(lun64);
>> + UASRequest *req;
>> + uint16_t task_tag;
>> +
>> + req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
>> + if (req) {
>> + goto overlapped_tag;
>> + }
>> +
>> + switch (ui->task.function) {
>> + case UAS_TMF_ABORT_TASK:
>> + task_tag = be16_to_cpu(ui->task.task_tag);
>> + trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
>> + if (dev == NULL) {
>> + goto bad_target;
>> + }
>> + if (dev->lun != lun) {
>> + goto incorrect_lun;
>> + }
>> + req = usb_uas_find_request(uas, task_tag);
>> + if (req && req->dev == dev) {
>> + scsi_req_cancel(req->req);
>> + }
>> + usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE, 0);
>> + break;
>> +
>> + case UAS_TMF_LOGICAL_UNIT_RESET:
>> + trace_usb_uas_tmf_logical_unit_reset(uas->dev.addr, tag, lun);
>> + if (dev == NULL) {
>> + goto bad_target;
>> + }
>> + if (dev->lun != lun) {
>> + goto incorrect_lun;
>> + }
>> + qdev_reset_all(&dev->qdev);
>> + usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE, 0);
>> + break;
>> +
>> + default:
>> + trace_usb_uas_tmf_unsupported(uas->dev.addr, tag,
>> ui->task.function);
>> + usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED, 0);
>> + break;
>> + }
>> + return;
>> +
>> +overlapped_tag:
>> + usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
>> + return;
>> +
>> +bad_target:
>> + /* FIXME: correct? [see long comment in usb_uas_command()] */
>> + usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT, 0);
>> + return;
>> +
>> +incorrect_lun:
>> + usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN, 0);
>> + return;
>> +}
>> +
>> +static int usb_uas_handle_data(USBDevice *dev, USBPacket *p)
>> +{
>> + UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
>> + uas_ui ui;
>> + UASStatus *st;
>> + UASRequest *req;
>> + int length, ret = 0;
>> +
>> + switch (p->ep->nr) {
>> + case UAS_PIPE_ID_COMMAND:
>> + length = MIN(sizeof(ui), p->iov.size);
>> + usb_packet_copy(p, &ui, length);
>> + switch (ui.hdr.id) {
>> + case UAS_UI_COMMAND:
>> + usb_uas_command(uas, &ui);
>> + ret = length;
>> + break;
>> + case UAS_UI_TASK_MGMT:
>> + usb_uas_task(uas, &ui);
>> + ret = length;
>> + break;
>> + default:
>> + fprintf(stderr, "%s: unknown command ui: id 0x%x\n",
>> + __func__, ui.hdr.id);
>> + ret = USB_RET_STALL;
>> + break;
>> + }
>> + break;
>> + case UAS_PIPE_ID_STATUS:
>> + st = QTAILQ_FIRST(&uas->results);
>> + if (st == NULL) {
>> + assert(uas->status == NULL);
>> + uas->status = p;
>> + ret = USB_RET_ASYNC;
>> + break;
>> + }
>> + usb_packet_copy(p, &st->status, st->length);
>> + ret = st->length;
>> + QTAILQ_REMOVE(&uas->results, st, next);
>> + g_free(st);
>> + break;
>> + case UAS_PIPE_ID_DATA_IN:
>> + case UAS_PIPE_ID_DATA_OUT:
>> + req = (p->ep->nr == UAS_PIPE_ID_DATA_IN) ? uas->datain :
>> uas->dataout;
>> + if (req == NULL) {
>> + fprintf(stderr, "%s: no inflight request\n", __func__);
>> + ret = USB_RET_STALL;
>> + break;
>> + }
>> + scsi_req_ref(req->req);
>> + req->data = p;
>> + usb_uas_copy_data(req);
>> + if (p->result == p->iov.size || req->complete) {
>> + req->data = NULL;
>> + ret = p->result;
>> + } else {
>> + req->data_async = true;
>> + ret = USB_RET_ASYNC;
>> + }
>> + scsi_req_unref(req->req);
>> + usb_uas_start_next_transfer(uas);
>> + break;
>> + default:
>> + fprintf(stderr, "%s: invalid endpoint %d\n", __func__, p->ep->nr);
>> + ret = USB_RET_STALL;
>> + break;
>> + }
>> + return ret;
>> +}
>> +
>> +static void usb_uas_handle_destroy(USBDevice *dev)
>> +{
>> + UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
>> +
>> + qemu_bh_delete(uas->status_bh);
>> +}
>> +
>> +static int usb_uas_init(USBDevice *dev)
>> +{
>> + UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
>> +
>> + usb_desc_create_serial(dev);
>> + usb_desc_init(dev);
>> +
>> + QTAILQ_INIT(&uas->results);
>> + QTAILQ_INIT(&uas->requests);
>> + uas->status_bh = qemu_bh_new(usb_uas_send_status_bh, uas);
>> +
>> + scsi_bus_new(&uas->bus, &uas->dev.qdev, &usb_uas_scsi_info);
>> +
>> + return 0;
>> +}
>> +
>> +static const VMStateDescription vmstate_usb_uas = {
>> + .name = "usb-uas",
>> + .unmigratable = 1,
>> + .fields = (VMStateField[]) {
>> + VMSTATE_USB_DEVICE(dev, UASDevice),
>> + VMSTATE_END_OF_LIST()
>> + }
>> +};
>> +
>> +static void usb_uas_class_initfn(ObjectClass *klass, void *data)
>> +{
>> + DeviceClass *dc = DEVICE_CLASS(klass);
>> + USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
>> +
>> + uc->init = usb_uas_init;
>> + uc->product_desc = desc_strings[STR_PRODUCT];
>> + uc->usb_desc = &desc;
>> + uc->cancel_packet = usb_uas_cancel_io;
>> + uc->handle_attach = usb_desc_attach;
>> + uc->handle_reset = usb_uas_handle_reset;
>> + uc->handle_control = usb_uas_handle_control;
>> + uc->handle_data = usb_uas_handle_data;
>> + uc->handle_destroy = usb_uas_handle_destroy;
>> + dc->fw_name = "storage";
>> + dc->vmsd = &vmstate_usb_uas;
>> +}
>> +
>> +static TypeInfo uas_info = {
>> + .name = "usb-uas",
>> + .parent = TYPE_USB_DEVICE,
>> + .instance_size = sizeof(UASDevice),
>> + .class_init = usb_uas_class_initfn,
>> +};
>> +
>> +static void usb_uas_register_types(void)
>> +{
>> + type_register_static(&uas_info);
>> +}
>> +
>> +type_init(usb_uas_register_types)
>> diff --git a/trace-events b/trace-events
>> index 1f9fc98..04b3d93 100644
>> --- a/trace-events
>> +++ b/trace-events
>> @@ -347,6 +347,20 @@ usb_hub_clear_port_feature(int addr, int nr, const char
>> *f) "dev %d, port %d, fe
>> usb_hub_attach(int addr, int nr) "dev %d, port %d"
>> usb_hub_detach(int addr, int nr) "dev %d, port %d"
>>
>> +# hw/usb/dev-uas.c
>> +usb_uas_reset(int addr) "dev %d"
>> +usb_uas_command(int addr, uint16_t tag, int lun, uint32_t lun64_1, uint32_t
>> lun64_2) "dev %d, tag 0x%x, lun %d, lun64 %08x-%08x"
>> +usb_uas_response(int addr, uint16_t tag, uint8_t code) "dev %d, tag 0x%x,
>> code 0x%x"
>> +usb_uas_sense(int addr, uint16_t tag, uint8_t status) "dev %d, tag 0x%x,
>> status 0x%x"
>> +usb_uas_read_ready(int addr, uint16_t tag) "dev %d, tag 0x%x"
>> +usb_uas_write_ready(int addr, uint16_t tag) "dev %d, tag 0x%x"
>> +usb_uas_xfer_data(int addr, uint16_t tag, uint32_t copy, uint32_t uoff,
>> uint32_t usize, uint32_t soff, uint32_t ssize) "dev %d, tag 0x%x, copy %d,
>> usb-pkt %d/%d, scsi-buf %d/%d"
>
> The above tracepoint seems to require too many parameters for the
> simple tracing backend. Trace routines appear to go up to trace6 in
> trace/simple.c but no trace7. So please add the trace7 or reduce the
> number of parameters above.
>
> Currently with the above situation, trying to build latest scsi-next
> with ./configure --enable-trace-backend=simple is resulting in a build
> break around trace_usb_uas_xfer_data.
Thanks for pointing this out. The limitation will be lifted soon,
Harsh Prateek Bora has submitted a simpletrace v2 patch series which
moves to a variable-length record format. It can support >6 arguments
but has not been applied yet. I am going to review and hopefully
merge it into the tracing tree this week.
It's still a good idea to shorten the trace event definition in the meantime.
Stefan
