mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

scsi: drop 'result' argument from command_complete callback

Browse Source 
The command complete callback has a SCSIRequest as the first argument,
and the status field of that structure is identical to the 'status'
argument. So drop the argument from the callback.

Signed-off-by: Hannes Reinecke <hare@suse.de>
Message-Id: <20201116184041.60465-3-hare@suse.de>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Hannes Reinecke 2020-11-16 19:40:36 +01:00 committed by Paolo Bonzini
parent 782a78c9e9
commit 17ea26c2d8
13 changed files with 32 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
hw/scsi/esp-pci.c
View File

@ -329,13 +329,12 @@ static const VMStateDescription vmstate_esp_pci_scsi = {
} }
}; };
static void esp_pci_command_complete(SCSIRequest *req, uint32_t status, static void esp_pci_command_complete(SCSIRequest *req, size_t resid)
size_t resid)
{ {
ESPState *s = req->hba_private; ESPState *s = req->hba_private;
PCIESPState *pci = container_of(s, PCIESPState, esp); PCIESPState *pci = container_of(s, PCIESPState, esp);
esp_command_complete(req, status, resid); esp_command_complete(req, resid);
pci->dma_regs[DMA_WBC] = 0; pci->dma_regs[DMA_WBC] = 0;
pci->dma_regs[DMA_STAT] |= DMA_STAT_DONE; pci->dma_regs[DMA_STAT] |= DMA_STAT_DONE;
} }

7
hw/scsi/esp.c
View File

@ -485,8 +485,7 @@ static void esp_report_command_complete(ESPState *s, uint32_t status)
} }
} }
void esp_command_complete(SCSIRequest *req, uint32_t status, void esp_command_complete(SCSIRequest *req, size_t resid)
size_t resid)
{ {
ESPState *s = req->hba_private; ESPState *s = req->hba_private;
@ -495,11 +494,11 @@ void esp_command_complete(SCSIRequest *req, uint32_t status,
* interrupt has been handled. * interrupt has been handled.
*/ */
trace_esp_command_complete_deferred(); trace_esp_command_complete_deferred();
s->deferred_status = status; s->deferred_status = req->status;
s->deferred_complete = true; s->deferred_complete = true;
return; return;
} }
esp_report_command_complete(s, status); esp_report_command_complete(s, req->status);
} }
void esp_transfer_data(SCSIRequest *req, uint32_t len) void esp_transfer_data(SCSIRequest *req, uint32_t len)

6
hw/scsi/lsi53c895a.c
View File

@ -787,14 +787,14 @@ static int lsi_queue_req(LSIState *s, SCSIRequest *req, uint32_t len)
} }
/* Callback to indicate that the SCSI layer has completed a command. */ /* Callback to indicate that the SCSI layer has completed a command. */
static void lsi_command_complete(SCSIRequest *req, uint32_t status, size_t resid) static void lsi_command_complete(SCSIRequest *req, size_t resid)
{ {
LSIState *s = LSI53C895A(req->bus->qbus.parent); LSIState *s = LSI53C895A(req->bus->qbus.parent);
int out; int out;
out = (s->sstat1 & PHASE_MASK) == PHASE_DO; out = (s->sstat1 & PHASE_MASK) == PHASE_DO;
trace_lsi_command_complete(status); trace_lsi_command_complete(req->status);
s->status = status; s->status = req->status;
s->command_complete = 2; s->command_complete = 2;
if (s->waiting && s->dbc != 0) { if (s->waiting && s->dbc != 0) {
/* Raise phase mismatch for short transfers. */ /* Raise phase mismatch for short transfers. */

6
hw/scsi/megasas.c
View File

@ -1852,13 +1852,12 @@ static void megasas_xfer_complete(SCSIRequest *req, uint32_t len)
} }
} }
static void megasas_command_complete(SCSIRequest *req, uint32_t status, static void megasas_command_complete(SCSIRequest *req, size_t resid)
size_t resid)
{ {
MegasasCmd *cmd = req->hba_private; MegasasCmd *cmd = req->hba_private;
uint8_t cmd_status = MFI_STAT_OK; uint8_t cmd_status = MFI_STAT_OK;
trace_megasas_command_complete(cmd->index, status, resid); trace_megasas_command_complete(cmd->index, req->status, resid);
if (req->io_canceled) { if (req->io_canceled) {
return; return;
@ -1873,7 +1872,6 @@ static void megasas_command_complete(SCSIRequest *req, uint32_t status,
return; return;
} }
} else { } else {
req->status = status;
trace_megasas_scsi_complete(cmd->index, req->status, trace_megasas_scsi_complete(cmd->index, req->status,
cmd->iov_size, req->cmd.xfer); cmd->iov_size, req->cmd.xfer);
if (req->status != GOOD) { if (req->status != GOOD) {

5
hw/scsi/mptsas.c
View File

@ -1133,7 +1133,7 @@ static QEMUSGList *mptsas_get_sg_list(SCSIRequest *sreq)
} }
static void mptsas_command_complete(SCSIRequest *sreq, static void mptsas_command_complete(SCSIRequest *sreq,
uint32_t status, size_t resid) size_t resid)
{ {
MPTSASRequest *req = sreq->hba_private; MPTSASRequest *req = sreq->hba_private;
MPTSASState *s = req->dev; MPTSASState *s = req->dev;
@ -1143,7 +1143,8 @@ static void mptsas_command_complete(SCSIRequest *sreq,
hwaddr sense_buffer_addr = req->dev->sense_buffer_high_addr | hwaddr sense_buffer_addr = req->dev->sense_buffer_high_addr |
req->scsi_io.SenseBufferLowAddr; req->scsi_io.SenseBufferLowAddr;
trace_mptsas_command_complete(s, req->scsi_io.MsgContext, status, resid); trace_mptsas_command_complete(s, req->scsi_io.MsgContext,
sreq->status, resid);
sense_len = scsi_req_get_sense(sreq, sense_buf, SCSI_SENSE_BUF_SIZE); sense_len = scsi_req_get_sense(sreq, sense_buf, SCSI_SENSE_BUF_SIZE);
if (sense_len > 0) { if (sense_len > 0) {

2
hw/scsi/scsi-bus.c
View File

@ -1483,7 +1483,7 @@ void scsi_req_complete(SCSIRequest *req, int status)
scsi_req_ref(req); scsi_req_ref(req);
scsi_req_dequeue(req); scsi_req_dequeue(req);
req->bus->info->complete(req, req->status, req->resid); req->bus->info->complete(req, req->resid);
/* Cancelled requests might end up being completed instead of cancelled */ /* Cancelled requests might end up being completed instead of cancelled */
notifier_list_notify(&req->cancel_notifiers, req); notifier_list_notify(&req->cancel_notifiers, req);

12
hw/scsi/spapr_vscsi.c
View File

@ -551,19 +551,19 @@ static void vscsi_transfer_data(SCSIRequest *sreq, uint32_t len)
} }
/* Callback to indicate that the SCSI layer has completed a transfer. */ /* Callback to indicate that the SCSI layer has completed a transfer. */
static void vscsi_command_complete(SCSIRequest *sreq, uint32_t status, size_t resid) static void vscsi_command_complete(SCSIRequest *sreq, size_t resid)
{ {
VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(sreq->bus->qbus.parent); VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(sreq->bus->qbus.parent);
vscsi_req *req = sreq->hba_private; vscsi_req *req = sreq->hba_private;
int32_t res_in = 0, res_out = 0; int32_t res_in = 0, res_out = 0;
trace_spapr_vscsi_command_complete(sreq->tag, status, req); trace_spapr_vscsi_command_complete(sreq->tag, sreq->status, req);
if (req == NULL) { if (req == NULL) {
fprintf(stderr, "VSCSI: Can't find request for tag 0x%x\n", sreq->tag); fprintf(stderr, "VSCSI: Can't find request for tag 0x%x\n", sreq->tag);
return; return;
} }
if (status == CHECK_CONDITION) { if (sreq->status == CHECK_CONDITION) {
req->senselen = scsi_req_get_sense(req->sreq, req->sense, req->senselen = scsi_req_get_sense(req->sreq, req->sense,
sizeof(req->sense)); sizeof(req->sense));
trace_spapr_vscsi_command_complete_sense_data1(req->senselen, trace_spapr_vscsi_command_complete_sense_data1(req->senselen,
@ -574,8 +574,8 @@ static void vscsi_command_complete(SCSIRequest *sreq, uint32_t status, size_t re
req->sense[12], req->sense[13], req->sense[14], req->sense[15]); req->sense[12], req->sense[13], req->sense[14], req->sense[15]);
} }
trace_spapr_vscsi_command_complete_status(status); trace_spapr_vscsi_command_complete_status(sreq->status);
if (status == 0) { if (sreq->status == 0) {
/* We handle overflows, not underflows for normal commands, /* We handle overflows, not underflows for normal commands,
* but hopefully nobody cares * but hopefully nobody cares
*/ */
@ -585,7 +585,7 @@ static void vscsi_command_complete(SCSIRequest *sreq, uint32_t status, size_t re
res_in = req->data_len; res_in = req->data_len;
} }
} }
vscsi_send_rsp(s, req, status, res_in, res_out); vscsi_send_rsp(s, req, sreq->status, res_in, res_out);
vscsi_put_req(req); vscsi_put_req(req);
} }

5
hw/scsi/virtio-scsi.c
View File

@ -500,8 +500,7 @@ static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq *req)
virtio_scsi_complete_req(req); virtio_scsi_complete_req(req);
} }
static void virtio_scsi_command_complete(SCSIRequest *r, uint32_t status, static void virtio_scsi_command_complete(SCSIRequest *r, size_t resid)
size_t resid)
{ {
VirtIOSCSIReq *req = r->hba_private; VirtIOSCSIReq *req = r->hba_private;
uint8_t sense[SCSI_SENSE_BUF_SIZE]; uint8_t sense[SCSI_SENSE_BUF_SIZE];
@ -513,7 +512,7 @@ static void virtio_scsi_command_complete(SCSIRequest *r, uint32_t status,
} }
req->resp.cmd.response = VIRTIO_SCSI_S_OK; req->resp.cmd.response = VIRTIO_SCSI_S_OK;
req->resp.cmd.status = status; req->resp.cmd.status = r->status;
if (req->resp.cmd.status == GOOD) { if (req->resp.cmd.status == GOOD) {
req->resp.cmd.resid = virtio_tswap32(vdev, resid); req->resp.cmd.resid = virtio_tswap32(vdev, resid);
} else { } else {

4
hw/scsi/vmw_pvscsi.c
View File

@ -511,7 +511,7 @@ pvscsi_write_sense(PVSCSIRequest *r, uint8_t *sense, int len)
} }
static void static void
pvscsi_command_complete(SCSIRequest *req, uint32_t status, size_t resid) pvscsi_command_complete(SCSIRequest *req, size_t resid)
{ {
PVSCSIRequest *pvscsi_req = req->hba_private; PVSCSIRequest *pvscsi_req = req->hba_private;
PVSCSIState *s; PVSCSIState *s;
@ -528,7 +528,7 @@ pvscsi_command_complete(SCSIRequest *req, uint32_t status, size_t resid)
pvscsi_req->cmp.hostStatus = BTSTAT_DATARUN; pvscsi_req->cmp.hostStatus = BTSTAT_DATARUN;
} }
pvscsi_req->cmp.scsiStatus = status; pvscsi_req->cmp.scsiStatus = req->status;
if (pvscsi_req->cmp.scsiStatus == CHECK_CONDITION) { if (pvscsi_req->cmp.scsiStatus == CHECK_CONDITION) {
uint8_t sense[SCSI_SENSE_BUF_SIZE]; uint8_t sense[SCSI_SENSE_BUF_SIZE];
int sense_len = int sense_len =

6
hw/usb/dev-storage.c
View File

@ -277,17 +277,17 @@ static void usb_msd_transfer_data(SCSIRequest *req, uint32_t len)
} }
} }
static void usb_msd_command_complete(SCSIRequest *req, uint32_t status, size_t resid) static void usb_msd_command_complete(SCSIRequest *req, size_t resid)
{ {
MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent); MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
USBPacket *p = s->packet; USBPacket *p = s->packet;
trace_usb_msd_cmd_complete(status, req->tag); trace_usb_msd_cmd_complete(req->status, req->tag);
s->csw.sig = cpu_to_le32(0x53425355); s->csw.sig = cpu_to_le32(0x53425355);
s->csw.tag = cpu_to_le32(req->tag); s->csw.tag = cpu_to_le32(req->tag);
s->csw.residue = cpu_to_le32(s->data_len); s->csw.residue = cpu_to_le32(s->data_len);
s->csw.status = status != 0; s->csw.status = req->status != 0;
if (s->packet) { if (s->packet) {
if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) { if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) {

7
hw/usb/dev-uas.c
View File

@ -598,17 +598,16 @@ static void usb_uas_scsi_transfer_data(SCSIRequest *r, uint32_t len)
} }
} }
static void usb_uas_scsi_command_complete(SCSIRequest *r, static void usb_uas_scsi_command_complete(SCSIRequest *r, size_t resid)
uint32_t status, size_t resid)
{ {
UASRequest *req = r->hba_private; UASRequest *req = r->hba_private;
trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, status, resid); trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, r->status, resid);
req->complete = true; req->complete = true;
if (req->data) { if (req->data) {
usb_uas_complete_data_packet(req); usb_uas_complete_data_packet(req);
} }
usb_uas_queue_sense(req, status); usb_uas_queue_sense(req, r->status);
scsi_req_unref(req->req); scsi_req_unref(req->req);
} }

2
include/hw/scsi/esp.h
View File

@ -151,7 +151,7 @@ struct SysBusESPState {
void esp_dma_enable(ESPState *s, int irq, int level); void esp_dma_enable(ESPState *s, int irq, int level);
void esp_request_cancelled(SCSIRequest *req); void esp_request_cancelled(SCSIRequest *req);
void esp_command_complete(SCSIRequest *req, uint32_t status, size_t resid); void esp_command_complete(SCSIRequest *req, size_t resid);
void esp_transfer_data(SCSIRequest *req, uint32_t len); void esp_transfer_data(SCSIRequest *req, uint32_t len);
void esp_hard_reset(ESPState *s); void esp_hard_reset(ESPState *s);
uint64_t esp_reg_read(ESPState *s, uint32_t saddr); uint64_t esp_reg_read(ESPState *s, uint32_t saddr);

2
include/hw/scsi/scsi.h
View File

@ -123,7 +123,7 @@ struct SCSIBusInfo {
int (*parse_cdb)(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf, int (*parse_cdb)(SCSIDevice *dev, SCSICommand *cmd, uint8_t *buf,
void *hba_private); void *hba_private);
void (*transfer_data)(SCSIRequest *req, uint32_t arg); void (*transfer_data)(SCSIRequest *req, uint32_t arg);
void (*complete)(SCSIRequest *req, uint32_t arg, size_t resid); void (*complete)(SCSIRequest *req, size_t resid);
void (*cancel)(SCSIRequest *req); void (*cancel)(SCSIRequest *req);
void (*change)(SCSIBus *bus, SCSIDevice *dev, SCSISense sense); void (*change)(SCSIBus *bus, SCSIDevice *dev, SCSISense sense);
QEMUSGList *(*get_sg_list)(SCSIRequest *req); QEMUSGList *(*get_sg_list)(SCSIRequest *req);