← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/CVE-2013-4377.patch/hw/block/dataplane/virtio-blk.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/CVE-2013-4377.patch/hw/block/dataplane/virtio-blk.c
1
 
/*
2
 
 * Dedicated thread for virtio-blk I/O processing
3
 
 *
4
 
 * Copyright 2012 IBM, Corp.
5
 
 * Copyright 2012 Red Hat, Inc. and/or its affiliates
6
 
 *
7
 
 * Authors:
8
 
 *   Stefan Hajnoczi <stefanha@redhat.com>
9
 
 *
10
 
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11
 
 * See the COPYING file in the top-level directory.
12
 
 *
13
 
 */
14
 
 
15
 
#include "trace.h"
16
 
#include "qemu/iov.h"
17
 
#include "qemu/thread.h"
18
 
#include "qemu/error-report.h"
19
 
#include "hw/virtio/dataplane/vring.h"
20
 
#include "ioq.h"
21
 
#include "block/block.h"
22
 
#include "hw/virtio/virtio-blk.h"
23
 
#include "virtio-blk.h"
24
 
#include "block/aio.h"
25
 
#include "hw/virtio/virtio-bus.h"
26
 
 
27
 
enum {
28
 
    SEG_MAX = 126,                  /* maximum number of I/O segments */
29
 
    VRING_MAX = SEG_MAX + 2,        /* maximum number of vring descriptors */
30
 
    REQ_MAX = VRING_MAX,            /* maximum number of requests in the vring,
31
 
                                     * is VRING_MAX / 2 with traditional and
32
 
                                     * VRING_MAX with indirect descriptors */
33
 
};
34
 
 
35
 
typedef struct {
36
 
    struct iocb iocb;               /* Linux AIO control block */
37
 
    QEMUIOVector *inhdr;            /* iovecs for virtio_blk_inhdr */
38
 
    unsigned int head;              /* vring descriptor index */
39
 
    struct iovec *bounce_iov;       /* used if guest buffers are unaligned */
40
 
    QEMUIOVector *read_qiov;        /* for read completion /w bounce buffer */
41
 
} VirtIOBlockRequest;
42
 
 
43
 
struct VirtIOBlockDataPlane {
44
 
    bool started;
45
 
    bool starting;
46
 
    bool stopping;
47
 
    QEMUBH *start_bh;
48
 
    QemuThread thread;
49
 
 
50
 
    VirtIOBlkConf *blk;
51
 
    int fd;                         /* image file descriptor */
52
 
 
53
 
    VirtIODevice *vdev;
54
 
    Vring vring;                    /* virtqueue vring */
55
 
    EventNotifier *guest_notifier;  /* irq */
56
 
 
57
 
    /* Note that these EventNotifiers are assigned by value.  This is
58
 
     * fine as long as you do not call event_notifier_cleanup on them
59
 
     * (because you don't own the file descriptor or handle; you just
60
 
     * use it).
61
 
     */
62
 
    AioContext *ctx;
63
 
    EventNotifier io_notifier;      /* Linux AIO completion */
64
 
    EventNotifier host_notifier;    /* doorbell */
65
 
 
66
 
    IOQueue ioqueue;                /* Linux AIO queue (should really be per
67
 
                                       dataplane thread) */
68
 
    VirtIOBlockRequest requests[REQ_MAX]; /* pool of requests, managed by the
69
 
                                             queue */
70
 
 
71
 
    unsigned int num_reqs;
72
 
};
73
 
 
74
 
/* Raise an interrupt to signal guest, if necessary */
75
 
static void notify_guest(VirtIOBlockDataPlane *s)
76
 
{
77
 
    if (!vring_should_notify(s->vdev, &s->vring)) {
78
 
        return;
79
 
    }
80
 
 
81
 
    event_notifier_set(s->guest_notifier);
82
 
}
83
 
 
84
 
static void complete_request(struct iocb *iocb, ssize_t ret, void *opaque)
85
 
{
86
 
    VirtIOBlockDataPlane *s = opaque;
87
 
    VirtIOBlockRequest *req = container_of(iocb, VirtIOBlockRequest, iocb);
88
 
    struct virtio_blk_inhdr hdr;
89
 
    int len;
90
 
 
91
 
    if (likely(ret >= 0)) {
92
 
        hdr.status = VIRTIO_BLK_S_OK;
93
 
        len = ret;
94
 
    } else {
95
 
        hdr.status = VIRTIO_BLK_S_IOERR;
96
 
        len = 0;
97
 
    }
98
 
 
99
 
    trace_virtio_blk_data_plane_complete_request(s, req->head, ret);
100
 
 
101
 
    if (req->read_qiov) {
102
 
        assert(req->bounce_iov);
103
 
        qemu_iovec_from_buf(req->read_qiov, 0, req->bounce_iov->iov_base, len);
104
 
        qemu_iovec_destroy(req->read_qiov);
105
 
        g_slice_free(QEMUIOVector, req->read_qiov);
106
 
    }
107
 
 
108
 
    if (req->bounce_iov) {
109
 
        qemu_vfree(req->bounce_iov->iov_base);
110
 
        g_slice_free(struct iovec, req->bounce_iov);
111
 
    }
112
 
 
113
 
    qemu_iovec_from_buf(req->inhdr, 0, &hdr, sizeof(hdr));
114
 
    qemu_iovec_destroy(req->inhdr);
115
 
    g_slice_free(QEMUIOVector, req->inhdr);
116
 
 
117
 
    /* According to the virtio specification len should be the number of bytes
118
 
     * written to, but for virtio-blk it seems to be the number of bytes
119
 
     * transferred plus the status bytes.
120
 
     */
121
 
    vring_push(&s->vring, req->head, len + sizeof(hdr));
122
 
 
123
 
    s->num_reqs--;
124
 
}
125
 
 
126
 
static void complete_request_early(VirtIOBlockDataPlane *s, unsigned int head,
127
 
                                   QEMUIOVector *inhdr, unsigned char status)
128
 
{
129
 
    struct virtio_blk_inhdr hdr = {
130
 
        .status = status,
131
 
    };
132
 
 
133
 
    qemu_iovec_from_buf(inhdr, 0, &hdr, sizeof(hdr));
134
 
    qemu_iovec_destroy(inhdr);
135
 
    g_slice_free(QEMUIOVector, inhdr);
136
 
 
137
 
    vring_push(&s->vring, head, sizeof(hdr));
138
 
    notify_guest(s);
139
 
}
140
 
 
141
 
/* Get disk serial number */
142
 
static void do_get_id_cmd(VirtIOBlockDataPlane *s,
143
 
                          struct iovec *iov, unsigned int iov_cnt,
144
 
                          unsigned int head, QEMUIOVector *inhdr)
145
 
{
146
 
    char id[VIRTIO_BLK_ID_BYTES];
147
 
 
148
 
    /* Serial number not NUL-terminated when shorter than buffer */
149
 
    strncpy(id, s->blk->serial ? s->blk->serial : "", sizeof(id));
150
 
    iov_from_buf(iov, iov_cnt, 0, id, sizeof(id));
151
 
    complete_request_early(s, head, inhdr, VIRTIO_BLK_S_OK);
152
 
}
153
 
 
154
 
static int do_rdwr_cmd(VirtIOBlockDataPlane *s, bool read,
155
 
                       struct iovec *iov, unsigned int iov_cnt,
156
 
                       long long offset, unsigned int head,
157
 
                       QEMUIOVector *inhdr)
158
 
{
159
 
    struct iocb *iocb;
160
 
    QEMUIOVector qiov;
161
 
    struct iovec *bounce_iov = NULL;
162
 
    QEMUIOVector *read_qiov = NULL;
163
 
 
164
 
    qemu_iovec_init_external(&qiov, iov, iov_cnt);
165
 
    if (!bdrv_qiov_is_aligned(s->blk->conf.bs, &qiov)) {
166
 
        void *bounce_buffer = qemu_blockalign(s->blk->conf.bs, qiov.size);
167
 
 
168
 
        if (read) {
169
 
            /* Need to copy back from bounce buffer on completion */
170
 
            read_qiov = g_slice_new(QEMUIOVector);
171
 
            qemu_iovec_init(read_qiov, iov_cnt);
172
 
            qemu_iovec_concat_iov(read_qiov, iov, iov_cnt, 0, qiov.size);
173
 
        } else {
174
 
            qemu_iovec_to_buf(&qiov, 0, bounce_buffer, qiov.size);
175
 
        }
176
 
 
177
 
        /* Redirect I/O to aligned bounce buffer */
178
 
        bounce_iov = g_slice_new(struct iovec);
179
 
        bounce_iov->iov_base = bounce_buffer;
180
 
        bounce_iov->iov_len = qiov.size;
181
 
        iov = bounce_iov;
182
 
        iov_cnt = 1;
183
 
    }
184
 
 
185
 
    iocb = ioq_rdwr(&s->ioqueue, read, iov, iov_cnt, offset);
186
 
 
187
 
    /* Fill in virtio block metadata needed for completion */
188
 
    VirtIOBlockRequest *req = container_of(iocb, VirtIOBlockRequest, iocb);
189
 
    req->head = head;
190
 
    req->inhdr = inhdr;
191
 
    req->bounce_iov = bounce_iov;
192
 
    req->read_qiov = read_qiov;
193
 
    return 0;
194
 
}
195
 
 
196
 
static int process_request(IOQueue *ioq, struct iovec iov[],
197
 
                           unsigned int out_num, unsigned int in_num,
198
 
                           unsigned int head)
199
 
{
200
 
    VirtIOBlockDataPlane *s = container_of(ioq, VirtIOBlockDataPlane, ioqueue);
201
 
    struct iovec *in_iov = &iov[out_num];
202
 
    struct virtio_blk_outhdr outhdr;
203
 
    QEMUIOVector *inhdr;
204
 
    size_t in_size;
205
 
 
206
 
    /* Copy in outhdr */
207
 
    if (unlikely(iov_to_buf(iov, out_num, 0, &outhdr,
208
 
                            sizeof(outhdr)) != sizeof(outhdr))) {
209
 
        error_report("virtio-blk request outhdr too short");
210
 
        return -EFAULT;
211
 
    }
212
 
    iov_discard_front(&iov, &out_num, sizeof(outhdr));
213
 
 
214
 
    /* Grab inhdr for later */
215
 
    in_size = iov_size(in_iov, in_num);
216
 
    if (in_size < sizeof(struct virtio_blk_inhdr)) {
217
 
        error_report("virtio_blk request inhdr too short");
218
 
        return -EFAULT;
219
 
    }
220
 
    inhdr = g_slice_new(QEMUIOVector);
221
 
    qemu_iovec_init(inhdr, 1);
222
 
    qemu_iovec_concat_iov(inhdr, in_iov, in_num,
223
 
            in_size - sizeof(struct virtio_blk_inhdr),
224
 
            sizeof(struct virtio_blk_inhdr));
225
 
    iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
226
 
 
227
 
    /* TODO Linux sets the barrier bit even when not advertised! */
228
 
    outhdr.type &= ~VIRTIO_BLK_T_BARRIER;
229
 
 
230
 
    switch (outhdr.type) {
231
 
    case VIRTIO_BLK_T_IN:
232
 
        do_rdwr_cmd(s, true, in_iov, in_num, outhdr.sector * 512, head, inhdr);
233
 
        return 0;
234
 
 
235
 
    case VIRTIO_BLK_T_OUT:
236
 
        do_rdwr_cmd(s, false, iov, out_num, outhdr.sector * 512, head, inhdr);
237
 
        return 0;
238
 
 
239
 
    case VIRTIO_BLK_T_SCSI_CMD:
240
 
        /* TODO support SCSI commands */
241
 
        complete_request_early(s, head, inhdr, VIRTIO_BLK_S_UNSUPP);
242
 
        return 0;
243
 
 
244
 
    case VIRTIO_BLK_T_FLUSH:
245
 
        /* TODO fdsync not supported by Linux AIO, do it synchronously here! */
246
 
        if (qemu_fdatasync(s->fd) < 0) {
247
 
            complete_request_early(s, head, inhdr, VIRTIO_BLK_S_IOERR);
248
 
        } else {
249
 
            complete_request_early(s, head, inhdr, VIRTIO_BLK_S_OK);
250
 
        }
251
 
        return 0;
252
 
 
253
 
    case VIRTIO_BLK_T_GET_ID:
254
 
        do_get_id_cmd(s, in_iov, in_num, head, inhdr);
255
 
        return 0;
256
 
 
257
 
    default:
258
 
        error_report("virtio-blk unsupported request type %#x", outhdr.type);
259
 
        qemu_iovec_destroy(inhdr);
260
 
        g_slice_free(QEMUIOVector, inhdr);
261
 
        return -EFAULT;
262
 
    }
263
 
}
264
 
 
265
 
static void handle_notify(EventNotifier *e)
266
 
{
267
 
    VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
268
 
                                           host_notifier);
269
 
 
270
 
    /* There is one array of iovecs into which all new requests are extracted
271
 
     * from the vring.  Requests are read from the vring and the translated
272
 
     * descriptors are written to the iovecs array.  The iovecs do not have to
273
 
     * persist across handle_notify() calls because the kernel copies the
274
 
     * iovecs on io_submit().
275
 
     *
276
 
     * Handling io_submit() EAGAIN may require storing the requests across
277
 
     * handle_notify() calls until the kernel has sufficient resources to
278
 
     * accept more I/O.  This is not implemented yet.
279
 
     */
280
 
    struct iovec iovec[VRING_MAX];
281
 
    struct iovec *end = &iovec[VRING_MAX];
282
 
    struct iovec *iov = iovec;
283
 
 
284
 
    /* When a request is read from the vring, the index of the first descriptor
285
 
     * (aka head) is returned so that the completed request can be pushed onto
286
 
     * the vring later.
287
 
     *
288
 
     * The number of hypervisor read-only iovecs is out_num.  The number of
289
 
     * hypervisor write-only iovecs is in_num.
290
 
     */
291
 
    int head;
292
 
    unsigned int out_num = 0, in_num = 0;
293
 
    unsigned int num_queued;
294
 
 
295
 
    event_notifier_test_and_clear(&s->host_notifier);
296
 
    for (;;) {
297
 
        /* Disable guest->host notifies to avoid unnecessary vmexits */
298
 
        vring_disable_notification(s->vdev, &s->vring);
299
 
 
300
 
        for (;;) {
301
 
            head = vring_pop(s->vdev, &s->vring, iov, end, &out_num, &in_num);
302
 
            if (head < 0) {
303
 
                break; /* no more requests */
304
 
            }
305
 
 
306
 
            trace_virtio_blk_data_plane_process_request(s, out_num, in_num,
307
 
                                                        head);
308
 
 
309
 
            if (process_request(&s->ioqueue, iov, out_num, in_num, head) < 0) {
310
 
                vring_set_broken(&s->vring);
311
 
                break;
312
 
            }
313
 
            iov += out_num + in_num;
314
 
        }
315
 
 
316
 
        if (likely(head == -EAGAIN)) { /* vring emptied */
317
 
            /* Re-enable guest->host notifies and stop processing the vring.
318
 
             * But if the guest has snuck in more descriptors, keep processing.
319
 
             */
320
 
            if (vring_enable_notification(s->vdev, &s->vring)) {
321
 
                break;
322
 
            }
323
 
        } else { /* head == -ENOBUFS or fatal error, iovecs[] is depleted */
324
 
            /* Since there are no iovecs[] left, stop processing for now.  Do
325
 
             * not re-enable guest->host notifies since the I/O completion
326
 
             * handler knows to check for more vring descriptors anyway.
327
 
             */
328
 
            break;
329
 
        }
330
 
    }
331
 
 
332
 
    num_queued = ioq_num_queued(&s->ioqueue);
333
 
    if (num_queued > 0) {
334
 
        s->num_reqs += num_queued;
335
 
 
336
 
        int rc = ioq_submit(&s->ioqueue);
337
 
        if (unlikely(rc < 0)) {
338
 
            fprintf(stderr, "ioq_submit failed %d\n", rc);
339
 
            exit(1);
340
 
        }
341
 
    }
342
 
}
343
 
 
344
 
static void handle_io(EventNotifier *e)
345
 
{
346
 
    VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
347
 
                                           io_notifier);
348
 
 
349
 
    event_notifier_test_and_clear(&s->io_notifier);
350
 
    if (ioq_run_completion(&s->ioqueue, complete_request, s) > 0) {
351
 
        notify_guest(s);
352
 
    }
353
 
 
354
 
    /* If there were more requests than iovecs, the vring will not be empty yet
355
 
     * so check again.  There should now be enough resources to process more
356
 
     * requests.
357
 
     */
358
 
    if (unlikely(vring_more_avail(&s->vring))) {
359
 
        handle_notify(&s->host_notifier);
360
 
    }
361
 
}
362
 
 
363
 
static void *data_plane_thread(void *opaque)
364
 
{
365
 
    VirtIOBlockDataPlane *s = opaque;
366
 
 
367
 
    while (!s->stopping || s->num_reqs > 0) {
368
 
        aio_poll(s->ctx, true);
369
 
    }
370
 
    return NULL;
371
 
}
372
 
 
373
 
static void start_data_plane_bh(void *opaque)
374
 
{
375
 
    VirtIOBlockDataPlane *s = opaque;
376
 
 
377
 
    qemu_bh_delete(s->start_bh);
378
 
    s->start_bh = NULL;
379
 
    qemu_thread_create(&s->thread, data_plane_thread,
380
 
                       s, QEMU_THREAD_JOINABLE);
381
 
}
382
 
 
383
 
bool virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
384
 
                                  VirtIOBlockDataPlane **dataplane)
385
 
{
386
 
    VirtIOBlockDataPlane *s;
387
 
    int fd;
388
 
 
389
 
    *dataplane = NULL;
390
 
 
391
 
    if (!blk->data_plane) {
392
 
        return true;
393
 
    }
394
 
 
395
 
    if (blk->scsi) {
396
 
        error_report("device is incompatible with x-data-plane, use scsi=off");
397
 
        return false;
398
 
    }
399
 
 
400
 
    if (blk->config_wce) {
401
 
        error_report("device is incompatible with x-data-plane, "
402
 
                     "use config-wce=off");
403
 
        return false;
404
 
    }
405
 
 
406
 
    /* If dataplane is (re-)enabled while the guest is running there could be
407
 
     * block jobs that can conflict.
408
 
     */
409
 
    if (bdrv_in_use(blk->conf.bs)) {
410
 
        error_report("cannot start dataplane thread while device is in use");
411
 
        return false;
412
 
    }
413
 
 
414
 
    fd = raw_get_aio_fd(blk->conf.bs);
415
 
    if (fd < 0) {
416
 
        error_report("drive is incompatible with x-data-plane, "
417
 
                     "use format=raw,cache=none,aio=native");
418
 
        return false;
419
 
    }
420
 
 
421
 
    s = g_new0(VirtIOBlockDataPlane, 1);
422
 
    s->vdev = vdev;
423
 
    s->fd = fd;
424
 
    s->blk = blk;
425
 
 
426
 
    /* Prevent block operations that conflict with data plane thread */
427
 
    bdrv_set_in_use(blk->conf.bs, 1);
428
 
 
429
 
    *dataplane = s;
430
 
    return true;
431
 
}
432
 
 
433
 
void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
434
 
{
435
 
    if (!s) {
436
 
        return;
437
 
    }
438
 
 
439
 
    virtio_blk_data_plane_stop(s);
440
 
    bdrv_set_in_use(s->blk->conf.bs, 0);
441
 
    g_free(s);
442
 
}
443
 
 
444
 
void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
445
 
{
446
 
    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
447
 
    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
448
 
    VirtQueue *vq;
449
 
    int i;
450
 
 
451
 
    if (s->started) {
452
 
        return;
453
 
    }
454
 
 
455
 
    if (s->starting) {
456
 
        return;
457
 
    }
458
 
 
459
 
    s->starting = true;
460
 
 
461
 
    vq = virtio_get_queue(s->vdev, 0);
462
 
    if (!vring_setup(&s->vring, s->vdev, 0)) {
463
 
        s->starting = false;
464
 
        return;
465
 
    }
466
 
 
467
 
    s->ctx = aio_context_new();
468
 
 
469
 
    /* Set up guest notifier (irq) */
470
 
    if (k->set_guest_notifiers(qbus->parent, 1, true) != 0) {
471
 
        fprintf(stderr, "virtio-blk failed to set guest notifier, "
472
 
                "ensure -enable-kvm is set\n");
473
 
        exit(1);
474
 
    }
475
 
    s->guest_notifier = virtio_queue_get_guest_notifier(vq);
476
 
 
477
 
    /* Set up virtqueue notify */
478
 
    if (k->set_host_notifier(qbus->parent, 0, true) != 0) {
479
 
        fprintf(stderr, "virtio-blk failed to set host notifier\n");
480
 
        exit(1);
481
 
    }
482
 
    s->host_notifier = *virtio_queue_get_host_notifier(vq);
483
 
    aio_set_event_notifier(s->ctx, &s->host_notifier, handle_notify);
484
 
 
485
 
    /* Set up ioqueue */
486
 
    ioq_init(&s->ioqueue, s->fd, REQ_MAX);
487
 
    for (i = 0; i < ARRAY_SIZE(s->requests); i++) {
488
 
        ioq_put_iocb(&s->ioqueue, &s->requests[i].iocb);
489
 
    }
490
 
    s->io_notifier = *ioq_get_notifier(&s->ioqueue);
491
 
    aio_set_event_notifier(s->ctx, &s->io_notifier, handle_io);
492
 
 
493
 
    s->starting = false;
494
 
    s->started = true;
495
 
    trace_virtio_blk_data_plane_start(s);
496
 
 
497
 
    /* Kick right away to begin processing requests already in vring */
498
 
    event_notifier_set(virtio_queue_get_host_notifier(vq));
499
 
 
500
 
    /* Spawn thread in BH so it inherits iothread cpusets */
501
 
    s->start_bh = qemu_bh_new(start_data_plane_bh, s);
502
 
    qemu_bh_schedule(s->start_bh);
503
 
}
504
 
 
505
 
void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)
506
 
{
507
 
    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));
508
 
    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
509
 
    if (!s->started || s->stopping) {
510
 
        return;
511
 
    }
512
 
    s->stopping = true;
513
 
    trace_virtio_blk_data_plane_stop(s);
514
 
 
515
 
    /* Stop thread or cancel pending thread creation BH */
516
 
    if (s->start_bh) {
517
 
        qemu_bh_delete(s->start_bh);
518
 
        s->start_bh = NULL;
519
 
    } else {
520
 
        aio_notify(s->ctx);
521
 
        qemu_thread_join(&s->thread);
522
 
    }
523
 
 
524
 
    aio_set_event_notifier(s->ctx, &s->io_notifier, NULL);
525
 
    ioq_cleanup(&s->ioqueue);
526
 
 
527
 
    aio_set_event_notifier(s->ctx, &s->host_notifier, NULL);
528
 
    k->set_host_notifier(qbus->parent, 0, false);
529
 
 
530
 
    aio_context_unref(s->ctx);
531
 
 
532
 
    /* Clean up guest notifier (irq) */
533
 
    k->set_guest_notifiers(qbus->parent, 1, false);
534
 
 
535
 
    vring_teardown(&s->vring, s->vdev, 0);
536
 
    s->started = false;
537
 
    s->stopping = false;
538
 
}