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);
