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