Revision 94d3f98a
b/hw/esp.c | ||
---|---|---|
188 | 188 |
} |
189 | 189 |
} |
190 | 190 |
|
191 |
static void esp_request_cancelled(SCSIRequest *req) |
|
192 |
{ |
|
193 |
ESPState *s = DO_UPCAST(ESPState, busdev.qdev, req->bus->qbus.parent); |
|
194 |
|
|
195 |
if (req == s->current_req) { |
|
196 |
scsi_req_unref(s->current_req); |
|
197 |
s->current_req = NULL; |
|
198 |
s->current_dev = NULL; |
|
199 |
} |
|
200 |
} |
|
201 |
|
|
191 | 202 |
static uint32_t get_cmd(ESPState *s, uint8_t *buf) |
192 | 203 |
{ |
193 | 204 |
uint32_t dmalen; |
... | ... | |
210 | 221 |
|
211 | 222 |
if (s->current_dev) { |
212 | 223 |
/* Started a new command before the old one finished. Cancel it. */ |
213 |
s->current_dev->info->cancel_io(s->current_req);
|
|
224 |
scsi_req_cancel(s->current_req);
|
|
214 | 225 |
s->async_len = 0; |
215 | 226 |
} |
216 | 227 |
|
... | ... | |
720 | 731 |
} |
721 | 732 |
|
722 | 733 |
static const struct SCSIBusOps esp_scsi_ops = { |
723 |
.complete = esp_command_complete |
|
734 |
.complete = esp_command_complete, |
|
735 |
.cancel = esp_request_cancelled |
|
724 | 736 |
}; |
725 | 737 |
|
726 | 738 |
static int esp_init1(SysBusDevice *dev) |
b/hw/lsi53c895a.c | ||
---|---|---|
664 | 664 |
return NULL; |
665 | 665 |
} |
666 | 666 |
|
667 |
static void lsi_request_cancelled(SCSIRequest *req) |
|
668 |
{ |
|
669 |
LSIState *s = DO_UPCAST(LSIState, dev.qdev, req->bus->qbus.parent); |
|
670 |
lsi_request *p; |
|
671 |
|
|
672 |
if (s->current && req == s->current->req) { |
|
673 |
scsi_req_unref(req); |
|
674 |
qemu_free(s->current); |
|
675 |
s->current = NULL; |
|
676 |
return; |
|
677 |
} |
|
678 |
|
|
679 |
p = lsi_find_by_tag(s, req->tag); |
|
680 |
if (p) { |
|
681 |
QTAILQ_REMOVE(&s->queue, p, next); |
|
682 |
scsi_req_unref(req); |
|
683 |
qemu_free(p); |
|
684 |
} |
|
685 |
} |
|
686 |
|
|
667 | 687 |
/* Record that data is available for a queued command. Returns zero if |
668 | 688 |
the device was reselected, nonzero if the IO is deferred. */ |
669 | 689 |
static int lsi_queue_tag(LSIState *s, uint32_t tag, uint32_t arg) |
... | ... | |
931 | 951 |
/* The ABORT TAG message clears the current I/O process only. */ |
932 | 952 |
DPRINTF("MSG: ABORT TAG tag=0x%x\n", current_tag); |
933 | 953 |
if (current_req) { |
934 |
current_dev->info->cancel_io(current_req->req);
|
|
954 |
scsi_req_cancel(current_req->req);
|
|
935 | 955 |
} |
936 | 956 |
lsi_disconnect(s); |
937 | 957 |
break; |
... | ... | |
956 | 976 |
|
957 | 977 |
/* clear the current I/O process */ |
958 | 978 |
if (s->current) { |
959 |
current_dev->info->cancel_io(s->current->req);
|
|
979 |
scsi_req_cancel(s->current->req);
|
|
960 | 980 |
} |
961 | 981 |
|
962 | 982 |
/* As the current implemented devices scsi_disk and scsi_generic |
... | ... | |
969 | 989 |
id = current_tag & 0x0000ff00; |
970 | 990 |
QTAILQ_FOREACH_SAFE(p, &s->queue, next, p_next) { |
971 | 991 |
if ((p->tag & 0x0000ff00) == id) { |
972 |
current_dev->info->cancel_io(p->req); |
|
973 |
QTAILQ_REMOVE(&s->queue, p, next); |
|
992 |
scsi_req_cancel(p->req); |
|
974 | 993 |
} |
975 | 994 |
} |
976 | 995 |
|
... | ... | |
2227 | 2246 |
} |
2228 | 2247 |
|
2229 | 2248 |
static const struct SCSIBusOps lsi_scsi_ops = { |
2230 |
.complete = lsi_command_complete |
|
2249 |
.complete = lsi_command_complete, |
|
2250 |
.cancel = lsi_request_cancelled |
|
2231 | 2251 |
}; |
2232 | 2252 |
|
2233 | 2253 |
static int lsi_scsi_init(PCIDevice *dev) |
b/hw/scsi-bus.c | ||
---|---|---|
549 | 549 |
scsi_req_unref(req); |
550 | 550 |
} |
551 | 551 |
|
552 |
void scsi_req_cancel(SCSIRequest *req) |
|
553 |
{ |
|
554 |
if (req->dev && req->dev->info->cancel_io) { |
|
555 |
req->dev->info->cancel_io(req); |
|
556 |
} |
|
557 |
scsi_req_ref(req); |
|
558 |
scsi_req_dequeue(req); |
|
559 |
if (req->bus->ops->cancel) { |
|
560 |
req->bus->ops->cancel(req); |
|
561 |
} |
|
562 |
scsi_req_unref(req); |
|
563 |
} |
|
564 |
|
|
552 | 565 |
void scsi_req_abort(SCSIRequest *req, int status) |
553 | 566 |
{ |
554 | 567 |
req->status = status; |
... | ... | |
564 | 577 |
|
565 | 578 |
while (!QTAILQ_EMPTY(&sdev->requests)) { |
566 | 579 |
req = QTAILQ_FIRST(&sdev->requests); |
567 |
sdev->info->cancel_io(req); |
|
568 |
scsi_req_dequeue(req); |
|
569 |
scsi_req_unref(req); |
|
580 |
scsi_req_cancel(req); |
|
570 | 581 |
} |
571 | 582 |
} |
572 | 583 |
|
b/hw/scsi-disk.c | ||
---|---|---|
143 | 143 |
bdrv_aio_cancel(r->req.aiocb); |
144 | 144 |
} |
145 | 145 |
r->req.aiocb = NULL; |
146 |
scsi_req_dequeue(&r->req); |
|
147 | 146 |
} |
148 | 147 |
|
149 | 148 |
static void scsi_read_complete(void * opaque, int ret) |
b/hw/scsi-generic.c | ||
---|---|---|
121 | 121 |
bdrv_aio_cancel(r->req.aiocb); |
122 | 122 |
} |
123 | 123 |
r->req.aiocb = NULL; |
124 |
scsi_req_dequeue(&r->req); |
|
125 | 124 |
} |
126 | 125 |
|
127 | 126 |
static int execute_command(BlockDriverState *bdrv, |
b/hw/scsi.h | ||
---|---|---|
78 | 78 |
|
79 | 79 |
struct SCSIBusOps { |
80 | 80 |
void (*complete)(SCSIRequest *req, int reason, uint32_t arg); |
81 |
void (*cancel)(SCSIRequest *req); |
|
81 | 82 |
}; |
82 | 83 |
|
83 | 84 |
struct SCSIBus { |
... | ... | |
115 | 116 |
void scsi_req_data(SCSIRequest *req, int len); |
116 | 117 |
void scsi_req_complete(SCSIRequest *req); |
117 | 118 |
void scsi_req_abort(SCSIRequest *req, int status); |
119 |
void scsi_req_cancel(SCSIRequest *req); |
|
118 | 120 |
void scsi_device_purge_requests(SCSIDevice *sdev); |
119 | 121 |
|
120 | 122 |
#endif |
b/hw/spapr_vscsi.c | ||
---|---|---|
559 | 559 |
} |
560 | 560 |
} |
561 | 561 |
|
562 |
static void vscsi_request_cancelled(SCSIRequest *sreq) |
|
563 |
{ |
|
564 |
VSCSIState *s = DO_UPCAST(VSCSIState, vdev.qdev, sreq->bus->qbus.parent); |
|
565 |
vscsi_req *req = vscsi_find_req(s, sreq); |
|
566 |
|
|
567 |
vscsi_put_req(s, req); |
|
568 |
} |
|
569 |
|
|
562 | 570 |
static void vscsi_process_login(VSCSIState *s, vscsi_req *req) |
563 | 571 |
{ |
564 | 572 |
union viosrp_iu *iu = &req->iu; |
... | ... | |
910 | 918 |
} |
911 | 919 |
|
912 | 920 |
static const struct SCSIBusOps vscsi_scsi_ops = { |
913 |
.complete = vscsi_command_complete |
|
921 |
.complete = vscsi_command_complete, |
|
922 |
.cancel = vscsi_request_cancelled |
|
914 | 923 |
}; |
915 | 924 |
|
916 | 925 |
static int spapr_vscsi_init(VIOsPAPRDevice *dev) |
b/hw/usb-msd.c | ||
---|---|---|
264 | 264 |
} |
265 | 265 |
} |
266 | 266 |
|
267 |
static void usb_msd_request_cancelled(SCSIRequest *req) |
|
268 |
{ |
|
269 |
MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent); |
|
270 |
|
|
271 |
if (req == s->req) { |
|
272 |
scsi_req_unref(s->req); |
|
273 |
s->req = NULL; |
|
274 |
s->packet = NULL; |
|
275 |
s->scsi_len = 0; |
|
276 |
} |
|
277 |
} |
|
278 |
|
|
267 | 279 |
static void usb_msd_handle_reset(USBDevice *dev) |
268 | 280 |
{ |
269 | 281 |
MSDState *s = (MSDState *)dev; |
... | ... | |
318 | 330 |
static void usb_msd_cancel_io(USBPacket *p, void *opaque) |
319 | 331 |
{ |
320 | 332 |
MSDState *s = opaque; |
321 |
s->scsi_dev->info->cancel_io(s->req); |
|
322 |
s->packet = NULL; |
|
323 |
s->scsi_len = 0; |
|
333 |
scsi_req_cancel(s->req); |
|
324 | 334 |
} |
325 | 335 |
|
326 | 336 |
static int usb_msd_handle_data(USBDevice *dev, USBPacket *p) |
... | ... | |
491 | 501 |
} |
492 | 502 |
|
493 | 503 |
static const struct SCSIBusOps usb_msd_scsi_ops = { |
494 |
.complete = usb_msd_command_complete |
|
504 |
.complete = usb_msd_command_complete, |
|
505 |
.cancel = usb_msd_request_cancelled |
|
495 | 506 |
}; |
496 | 507 |
|
497 | 508 |
static int usb_msd_initfn(USBDevice *dev) |
Also available in: Unified diff