On 10/29/2014 08:53 AM, Hannes Reinecke wrote:
> All scsi functions take a scsi device as argument, which has
> a LUN assigned to it. So we can get rid of specifying the 'lun'
> as separate argument.
... except if you are sending a command to a non-existent LUN, in which
case scsi_req_new detects this and redirects to a special SCSIReqOps
instance:
... else if (lun != d->lun ||
buf[0] == REPORT_LUNS ||
(buf[0] == REQUEST_SENSE && d->sense_len)) {
ops = &reqops_target_command;
} else {
ops = NULL;
}
Yes, it's ugly. If you have a better idea, I'm all ears. Passing a
NULL SCSIDevice is hard though.
Paolo
> Signed-off-by: Hannes Reinecke <h...@suse.de>
> ---
> hw/scsi/esp.c | 2 +-
> hw/scsi/lsi53c895a.c | 3 +--
> hw/scsi/megasas.c | 44 +++++++++++++++++------------------
> hw/scsi/scsi-bus.c | 62
> +++++++++++++++++++++++---------------------------
> hw/scsi/scsi-disk.c | 13 +++++------
> hw/scsi/scsi-generic.c | 4 ++--
> hw/scsi/virtio-scsi.c | 1 -
> hw/scsi/vmw_pvscsi.c | 2 +-
> hw/usb/dev-storage.c | 2 +-
> hw/usb/dev-uas.c | 1 -
> include/hw/scsi/scsi.h | 7 +++---
> 11 files changed, 65 insertions(+), 76 deletions(-)
>
> diff --git a/hw/scsi/esp.c b/hw/scsi/esp.c
> index 5ab44d8..1123156 100644
> --- a/hw/scsi/esp.c
> +++ b/hw/scsi/esp.c
> @@ -129,7 +129,7 @@ static void do_busid_cmd(ESPState *s, uint8_t *buf,
> uint8_t busid)
> trace_esp_do_busid_cmd(busid);
> lun = busid & 7;
> current_lun = scsi_device_find(&s->bus, 0, s->current_dev->id, lun);
> - s->current_req = scsi_req_new(current_lun, 0, lun, buf, s);
> + s->current_req = scsi_req_new(current_lun, 0, buf, s);
> datalen = scsi_req_enqueue(s->current_req);
> s->ti_size = datalen;
> if (datalen != 0) {
> diff --git a/hw/scsi/lsi53c895a.c b/hw/scsi/lsi53c895a.c
> index d9b4c7e..a185e0c 100644
> --- a/hw/scsi/lsi53c895a.c
> +++ b/hw/scsi/lsi53c895a.c
> @@ -783,8 +783,7 @@ static void lsi_do_command(LSIState *s)
> assert(s->current == NULL);
> s->current = g_malloc0(sizeof(lsi_request));
> s->current->tag = s->select_tag;
> - s->current->req = scsi_req_new(dev, s->current->tag, s->current_lun, buf,
> - s->current);
> + s->current->req = scsi_req_new(dev, s->current->tag, buf, s->current);
>
> n = scsi_req_enqueue(s->current->req);
> if (n) {
> diff --git a/hw/scsi/megasas.c b/hw/scsi/megasas.c
> index eedc992..5b9e508 100644
> --- a/hw/scsi/megasas.c
> +++ b/hw/scsi/megasas.c
> @@ -971,14 +971,13 @@ static int megasas_dcmd_pd_list_query(MegasasState *s,
> MegasasCmd *cmd)
> return MFI_STAT_OK;
> }
>
> -static int megasas_pd_get_info_submit(SCSIDevice *sdev, int lun,
> - MegasasCmd *cmd)
> +static int megasas_pd_get_info_submit(SCSIDevice *sdev, MegasasCmd *cmd)
> {
> struct mfi_pd_info *info = cmd->iov_buf;
> size_t dcmd_size = sizeof(struct mfi_pd_info);
> BlockConf *conf = &sdev->conf;
> uint64_t pd_size;
> - uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF);
> + uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF);
> uint8_t cmdbuf[6];
> SCSIRequest *req;
> size_t len, resid;
> @@ -990,7 +989,7 @@ static int megasas_pd_get_info_submit(SCSIDevice *sdev,
> int lun,
> info->inquiry_data[0] = 0x7f; /* Force PQual 0x3, PType 0x1f */
> info->vpd_page83[0] = 0x7f;
> megasas_setup_inquiry(cmdbuf, 0, sizeof(info->inquiry_data));
> - req = scsi_req_new(sdev, cmd->index, lun, cmdbuf, cmd);
> + req = scsi_req_new(sdev, cmd->index, cmdbuf, cmd);
> if (!req) {
> trace_megasas_dcmd_req_alloc_failed(cmd->index,
> "PD get info std inquiry");
> @@ -999,7 +998,8 @@ static int megasas_pd_get_info_submit(SCSIDevice *sdev,
> int lun,
> return MFI_STAT_FLASH_ALLOC_FAIL;
> }
> trace_megasas_dcmd_internal_submit(cmd->index,
> - "PD get info std inquiry", lun);
> + "PD get info std inquiry",
> + sdev->lun);
> len = scsi_req_enqueue(req);
> if (len > 0) {
> cmd->iov_size = len;
> @@ -1008,14 +1008,15 @@ static int megasas_pd_get_info_submit(SCSIDevice
> *sdev, int lun,
> return MFI_STAT_INVALID_STATUS;
> } else if (info->inquiry_data[0] != 0x7f && info->vpd_page83[0] == 0x7f)
> {
> megasas_setup_inquiry(cmdbuf, 0x83, sizeof(info->vpd_page83));
> - req = scsi_req_new(sdev, cmd->index, lun, cmdbuf, cmd);
> + req = scsi_req_new(sdev, cmd->index, cmdbuf, cmd);
> if (!req) {
> trace_megasas_dcmd_req_alloc_failed(cmd->index,
> "PD get info vpd inquiry");
> return MFI_STAT_FLASH_ALLOC_FAIL;
> }
> trace_megasas_dcmd_internal_submit(cmd->index,
> - "PD get info vpd inquiry", lun);
> + "PD get info vpd inquiry",
> + sdev->lun);
> len = scsi_req_enqueue(req);
> if (len > 0) {
> cmd->iov_size = len;
> @@ -1074,7 +1075,7 @@ static int megasas_dcmd_pd_get_info(MegasasState *s,
> MegasasCmd *cmd)
>
> if (sdev) {
> /* Submit inquiry */
> - retval = megasas_pd_get_info_submit(sdev, pd_id, cmd);
> + retval = megasas_pd_get_info_submit(sdev, cmd);
> }
>
> return retval;
> @@ -1136,8 +1137,7 @@ static int megasas_dcmd_ld_list_query(MegasasState *s,
> MegasasCmd *cmd)
> return MFI_STAT_OK;
> }
>
> -static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun,
> - MegasasCmd *cmd)
> +static int megasas_ld_get_info_submit(SCSIDevice *sdev, MegasasCmd *cmd)
> {
> struct mfi_ld_info *info = cmd->iov_buf;
> size_t dcmd_size = sizeof(struct mfi_ld_info);
> @@ -1145,7 +1145,7 @@ static int megasas_ld_get_info_submit(SCSIDevice *sdev,
> int lun,
> SCSIRequest *req;
> ssize_t len, resid;
> BlockConf *conf = &sdev->conf;
> - uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF);
> + uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF);
> uint64_t ld_size;
>
> if (!cmd->iov_buf) {
> @@ -1153,7 +1153,7 @@ static int megasas_ld_get_info_submit(SCSIDevice *sdev,
> int lun,
> memset(cmd->iov_buf, 0x0, dcmd_size);
> info = cmd->iov_buf;
> megasas_setup_inquiry(cdb, 0x83, sizeof(info->vpd_page83));
> - req = scsi_req_new(sdev, cmd->index, lun, cdb, cmd);
> + req = scsi_req_new(sdev, cmd->index, cdb, cmd);
> if (!req) {
> trace_megasas_dcmd_req_alloc_failed(cmd->index,
> "LD get info vpd inquiry");
> @@ -1162,7 +1162,8 @@ static int megasas_ld_get_info_submit(SCSIDevice *sdev,
> int lun,
> return MFI_STAT_FLASH_ALLOC_FAIL;
> }
> trace_megasas_dcmd_internal_submit(cmd->index,
> - "LD get info vpd inquiry", lun);
> + "LD get info vpd inquiry",
> + sdev->lun);
> len = scsi_req_enqueue(req);
> if (len > 0) {
> cmd->iov_size = len;
> @@ -1172,7 +1173,7 @@ static int megasas_ld_get_info_submit(SCSIDevice *sdev,
> int lun,
> }
>
> info->ld_config.params.state = MFI_LD_STATE_OPTIMAL;
> - info->ld_config.properties.ld.v.target_id = lun;
> + info->ld_config.properties.ld.v.target_id = sdev->lun;
> info->ld_config.params.stripe_size = 3;
> info->ld_config.params.num_drives = 1;
> info->ld_config.params.is_consistent = 1;
> @@ -1217,7 +1218,7 @@ static int megasas_dcmd_ld_get_info(MegasasState *s,
> MegasasCmd *cmd)
> }
>
> if (sdev) {
> - retval = megasas_ld_get_info_submit(sdev, ld_id, cmd);
> + retval = megasas_ld_get_info_submit(sdev, cmd);
> }
>
> return retval;
> @@ -1509,17 +1510,16 @@ static int megasas_finish_internal_dcmd(MegasasCmd
> *cmd,
> {
> int opcode;
> int retval = MFI_STAT_OK;
> - int lun = req->lun;
>
> opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
> scsi_req_unref(req);
> - trace_megasas_dcmd_internal_finish(cmd->index, opcode, lun);
> + trace_megasas_dcmd_internal_finish(cmd->index, opcode, req->dev->lun);
> switch (opcode) {
> case MFI_DCMD_PD_GET_INFO:
> - retval = megasas_pd_get_info_submit(req->dev, lun, cmd);
> + retval = megasas_pd_get_info_submit(req->dev, cmd);
> break;
> case MFI_DCMD_LD_GET_INFO:
> - retval = megasas_ld_get_info_submit(req->dev, lun, cmd);
> + retval = megasas_ld_get_info_submit(req->dev, cmd);
> break;
> default:
> trace_megasas_dcmd_internal_invalid(cmd->index, opcode);
> @@ -1609,8 +1609,7 @@ static int megasas_handle_scsi(MegasasState *s,
> MegasasCmd *cmd,
> return MFI_STAT_SCSI_DONE_WITH_ERROR;
> }
>
> - cmd->req = scsi_req_new(sdev, cmd->index,
> - cmd->frame->header.lun_id, cdb, cmd);
> + cmd->req = scsi_req_new(sdev, cmd->index, cdb, cmd);
> if (!cmd->req) {
> trace_megasas_scsi_req_alloc_failed(
> mfi_frame_desc[cmd->frame->header.frame_cmd],
> @@ -1686,8 +1685,7 @@ static int megasas_handle_io(MegasasState *s,
> MegasasCmd *cmd)
> }
>
> megasas_encode_lba(cdb, lba_start, lba_count, is_write);
> - cmd->req = scsi_req_new(sdev, cmd->index,
> - cmd->frame->header.lun_id, cdb, cmd);
> + cmd->req = scsi_req_new(sdev, cmd->index, cdb, cmd);
> if (!cmd->req) {
> trace_megasas_scsi_req_alloc_failed(
> mfi_frame_desc[cmd->frame->header.frame_cmd],
> diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c
> index 64d0880..0f13b77 100644
> --- a/hw/scsi/scsi-bus.c
> +++ b/hw/scsi/scsi-bus.c
> @@ -72,12 +72,12 @@ int scsi_bus_parse_cdb(SCSIDevice *dev, SCSICommand *cmd,
> uint8_t *buf,
> return rc;
> }
>
> -static SCSIRequest *scsi_device_alloc_req(SCSIDevice *s, uint32_t tag,
> uint32_t lun,
> +static SCSIRequest *scsi_device_alloc_req(SCSIDevice *s, uint32_t tag,
> uint8_t *buf, void *hba_private)
> {
> SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);
> if (sc->alloc_req) {
> - return sc->alloc_req(s, tag, lun, buf, hba_private);
> + return sc->alloc_req(s, tag, buf, hba_private);
> }
>
> return NULL;
> @@ -401,8 +401,6 @@ static bool scsi_target_emulate_report_luns(SCSITargetReq
> *r)
>
> static bool scsi_target_emulate_inquiry(SCSITargetReq *r)
> {
> - assert(r->req.dev->lun != r->req.lun);
> -
> scsi_target_alloc_buf(&r->req, SCSI_INQUIRY_LEN);
>
> if (r->req.cmd.buf[1] & 0x2) {
> @@ -442,7 +440,7 @@ static bool scsi_target_emulate_inquiry(SCSITargetReq *r)
> /* PAGE CODE == 0 */
> r->len = MIN(r->req.cmd.xfer, SCSI_INQUIRY_LEN);
> memset(r->buf, 0, r->len);
> - if (r->req.lun != 0) {
> + if (r->req.dev->lun != 0) {
> r->buf[0] = TYPE_NO_LUN;
> } else {
> r->buf[0] = TYPE_NOT_PRESENT | TYPE_INACTIVE;
> @@ -549,7 +547,7 @@ static const struct SCSIReqOps reqops_target_command = {
>
>
> SCSIRequest *scsi_req_alloc(const SCSIReqOps *reqops, SCSIDevice *d,
> - uint32_t tag, uint32_t lun, void *hba_private)
> + uint32_t tag, void *hba_private)
> {
> SCSIRequest *req;
> SCSIBus *bus = scsi_bus_from_device(d);
> @@ -563,18 +561,17 @@ SCSIRequest *scsi_req_alloc(const SCSIReqOps *reqops,
> SCSIDevice *d,
> req->bus = bus;
> req->dev = d;
> req->tag = tag;
> - req->lun = lun;
> req->hba_private = hba_private;
> req->status = -1;
> req->ops = reqops;
> object_ref(OBJECT(d));
> object_ref(OBJECT(qbus->parent));
> notifier_list_init(&req->cancel_notifiers);
> - trace_scsi_req_alloc(req->dev->id, req->lun, req->tag);
> + trace_scsi_req_alloc(req->dev->id, req->dev->lun, req->tag);
> return req;
> }
>
> -SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun,
> +SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag,
> uint8_t *buf, void *hba_private)
> {
> SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, d->qdev.parent_bus);
> @@ -597,8 +594,7 @@ SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag,
> uint32_t lun,
> */
> !(buf[0] == REQUEST_SENSE && d->sense_is_ua))) {
> ops = &reqops_unit_attention;
> - } else if (lun != d->lun ||
> - buf[0] == REPORT_LUNS ||
> + } else if (buf[0] == REPORT_LUNS ||
> (buf[0] == REQUEST_SENSE && d->sense_len)) {
> ops = &reqops_target_command;
> } else {
> @@ -612,23 +608,22 @@ SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag,
> uint32_t lun,
> }
>
> if (ret != 0) {
> - trace_scsi_req_parse_bad(d->id, lun, tag, buf[0]);
> - req = scsi_req_alloc(&reqops_invalid_opcode, d, tag, lun,
> hba_private);
> + trace_scsi_req_parse_bad(d->id, d->lun, tag, buf[0]);
> + req = scsi_req_alloc(&reqops_invalid_opcode, d, tag, hba_private);
> } else {
> assert(cmd.len != 0);
> - trace_scsi_req_parsed(d->id, lun, tag, buf[0],
> + trace_scsi_req_parsed(d->id, d->lun, tag, buf[0],
> cmd.mode, cmd.xfer);
> if (cmd.lba != -1) {
> - trace_scsi_req_parsed_lba(d->id, lun, tag, buf[0],
> - cmd.lba);
> + trace_scsi_req_parsed_lba(d->id, d->lun, tag, buf[0], cmd.lba);
> }
>
> if (cmd.xfer > INT32_MAX) {
> - req = scsi_req_alloc(&reqops_invalid_field, d, tag, lun,
> hba_private);
> + req = scsi_req_alloc(&reqops_invalid_field, d, tag, hba_private);
> } else if (ops) {
> - req = scsi_req_alloc(ops, d, tag, lun, hba_private);
> + req = scsi_req_alloc(ops, d, tag, hba_private);
> } else {
> - req = scsi_device_alloc_req(d, tag, lun, buf, hba_private);
> + req = scsi_device_alloc_req(d, tag, buf, hba_private);
> }
> }
>
> @@ -637,16 +632,16 @@ SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag,
> uint32_t lun,
>
> switch (buf[0]) {
> case INQUIRY:
> - trace_scsi_inquiry(d->id, lun, tag, cmd.buf[1], cmd.buf[2]);
> + trace_scsi_inquiry(d->id, d->lun, tag, cmd.buf[1], cmd.buf[2]);
> break;
> case TEST_UNIT_READY:
> - trace_scsi_test_unit_ready(d->id, lun, tag);
> + trace_scsi_test_unit_ready(d->id, d->lun, tag);
> break;
> case REPORT_LUNS:
> - trace_scsi_report_luns(d->id, lun, tag);
> + trace_scsi_report_luns(d->id, d->lun, tag);
> break;
> case REQUEST_SENSE:
> - trace_scsi_request_sense(d->id, lun, tag);
> + trace_scsi_request_sense(d->id, d->lun, tag);
> break;
> default:
> break;
> @@ -734,7 +729,7 @@ int scsi_device_get_sense(SCSIDevice *dev, uint8_t *buf,
> int len, bool fixed)
>
> void scsi_req_build_sense(SCSIRequest *req, SCSISense sense)
> {
> - trace_scsi_req_build_sense(req->dev->id, req->lun, req->tag,
> + trace_scsi_req_build_sense(req->dev->id, req->dev->lun, req->tag,
> sense.key, sense.asc, sense.ascq);
> memset(req->sense, 0, 18);
> req->sense[0] = 0x70;
> @@ -772,7 +767,7 @@ int32_t scsi_req_enqueue(SCSIRequest *req)
>
> static void scsi_req_dequeue(SCSIRequest *req)
> {
> - trace_scsi_req_dequeue(req->dev->id, req->lun, req->tag);
> + trace_scsi_req_dequeue(req->dev->id, req->dev->lun, req->tag);
> req->retry = false;
> if (req->enqueued) {
> QTAILQ_REMOVE(&req->dev->requests, req, next);
> @@ -1622,10 +1617,10 @@ void scsi_req_unref(SCSIRequest *req)
> void scsi_req_continue(SCSIRequest *req)
> {
> if (req->io_canceled) {
> - trace_scsi_req_continue_canceled(req->dev->id, req->lun, req->tag);
> + trace_scsi_req_continue_canceled(req->dev->id, req->dev->lun,
> req->tag);
> return;
> }
> - trace_scsi_req_continue(req->dev->id, req->lun, req->tag);
> + trace_scsi_req_continue(req->dev->id, req->dev->lun, req->tag);
> if (req->cmd.mode == SCSI_XFER_TO_DEV) {
> req->ops->write_data(req);
> } else {
> @@ -1640,10 +1635,11 @@ void scsi_req_data(SCSIRequest *req, int len)
> {
> uint8_t *buf;
> if (req->io_canceled) {
> - trace_scsi_req_data_canceled(req->dev->id, req->lun, req->tag, len);
> + trace_scsi_req_data_canceled(req->dev->id, req->dev->lun,
> + req->tag, len);
> return;
> }
> - trace_scsi_req_data(req->dev->id, req->lun, req->tag, len);
> + trace_scsi_req_data(req->dev->id, req->dev->lun, req->tag, len);
> assert(req->cmd.mode != SCSI_XFER_NONE);
> if (!req->sg) {
> req->resid -= len;
> @@ -1746,7 +1742,7 @@ void scsi_req_cancel_complete(SCSIRequest *req)
> * */
> void scsi_req_cancel_async(SCSIRequest *req, Notifier *notifier)
> {
> - trace_scsi_req_cancel(req->dev->id, req->lun, req->tag);
> + trace_scsi_req_cancel(req->dev->id, req->dev->lun, req->tag);
> if (notifier) {
> notifier_list_add(&req->cancel_notifiers, notifier);
> }
> @@ -1763,7 +1759,7 @@ void scsi_req_cancel_async(SCSIRequest *req, Notifier
> *notifier)
>
> void scsi_req_cancel(SCSIRequest *req)
> {
> - trace_scsi_req_cancel(req->dev->id, req->lun, req->tag);
> + trace_scsi_req_cancel(req->dev->id, req->dev->lun, req->tag);
> if (!req->enqueued) {
> return;
> }
> @@ -1895,7 +1891,7 @@ static void put_scsi_requests(QEMUFile *f, void *pv,
> size_t size)
> qemu_put_sbyte(f, req->retry ? 1 : 2);
> qemu_put_buffer(f, req->cmd.buf, sizeof(req->cmd.buf));
> qemu_put_be32s(f, &req->tag);
> - qemu_put_be32s(f, &req->lun);
> + qemu_put_be32s(f, &req->dev->lun);
> if (bus->info->save_request) {
> bus->info->save_request(f, req);
> }
> @@ -1921,7 +1917,7 @@ static int get_scsi_requests(QEMUFile *f, void *pv,
> size_t size)
> qemu_get_buffer(f, buf, sizeof(buf));
> qemu_get_be32s(f, &tag);
> qemu_get_be32s(f, &lun);
> - req = scsi_req_new(s, tag, lun, buf, NULL);
> + req = scsi_req_new(s, tag, buf, NULL);
> req->retry = (sbyte == 1);
> if (bus->info->load_request) {
> req->hba_private = bus->info->load_request(f, req);
> diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
> index 30e3789..dec669e 100644
> --- a/hw/scsi/scsi-disk.c
> +++ b/hw/scsi/scsi-disk.c
> @@ -2374,7 +2374,7 @@ static const SCSIReqOps *const
> scsi_disk_reqops_dispatch[256] = {
> [WRITE_VERIFY_16] = &scsi_disk_dma_reqops,
> };
>
> -static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t
> lun,
> +static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag,
> uint8_t *buf, void *hba_private)
> {
> SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
> @@ -2387,10 +2387,10 @@ static SCSIRequest *scsi_new_request(SCSIDevice *d,
> uint32_t tag, uint32_t lun,
> if (!ops) {
> ops = &scsi_disk_emulate_reqops;
> }
> - req = scsi_req_alloc(ops, &s->qdev, tag, lun, hba_private);
> + req = scsi_req_alloc(ops, &s->qdev, tag, hba_private);
>
> #ifdef DEBUG_SCSI
> - DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun, tag, buf[0]);
> + DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", d->lun, tag, buf[0]);
> {
> int i;
> for (i = 1; i < scsi_cdb_length(buf); i++) {
> @@ -2539,16 +2539,15 @@ static bool scsi_block_is_passthrough(SCSIDiskState
> *s, uint8_t *buf)
>
>
> static SCSIRequest *scsi_block_new_request(SCSIDevice *d, uint32_t tag,
> - uint32_t lun, uint8_t *buf,
> - void *hba_private)
> + uint8_t *buf, void *hba_private)
> {
> SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
>
> if (scsi_block_is_passthrough(s, buf)) {
> - return scsi_req_alloc(&scsi_generic_req_ops, &s->qdev, tag, lun,
> + return scsi_req_alloc(&scsi_generic_req_ops, &s->qdev, tag,
> hba_private);
> } else {
> - return scsi_req_alloc(&scsi_disk_dma_reqops, &s->qdev, tag, lun,
> + return scsi_req_alloc(&scsi_disk_dma_reqops, &s->qdev, tag,
> hba_private);
> }
> }
> diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c
> index 84a1d5b..837f670 100644
> --- a/hw/scsi/scsi-generic.c
> +++ b/hw/scsi/scsi-generic.c
> @@ -449,12 +449,12 @@ const SCSIReqOps scsi_generic_req_ops = {
> .save_request = scsi_generic_save_request,
> };
>
> -static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t
> lun,
> +static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag,
> uint8_t *buf, void *hba_private)
> {
> SCSIRequest *req;
>
> - req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, lun, hba_private);
> + req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, hba_private);
> return req;
> }
>
> diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
> index 8547ea0..dd71edc 100644
> --- a/hw/scsi/virtio-scsi.c
> +++ b/hw/scsi/virtio-scsi.c
> @@ -528,7 +528,6 @@ bool virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s,
> VirtIOSCSIReq *req)
> aio_context_release(s->ctx);
> }
> req->sreq = scsi_req_new(d, req->req.cmd.tag,
> - virtio_scsi_get_lun(req->req.cmd.lun),
> req->req.cdb, req);
>
> if (req->sreq->cmd.mode != SCSI_XFER_NONE
> diff --git a/hw/scsi/vmw_pvscsi.c b/hw/scsi/vmw_pvscsi.c
> index d3a92fb..873c830 100644
> --- a/hw/scsi/vmw_pvscsi.c
> +++ b/hw/scsi/vmw_pvscsi.c
> @@ -652,7 +652,7 @@ pvscsi_process_request_descriptor(PVSCSIState *s,
> r->sg.elemAddr = descr->dataAddr;
> }
>
> - r->sreq = scsi_req_new(d, descr->context, r->lun, descr->cdb, r);
> + r->sreq = scsi_req_new(d, descr->context, descr->cdb, r);
> if (r->sreq->cmd.mode == SCSI_XFER_FROM_DEV &&
> (descr->flags & PVSCSI_FLAG_CMD_DIR_TODEVICE)) {
> r->cmp.hostStatus = BTSTAT_BADMSG;
> diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c
> index 5bfc72c..c2e9d50 100644
> --- a/hw/usb/dev-storage.c
> +++ b/hw/usb/dev-storage.c
> @@ -439,7 +439,7 @@ static void usb_msd_handle_data(USBDevice *dev, USBPacket
> *p)
> tag, cbw.flags, cbw.cmd_len, s->data_len);
> assert(le32_to_cpu(s->csw.residue) == 0);
> s->scsi_len = 0;
> - s->req = scsi_req_new(scsi_dev, tag, cbw.lun, cbw.cmd, NULL);
> + s->req = scsi_req_new(scsi_dev, tag, cbw.cmd, NULL);
> #ifdef DEBUG_MSD
> scsi_req_print(s->req);
> #endif
> diff --git a/hw/usb/dev-uas.c b/hw/usb/dev-uas.c
> index 04fc515..dcb3773 100644
> --- a/hw/usb/dev-uas.c
> +++ b/hw/usb/dev-uas.c
> @@ -714,7 +714,6 @@ static void usb_uas_command(UASDevice *uas, uas_iu *iu)
> }
>
> req->req = scsi_req_new(req->dev, req->tag,
> - usb_uas_get_lun(req->lun),
> iu->command.cdb, req);
> if (uas->requestlog) {
> scsi_req_print(req->req);
> diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h
> index 4e9bbd1..afb3f5d 100644
> --- a/include/hw/scsi/scsi.h
> +++ b/include/hw/scsi/scsi.h
> @@ -49,7 +49,6 @@ struct SCSIRequest {
> const SCSIReqOps *ops;
> uint32_t refcount;
> uint32_t tag;
> - uint32_t lun;
> uint32_t status;
> void *hba_private;
> size_t resid;
> @@ -87,7 +86,7 @@ typedef struct SCSIDeviceClass {
> void (*unrealize)(SCSIDevice *dev, Error **errp);
> int (*parse_cdb)(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf,
> void *hba_private);
> - SCSIRequest *(*alloc_req)(SCSIDevice *s, uint32_t tag, uint32_t lun,
> + SCSIRequest *(*alloc_req)(SCSIDevice *s, uint32_t tag,
> uint8_t *buf, void *hba_private);
> void (*unit_attention_reported)(SCSIDevice *s);
> } SCSIDeviceClass;
> @@ -247,8 +246,8 @@ int scsi_build_sense(uint8_t *in_buf, int in_len,
> uint8_t *buf, int len, bool fixed);
>
> SCSIRequest *scsi_req_alloc(const SCSIReqOps *reqops, SCSIDevice *d,
> - uint32_t tag, uint32_t lun, void *hba_private);
> -SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun,
> + uint32_t tag, void *hba_private);
> +SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag,
> uint8_t *buf, void *hba_private);
> int32_t scsi_req_enqueue(SCSIRequest *req);
> void scsi_req_free(SCSIRequest *req);
>
