xref: /openbmc/qemu/hw/block/virtio-blk.c (revision 75bbe5e5)
1 /*
2  * Virtio Block Device
3  *
4  * Copyright IBM, Corp. 2007
5  *
6  * Authors:
7  *  Anthony Liguori   <aliguori@us.ibm.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2.  See
10  * the COPYING file in the top-level directory.
11  *
12  */
13 
14 #include "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "qemu/iov.h"
17 #include "qemu/module.h"
18 #include "qemu/error-report.h"
19 #include "qemu/main-loop.h"
20 #include "trace.h"
21 #include "hw/block/block.h"
22 #include "hw/qdev-properties.h"
23 #include "sysemu/blockdev.h"
24 #include "sysemu/sysemu.h"
25 #include "sysemu/runstate.h"
26 #include "hw/virtio/virtio-blk.h"
27 #include "dataplane/virtio-blk.h"
28 #include "scsi/constants.h"
29 #ifdef __linux__
30 # include <scsi/sg.h>
31 #endif
32 #include "hw/virtio/virtio-bus.h"
33 #include "migration/qemu-file-types.h"
34 #include "hw/virtio/virtio-access.h"
35 #include "qemu/coroutine.h"
36 
37 /* Config size before the discard support (hide associated config fields) */
38 #define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \
39                                      max_discard_sectors)
40 /*
41  * Starting from the discard feature, we can use this array to properly
42  * set the config size depending on the features enabled.
43  */
44 static const VirtIOFeature feature_sizes[] = {
45     {.flags = 1ULL << VIRTIO_BLK_F_DISCARD,
46      .end = endof(struct virtio_blk_config, discard_sector_alignment)},
47     {.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES,
48      .end = endof(struct virtio_blk_config, write_zeroes_may_unmap)},
49     {}
50 };
51 
52 static void virtio_blk_set_config_size(VirtIOBlock *s, uint64_t host_features)
53 {
54     s->config_size = MAX(VIRTIO_BLK_CFG_SIZE,
55         virtio_feature_get_config_size(feature_sizes, host_features));
56 
57     assert(s->config_size <= sizeof(struct virtio_blk_config));
58 }
59 
60 static void virtio_blk_init_request(VirtIOBlock *s, VirtQueue *vq,
61                                     VirtIOBlockReq *req)
62 {
63     req->dev = s;
64     req->vq = vq;
65     req->qiov.size = 0;
66     req->in_len = 0;
67     req->next = NULL;
68     req->mr_next = NULL;
69 }
70 
71 static void virtio_blk_free_request(VirtIOBlockReq *req)
72 {
73     g_free(req);
74 }
75 
76 static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status)
77 {
78     VirtIOBlock *s = req->dev;
79     VirtIODevice *vdev = VIRTIO_DEVICE(s);
80 
81     trace_virtio_blk_req_complete(vdev, req, status);
82 
83     stb_p(&req->in->status, status);
84     iov_discard_undo(&req->inhdr_undo);
85     iov_discard_undo(&req->outhdr_undo);
86     virtqueue_push(req->vq, &req->elem, req->in_len);
87     if (s->dataplane_started && !s->dataplane_disabled) {
88         virtio_blk_data_plane_notify(s->dataplane, req->vq);
89     } else {
90         virtio_notify(vdev, req->vq);
91     }
92 }
93 
94 static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
95     bool is_read, bool acct_failed)
96 {
97     VirtIOBlock *s = req->dev;
98     BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);
99 
100     if (action == BLOCK_ERROR_ACTION_STOP) {
101         /* Break the link as the next request is going to be parsed from the
102          * ring again. Otherwise we may end up doing a double completion! */
103         req->mr_next = NULL;
104         req->next = s->rq;
105         s->rq = req;
106     } else if (action == BLOCK_ERROR_ACTION_REPORT) {
107         virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
108         if (acct_failed) {
109             block_acct_failed(blk_get_stats(s->blk), &req->acct);
110         }
111         virtio_blk_free_request(req);
112     }
113 
114     blk_error_action(s->blk, action, is_read, error);
115     return action != BLOCK_ERROR_ACTION_IGNORE;
116 }
117 
118 static void virtio_blk_rw_complete(void *opaque, int ret)
119 {
120     VirtIOBlockReq *next = opaque;
121     VirtIOBlock *s = next->dev;
122     VirtIODevice *vdev = VIRTIO_DEVICE(s);
123 
124     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
125     while (next) {
126         VirtIOBlockReq *req = next;
127         next = req->mr_next;
128         trace_virtio_blk_rw_complete(vdev, req, ret);
129 
130         if (req->qiov.nalloc != -1) {
131             /* If nalloc is != -1 req->qiov is a local copy of the original
132              * external iovec. It was allocated in submit_requests to be
133              * able to merge requests. */
134             qemu_iovec_destroy(&req->qiov);
135         }
136 
137         if (ret) {
138             int p = virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type);
139             bool is_read = !(p & VIRTIO_BLK_T_OUT);
140             /* Note that memory may be dirtied on read failure.  If the
141              * virtio request is not completed here, as is the case for
142              * BLOCK_ERROR_ACTION_STOP, the memory may not be copied
143              * correctly during live migration.  While this is ugly,
144              * it is acceptable because the device is free to write to
145              * the memory until the request is completed (which will
146              * happen on the other side of the migration).
147              */
148             if (virtio_blk_handle_rw_error(req, -ret, is_read, true)) {
149                 continue;
150             }
151         }
152 
153         virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
154         block_acct_done(blk_get_stats(s->blk), &req->acct);
155         virtio_blk_free_request(req);
156     }
157     aio_context_release(blk_get_aio_context(s->conf.conf.blk));
158 }
159 
160 static void virtio_blk_flush_complete(void *opaque, int ret)
161 {
162     VirtIOBlockReq *req = opaque;
163     VirtIOBlock *s = req->dev;
164 
165     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
166     if (ret) {
167         if (virtio_blk_handle_rw_error(req, -ret, 0, true)) {
168             goto out;
169         }
170     }
171 
172     virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
173     block_acct_done(blk_get_stats(s->blk), &req->acct);
174     virtio_blk_free_request(req);
175 
176 out:
177     aio_context_release(blk_get_aio_context(s->conf.conf.blk));
178 }
179 
180 static void virtio_blk_discard_write_zeroes_complete(void *opaque, int ret)
181 {
182     VirtIOBlockReq *req = opaque;
183     VirtIOBlock *s = req->dev;
184     bool is_write_zeroes = (virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type) &
185                             ~VIRTIO_BLK_T_BARRIER) == VIRTIO_BLK_T_WRITE_ZEROES;
186 
187     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
188     if (ret) {
189         if (virtio_blk_handle_rw_error(req, -ret, false, is_write_zeroes)) {
190             goto out;
191         }
192     }
193 
194     virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
195     if (is_write_zeroes) {
196         block_acct_done(blk_get_stats(s->blk), &req->acct);
197     }
198     virtio_blk_free_request(req);
199 
200 out:
201     aio_context_release(blk_get_aio_context(s->conf.conf.blk));
202 }
203 
204 #ifdef __linux__
205 
206 typedef struct {
207     VirtIOBlockReq *req;
208     struct sg_io_hdr hdr;
209 } VirtIOBlockIoctlReq;
210 
211 static void virtio_blk_ioctl_complete(void *opaque, int status)
212 {
213     VirtIOBlockIoctlReq *ioctl_req = opaque;
214     VirtIOBlockReq *req = ioctl_req->req;
215     VirtIOBlock *s = req->dev;
216     VirtIODevice *vdev = VIRTIO_DEVICE(s);
217     struct virtio_scsi_inhdr *scsi;
218     struct sg_io_hdr *hdr;
219 
220     scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;
221 
222     if (status) {
223         status = VIRTIO_BLK_S_UNSUPP;
224         virtio_stl_p(vdev, &scsi->errors, 255);
225         goto out;
226     }
227 
228     hdr = &ioctl_req->hdr;
229     /*
230      * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi)
231      * clear the masked_status field [hence status gets cleared too, see
232      * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED
233      * status has occurred.  However they do set DRIVER_SENSE in driver_status
234      * field. Also a (sb_len_wr > 0) indicates there is a sense buffer.
235      */
236     if (hdr->status == 0 && hdr->sb_len_wr > 0) {
237         hdr->status = CHECK_CONDITION;
238     }
239 
240     virtio_stl_p(vdev, &scsi->errors,
241                  hdr->status | (hdr->msg_status << 8) |
242                  (hdr->host_status << 16) | (hdr->driver_status << 24));
243     virtio_stl_p(vdev, &scsi->residual, hdr->resid);
244     virtio_stl_p(vdev, &scsi->sense_len, hdr->sb_len_wr);
245     virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len);
246 
247 out:
248     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
249     virtio_blk_req_complete(req, status);
250     virtio_blk_free_request(req);
251     aio_context_release(blk_get_aio_context(s->conf.conf.blk));
252     g_free(ioctl_req);
253 }
254 
255 #endif
256 
257 static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s, VirtQueue *vq)
258 {
259     VirtIOBlockReq *req = virtqueue_pop(vq, sizeof(VirtIOBlockReq));
260 
261     if (req) {
262         virtio_blk_init_request(s, vq, req);
263     }
264     return req;
265 }
266 
267 static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req)
268 {
269     int status = VIRTIO_BLK_S_OK;
270     struct virtio_scsi_inhdr *scsi = NULL;
271     VirtIOBlock *blk = req->dev;
272     VirtIODevice *vdev = VIRTIO_DEVICE(blk);
273     VirtQueueElement *elem = &req->elem;
274 
275 #ifdef __linux__
276     int i;
277     VirtIOBlockIoctlReq *ioctl_req;
278     BlockAIOCB *acb;
279 #endif
280 
281     /*
282      * We require at least one output segment each for the virtio_blk_outhdr
283      * and the SCSI command block.
284      *
285      * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
286      * and the sense buffer pointer in the input segments.
287      */
288     if (elem->out_num < 2 || elem->in_num < 3) {
289         status = VIRTIO_BLK_S_IOERR;
290         goto fail;
291     }
292 
293     /*
294      * The scsi inhdr is placed in the second-to-last input segment, just
295      * before the regular inhdr.
296      */
297     scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
298 
299     if (!virtio_has_feature(blk->host_features, VIRTIO_BLK_F_SCSI)) {
300         status = VIRTIO_BLK_S_UNSUPP;
301         goto fail;
302     }
303 
304     /*
305      * No support for bidirection commands yet.
306      */
307     if (elem->out_num > 2 && elem->in_num > 3) {
308         status = VIRTIO_BLK_S_UNSUPP;
309         goto fail;
310     }
311 
312 #ifdef __linux__
313     ioctl_req = g_new0(VirtIOBlockIoctlReq, 1);
314     ioctl_req->req = req;
315     ioctl_req->hdr.interface_id = 'S';
316     ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len;
317     ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base;
318     ioctl_req->hdr.dxfer_len = 0;
319 
320     if (elem->out_num > 2) {
321         /*
322          * If there are more than the minimally required 2 output segments
323          * there is write payload starting from the third iovec.
324          */
325         ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV;
326         ioctl_req->hdr.iovec_count = elem->out_num - 2;
327 
328         for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
329             ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len;
330         }
331 
332         ioctl_req->hdr.dxferp = elem->out_sg + 2;
333 
334     } else if (elem->in_num > 3) {
335         /*
336          * If we have more than 3 input segments the guest wants to actually
337          * read data.
338          */
339         ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV;
340         ioctl_req->hdr.iovec_count = elem->in_num - 3;
341         for (i = 0; i < ioctl_req->hdr.iovec_count; i++) {
342             ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len;
343         }
344 
345         ioctl_req->hdr.dxferp = elem->in_sg;
346     } else {
347         /*
348          * Some SCSI commands don't actually transfer any data.
349          */
350         ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE;
351     }
352 
353     ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base;
354     ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len;
355 
356     acb = blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr,
357                         virtio_blk_ioctl_complete, ioctl_req);
358     if (!acb) {
359         g_free(ioctl_req);
360         status = VIRTIO_BLK_S_UNSUPP;
361         goto fail;
362     }
363     return -EINPROGRESS;
364 #else
365     abort();
366 #endif
367 
368 fail:
369     /* Just put anything nonzero so that the ioctl fails in the guest.  */
370     if (scsi) {
371         virtio_stl_p(vdev, &scsi->errors, 255);
372     }
373     return status;
374 }
375 
376 static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
377 {
378     int status;
379 
380     status = virtio_blk_handle_scsi_req(req);
381     if (status != -EINPROGRESS) {
382         virtio_blk_req_complete(req, status);
383         virtio_blk_free_request(req);
384     }
385 }
386 
387 static inline void submit_requests(BlockBackend *blk, MultiReqBuffer *mrb,
388                                    int start, int num_reqs, int niov)
389 {
390     QEMUIOVector *qiov = &mrb->reqs[start]->qiov;
391     int64_t sector_num = mrb->reqs[start]->sector_num;
392     bool is_write = mrb->is_write;
393 
394     if (num_reqs > 1) {
395         int i;
396         struct iovec *tmp_iov = qiov->iov;
397         int tmp_niov = qiov->niov;
398 
399         /* mrb->reqs[start]->qiov was initialized from external so we can't
400          * modify it here. We need to initialize it locally and then add the
401          * external iovecs. */
402         qemu_iovec_init(qiov, niov);
403 
404         for (i = 0; i < tmp_niov; i++) {
405             qemu_iovec_add(qiov, tmp_iov[i].iov_base, tmp_iov[i].iov_len);
406         }
407 
408         for (i = start + 1; i < start + num_reqs; i++) {
409             qemu_iovec_concat(qiov, &mrb->reqs[i]->qiov, 0,
410                               mrb->reqs[i]->qiov.size);
411             mrb->reqs[i - 1]->mr_next = mrb->reqs[i];
412         }
413 
414         trace_virtio_blk_submit_multireq(VIRTIO_DEVICE(mrb->reqs[start]->dev),
415                                          mrb, start, num_reqs,
416                                          sector_num << BDRV_SECTOR_BITS,
417                                          qiov->size, is_write);
418         block_acct_merge_done(blk_get_stats(blk),
419                               is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ,
420                               num_reqs - 1);
421     }
422 
423     if (is_write) {
424         blk_aio_pwritev(blk, sector_num << BDRV_SECTOR_BITS, qiov, 0,
425                         virtio_blk_rw_complete, mrb->reqs[start]);
426     } else {
427         blk_aio_preadv(blk, sector_num << BDRV_SECTOR_BITS, qiov, 0,
428                        virtio_blk_rw_complete, mrb->reqs[start]);
429     }
430 }
431 
432 static int multireq_compare(const void *a, const void *b)
433 {
434     const VirtIOBlockReq *req1 = *(VirtIOBlockReq **)a,
435                          *req2 = *(VirtIOBlockReq **)b;
436 
437     /*
438      * Note that we can't simply subtract sector_num1 from sector_num2
439      * here as that could overflow the return value.
440      */
441     if (req1->sector_num > req2->sector_num) {
442         return 1;
443     } else if (req1->sector_num < req2->sector_num) {
444         return -1;
445     } else {
446         return 0;
447     }
448 }
449 
450 static void virtio_blk_submit_multireq(BlockBackend *blk, MultiReqBuffer *mrb)
451 {
452     int i = 0, start = 0, num_reqs = 0, niov = 0, nb_sectors = 0;
453     uint32_t max_transfer;
454     int64_t sector_num = 0;
455 
456     if (mrb->num_reqs == 1) {
457         submit_requests(blk, mrb, 0, 1, -1);
458         mrb->num_reqs = 0;
459         return;
460     }
461 
462     max_transfer = blk_get_max_transfer(mrb->reqs[0]->dev->blk);
463 
464     qsort(mrb->reqs, mrb->num_reqs, sizeof(*mrb->reqs),
465           &multireq_compare);
466 
467     for (i = 0; i < mrb->num_reqs; i++) {
468         VirtIOBlockReq *req = mrb->reqs[i];
469         if (num_reqs > 0) {
470             /*
471              * NOTE: We cannot merge the requests in below situations:
472              * 1. requests are not sequential
473              * 2. merge would exceed maximum number of IOVs
474              * 3. merge would exceed maximum transfer length of backend device
475              */
476             if (sector_num + nb_sectors != req->sector_num ||
477                 niov > blk_get_max_iov(blk) - req->qiov.niov ||
478                 req->qiov.size > max_transfer ||
479                 nb_sectors > (max_transfer -
480                               req->qiov.size) / BDRV_SECTOR_SIZE) {
481                 submit_requests(blk, mrb, start, num_reqs, niov);
482                 num_reqs = 0;
483             }
484         }
485 
486         if (num_reqs == 0) {
487             sector_num = req->sector_num;
488             nb_sectors = niov = 0;
489             start = i;
490         }
491 
492         nb_sectors += req->qiov.size / BDRV_SECTOR_SIZE;
493         niov += req->qiov.niov;
494         num_reqs++;
495     }
496 
497     submit_requests(blk, mrb, start, num_reqs, niov);
498     mrb->num_reqs = 0;
499 }
500 
501 static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb)
502 {
503     VirtIOBlock *s = req->dev;
504 
505     block_acct_start(blk_get_stats(s->blk), &req->acct, 0,
506                      BLOCK_ACCT_FLUSH);
507 
508     /*
509      * Make sure all outstanding writes are posted to the backing device.
510      */
511     if (mrb->is_write && mrb->num_reqs > 0) {
512         virtio_blk_submit_multireq(s->blk, mrb);
513     }
514     blk_aio_flush(s->blk, virtio_blk_flush_complete, req);
515 }
516 
517 static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
518                                      uint64_t sector, size_t size)
519 {
520     uint64_t nb_sectors = size >> BDRV_SECTOR_BITS;
521     uint64_t total_sectors;
522 
523     if (nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
524         return false;
525     }
526     if (sector & dev->sector_mask) {
527         return false;
528     }
529     if (size % dev->conf.conf.logical_block_size) {
530         return false;
531     }
532     blk_get_geometry(dev->blk, &total_sectors);
533     if (sector > total_sectors || nb_sectors > total_sectors - sector) {
534         return false;
535     }
536     return true;
537 }
538 
539 static uint8_t virtio_blk_handle_discard_write_zeroes(VirtIOBlockReq *req,
540     struct virtio_blk_discard_write_zeroes *dwz_hdr, bool is_write_zeroes)
541 {
542     VirtIOBlock *s = req->dev;
543     VirtIODevice *vdev = VIRTIO_DEVICE(s);
544     uint64_t sector;
545     uint32_t num_sectors, flags, max_sectors;
546     uint8_t err_status;
547     int bytes;
548 
549     sector = virtio_ldq_p(vdev, &dwz_hdr->sector);
550     num_sectors = virtio_ldl_p(vdev, &dwz_hdr->num_sectors);
551     flags = virtio_ldl_p(vdev, &dwz_hdr->flags);
552     max_sectors = is_write_zeroes ? s->conf.max_write_zeroes_sectors :
553                   s->conf.max_discard_sectors;
554 
555     /*
556      * max_sectors is at most BDRV_REQUEST_MAX_SECTORS, this check
557      * make us sure that "num_sectors << BDRV_SECTOR_BITS" can fit in
558      * the integer variable.
559      */
560     if (unlikely(num_sectors > max_sectors)) {
561         err_status = VIRTIO_BLK_S_IOERR;
562         goto err;
563     }
564 
565     bytes = num_sectors << BDRV_SECTOR_BITS;
566 
567     if (unlikely(!virtio_blk_sect_range_ok(s, sector, bytes))) {
568         err_status = VIRTIO_BLK_S_IOERR;
569         goto err;
570     }
571 
572     /*
573      * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard
574      * and write zeroes commands if any unknown flag is set.
575      */
576     if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
577         err_status = VIRTIO_BLK_S_UNSUPP;
578         goto err;
579     }
580 
581     if (is_write_zeroes) { /* VIRTIO_BLK_T_WRITE_ZEROES */
582         int blk_aio_flags = 0;
583 
584         if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
585             blk_aio_flags |= BDRV_REQ_MAY_UNMAP;
586         }
587 
588         block_acct_start(blk_get_stats(s->blk), &req->acct, bytes,
589                          BLOCK_ACCT_WRITE);
590 
591         blk_aio_pwrite_zeroes(s->blk, sector << BDRV_SECTOR_BITS,
592                               bytes, blk_aio_flags,
593                               virtio_blk_discard_write_zeroes_complete, req);
594     } else { /* VIRTIO_BLK_T_DISCARD */
595         /*
596          * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for
597          * discard commands if the unmap flag is set.
598          */
599         if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
600             err_status = VIRTIO_BLK_S_UNSUPP;
601             goto err;
602         }
603 
604         blk_aio_pdiscard(s->blk, sector << BDRV_SECTOR_BITS, bytes,
605                          virtio_blk_discard_write_zeroes_complete, req);
606     }
607 
608     return VIRTIO_BLK_S_OK;
609 
610 err:
611     if (is_write_zeroes) {
612         block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE);
613     }
614     return err_status;
615 }
616 
617 static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
618 {
619     uint32_t type;
620     struct iovec *in_iov = req->elem.in_sg;
621     struct iovec *out_iov = req->elem.out_sg;
622     unsigned in_num = req->elem.in_num;
623     unsigned out_num = req->elem.out_num;
624     VirtIOBlock *s = req->dev;
625     VirtIODevice *vdev = VIRTIO_DEVICE(s);
626 
627     if (req->elem.out_num < 1 || req->elem.in_num < 1) {
628         virtio_error(vdev, "virtio-blk missing headers");
629         return -1;
630     }
631 
632     if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
633                             sizeof(req->out)) != sizeof(req->out))) {
634         virtio_error(vdev, "virtio-blk request outhdr too short");
635         return -1;
636     }
637 
638     iov_discard_front_undoable(&out_iov, &out_num, sizeof(req->out),
639                                &req->outhdr_undo);
640 
641     if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
642         virtio_error(vdev, "virtio-blk request inhdr too short");
643         iov_discard_undo(&req->outhdr_undo);
644         return -1;
645     }
646 
647     /* We always touch the last byte, so just see how big in_iov is.  */
648     req->in_len = iov_size(in_iov, in_num);
649     req->in = (void *)in_iov[in_num - 1].iov_base
650               + in_iov[in_num - 1].iov_len
651               - sizeof(struct virtio_blk_inhdr);
652     iov_discard_back_undoable(in_iov, &in_num, sizeof(struct virtio_blk_inhdr),
653                               &req->inhdr_undo);
654 
655     type = virtio_ldl_p(vdev, &req->out.type);
656 
657     /* VIRTIO_BLK_T_OUT defines the command direction. VIRTIO_BLK_T_BARRIER
658      * is an optional flag. Although a guest should not send this flag if
659      * not negotiated we ignored it in the past. So keep ignoring it. */
660     switch (type & ~(VIRTIO_BLK_T_OUT | VIRTIO_BLK_T_BARRIER)) {
661     case VIRTIO_BLK_T_IN:
662     {
663         bool is_write = type & VIRTIO_BLK_T_OUT;
664         req->sector_num = virtio_ldq_p(vdev, &req->out.sector);
665 
666         if (is_write) {
667             qemu_iovec_init_external(&req->qiov, out_iov, out_num);
668             trace_virtio_blk_handle_write(vdev, req, req->sector_num,
669                                           req->qiov.size / BDRV_SECTOR_SIZE);
670         } else {
671             qemu_iovec_init_external(&req->qiov, in_iov, in_num);
672             trace_virtio_blk_handle_read(vdev, req, req->sector_num,
673                                          req->qiov.size / BDRV_SECTOR_SIZE);
674         }
675 
676         if (!virtio_blk_sect_range_ok(s, req->sector_num, req->qiov.size)) {
677             virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
678             block_acct_invalid(blk_get_stats(s->blk),
679                                is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ);
680             virtio_blk_free_request(req);
681             return 0;
682         }
683 
684         block_acct_start(blk_get_stats(s->blk), &req->acct, req->qiov.size,
685                          is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ);
686 
687         /* merge would exceed maximum number of requests or IO direction
688          * changes */
689         if (mrb->num_reqs > 0 && (mrb->num_reqs == VIRTIO_BLK_MAX_MERGE_REQS ||
690                                   is_write != mrb->is_write ||
691                                   !s->conf.request_merging)) {
692             virtio_blk_submit_multireq(s->blk, mrb);
693         }
694 
695         assert(mrb->num_reqs < VIRTIO_BLK_MAX_MERGE_REQS);
696         mrb->reqs[mrb->num_reqs++] = req;
697         mrb->is_write = is_write;
698         break;
699     }
700     case VIRTIO_BLK_T_FLUSH:
701         virtio_blk_handle_flush(req, mrb);
702         break;
703     case VIRTIO_BLK_T_SCSI_CMD:
704         virtio_blk_handle_scsi(req);
705         break;
706     case VIRTIO_BLK_T_GET_ID:
707     {
708         /*
709          * NB: per existing s/n string convention the string is
710          * terminated by '\0' only when shorter than buffer.
711          */
712         const char *serial = s->conf.serial ? s->conf.serial : "";
713         size_t size = MIN(strlen(serial) + 1,
714                           MIN(iov_size(in_iov, in_num),
715                               VIRTIO_BLK_ID_BYTES));
716         iov_from_buf(in_iov, in_num, 0, serial, size);
717         virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
718         virtio_blk_free_request(req);
719         break;
720     }
721     /*
722      * VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with
723      * VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement,
724      * so we must mask it for these requests, then we will check if it is set.
725      */
726     case VIRTIO_BLK_T_DISCARD & ~VIRTIO_BLK_T_OUT:
727     case VIRTIO_BLK_T_WRITE_ZEROES & ~VIRTIO_BLK_T_OUT:
728     {
729         struct virtio_blk_discard_write_zeroes dwz_hdr;
730         size_t out_len = iov_size(out_iov, out_num);
731         bool is_write_zeroes = (type & ~VIRTIO_BLK_T_BARRIER) ==
732                                VIRTIO_BLK_T_WRITE_ZEROES;
733         uint8_t err_status;
734 
735         /*
736          * Unsupported if VIRTIO_BLK_T_OUT is not set or the request contains
737          * more than one segment.
738          */
739         if (unlikely(!(type & VIRTIO_BLK_T_OUT) ||
740                      out_len > sizeof(dwz_hdr))) {
741             virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
742             virtio_blk_free_request(req);
743             return 0;
744         }
745 
746         if (unlikely(iov_to_buf(out_iov, out_num, 0, &dwz_hdr,
747                                 sizeof(dwz_hdr)) != sizeof(dwz_hdr))) {
748             iov_discard_undo(&req->inhdr_undo);
749             iov_discard_undo(&req->outhdr_undo);
750             virtio_error(vdev, "virtio-blk discard/write_zeroes header"
751                          " too short");
752             return -1;
753         }
754 
755         err_status = virtio_blk_handle_discard_write_zeroes(req, &dwz_hdr,
756                                                             is_write_zeroes);
757         if (err_status != VIRTIO_BLK_S_OK) {
758             virtio_blk_req_complete(req, err_status);
759             virtio_blk_free_request(req);
760         }
761 
762         break;
763     }
764     default:
765         virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
766         virtio_blk_free_request(req);
767     }
768     return 0;
769 }
770 
771 void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
772 {
773     VirtIOBlockReq *req;
774     MultiReqBuffer mrb = {};
775     bool suppress_notifications = virtio_queue_get_notification(vq);
776 
777     aio_context_acquire(blk_get_aio_context(s->blk));
778     blk_io_plug(s->blk);
779 
780     do {
781         if (suppress_notifications) {
782             virtio_queue_set_notification(vq, 0);
783         }
784 
785         while ((req = virtio_blk_get_request(s, vq))) {
786             if (virtio_blk_handle_request(req, &mrb)) {
787                 virtqueue_detach_element(req->vq, &req->elem, 0);
788                 virtio_blk_free_request(req);
789                 break;
790             }
791         }
792 
793         if (suppress_notifications) {
794             virtio_queue_set_notification(vq, 1);
795         }
796     } while (!virtio_queue_empty(vq));
797 
798     if (mrb.num_reqs) {
799         virtio_blk_submit_multireq(s->blk, &mrb);
800     }
801 
802     blk_io_unplug(s->blk);
803     aio_context_release(blk_get_aio_context(s->blk));
804 }
805 
806 static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
807 {
808     VirtIOBlock *s = (VirtIOBlock *)vdev;
809 
810     if (s->dataplane && !s->dataplane_started) {
811         /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
812          * dataplane here instead of waiting for .set_status().
813          */
814         virtio_device_start_ioeventfd(vdev);
815         if (!s->dataplane_disabled) {
816             return;
817         }
818     }
819     virtio_blk_handle_vq(s, vq);
820 }
821 
822 void virtio_blk_process_queued_requests(VirtIOBlock *s, bool is_bh)
823 {
824     VirtIOBlockReq *req = s->rq;
825     MultiReqBuffer mrb = {};
826 
827     s->rq = NULL;
828 
829     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
830     while (req) {
831         VirtIOBlockReq *next = req->next;
832         if (virtio_blk_handle_request(req, &mrb)) {
833             /* Device is now broken and won't do any processing until it gets
834              * reset. Already queued requests will be lost: let's purge them.
835              */
836             while (req) {
837                 next = req->next;
838                 virtqueue_detach_element(req->vq, &req->elem, 0);
839                 virtio_blk_free_request(req);
840                 req = next;
841             }
842             break;
843         }
844         req = next;
845     }
846 
847     if (mrb.num_reqs) {
848         virtio_blk_submit_multireq(s->blk, &mrb);
849     }
850     if (is_bh) {
851         blk_dec_in_flight(s->conf.conf.blk);
852     }
853     aio_context_release(blk_get_aio_context(s->conf.conf.blk));
854 }
855 
856 static void virtio_blk_dma_restart_bh(void *opaque)
857 {
858     VirtIOBlock *s = opaque;
859 
860     qemu_bh_delete(s->bh);
861     s->bh = NULL;
862 
863     virtio_blk_process_queued_requests(s, true);
864 }
865 
866 static void virtio_blk_dma_restart_cb(void *opaque, bool running,
867                                       RunState state)
868 {
869     VirtIOBlock *s = opaque;
870     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
871     VirtioBusState *bus = VIRTIO_BUS(qbus);
872 
873     if (!running) {
874         return;
875     }
876 
877     /*
878      * If ioeventfd is enabled, don't schedule the BH here as queued
879      * requests will be processed while starting the data plane.
880      */
881     if (!s->bh && !virtio_bus_ioeventfd_enabled(bus)) {
882         s->bh = aio_bh_new(blk_get_aio_context(s->conf.conf.blk),
883                            virtio_blk_dma_restart_bh, s);
884         blk_inc_in_flight(s->conf.conf.blk);
885         qemu_bh_schedule(s->bh);
886     }
887 }
888 
889 static void virtio_blk_reset(VirtIODevice *vdev)
890 {
891     VirtIOBlock *s = VIRTIO_BLK(vdev);
892     AioContext *ctx;
893     VirtIOBlockReq *req;
894 
895     ctx = blk_get_aio_context(s->blk);
896     aio_context_acquire(ctx);
897     blk_drain(s->blk);
898 
899     /* We drop queued requests after blk_drain() because blk_drain() itself can
900      * produce them. */
901     while (s->rq) {
902         req = s->rq;
903         s->rq = req->next;
904         virtqueue_detach_element(req->vq, &req->elem, 0);
905         virtio_blk_free_request(req);
906     }
907 
908     aio_context_release(ctx);
909 
910     assert(!s->dataplane_started);
911     blk_set_enable_write_cache(s->blk, s->original_wce);
912 }
913 
914 /* coalesce internal state, copy to pci i/o region 0
915  */
916 static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
917 {
918     VirtIOBlock *s = VIRTIO_BLK(vdev);
919     BlockConf *conf = &s->conf.conf;
920     struct virtio_blk_config blkcfg;
921     uint64_t capacity;
922     int64_t length;
923     int blk_size = conf->logical_block_size;
924 
925     blk_get_geometry(s->blk, &capacity);
926     memset(&blkcfg, 0, sizeof(blkcfg));
927     virtio_stq_p(vdev, &blkcfg.capacity, capacity);
928     virtio_stl_p(vdev, &blkcfg.seg_max,
929                  s->conf.seg_max_adjust ? s->conf.queue_size - 2 : 128 - 2);
930     virtio_stw_p(vdev, &blkcfg.geometry.cylinders, conf->cyls);
931     virtio_stl_p(vdev, &blkcfg.blk_size, blk_size);
932     virtio_stw_p(vdev, &blkcfg.min_io_size, conf->min_io_size / blk_size);
933     virtio_stl_p(vdev, &blkcfg.opt_io_size, conf->opt_io_size / blk_size);
934     blkcfg.geometry.heads = conf->heads;
935     /*
936      * We must ensure that the block device capacity is a multiple of
937      * the logical block size. If that is not the case, let's use
938      * sector_mask to adopt the geometry to have a correct picture.
939      * For those devices where the capacity is ok for the given geometry
940      * we don't touch the sector value of the geometry, since some devices
941      * (like s390 dasd) need a specific value. Here the capacity is already
942      * cyls*heads*secs*blk_size and the sector value is not block size
943      * divided by 512 - instead it is the amount of blk_size blocks
944      * per track (cylinder).
945      */
946     length = blk_getlength(s->blk);
947     if (length > 0 && length / conf->heads / conf->secs % blk_size) {
948         blkcfg.geometry.sectors = conf->secs & ~s->sector_mask;
949     } else {
950         blkcfg.geometry.sectors = conf->secs;
951     }
952     blkcfg.size_max = 0;
953     blkcfg.physical_block_exp = get_physical_block_exp(conf);
954     blkcfg.alignment_offset = 0;
955     blkcfg.wce = blk_enable_write_cache(s->blk);
956     virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
957     if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD)) {
958         uint32_t discard_granularity = conf->discard_granularity;
959         if (discard_granularity == -1 || !s->conf.report_discard_granularity) {
960             discard_granularity = blk_size;
961         }
962         virtio_stl_p(vdev, &blkcfg.max_discard_sectors,
963                      s->conf.max_discard_sectors);
964         virtio_stl_p(vdev, &blkcfg.discard_sector_alignment,
965                      discard_granularity >> BDRV_SECTOR_BITS);
966         /*
967          * We support only one segment per request since multiple segments
968          * are not widely used and there are no userspace APIs that allow
969          * applications to submit multiple segments in a single call.
970          */
971         virtio_stl_p(vdev, &blkcfg.max_discard_seg, 1);
972     }
973     if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES)) {
974         virtio_stl_p(vdev, &blkcfg.max_write_zeroes_sectors,
975                      s->conf.max_write_zeroes_sectors);
976         blkcfg.write_zeroes_may_unmap = 1;
977         virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1);
978     }
979     memcpy(config, &blkcfg, s->config_size);
980 }
981 
982 static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
983 {
984     VirtIOBlock *s = VIRTIO_BLK(vdev);
985     struct virtio_blk_config blkcfg;
986 
987     memcpy(&blkcfg, config, s->config_size);
988 
989     aio_context_acquire(blk_get_aio_context(s->blk));
990     blk_set_enable_write_cache(s->blk, blkcfg.wce != 0);
991     aio_context_release(blk_get_aio_context(s->blk));
992 }
993 
994 static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,
995                                         Error **errp)
996 {
997     VirtIOBlock *s = VIRTIO_BLK(vdev);
998 
999     /* Firstly sync all virtio-blk possible supported features */
1000     features |= s->host_features;
1001 
1002     virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
1003     virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
1004     virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
1005     virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
1006     if (virtio_has_feature(features, VIRTIO_F_VERSION_1)) {
1007         if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_SCSI)) {
1008             error_setg(errp, "Please set scsi=off for virtio-blk devices in order to use virtio 1.0");
1009             return 0;
1010         }
1011     } else {
1012         virtio_clear_feature(&features, VIRTIO_F_ANY_LAYOUT);
1013         virtio_add_feature(&features, VIRTIO_BLK_F_SCSI);
1014     }
1015 
1016     if (blk_enable_write_cache(s->blk) ||
1017         (s->conf.x_enable_wce_if_config_wce &&
1018          virtio_has_feature(features, VIRTIO_BLK_F_CONFIG_WCE))) {
1019         virtio_add_feature(&features, VIRTIO_BLK_F_WCE);
1020     }
1021     if (!blk_is_writable(s->blk)) {
1022         virtio_add_feature(&features, VIRTIO_BLK_F_RO);
1023     }
1024     if (s->conf.num_queues > 1) {
1025         virtio_add_feature(&features, VIRTIO_BLK_F_MQ);
1026     }
1027 
1028     return features;
1029 }
1030 
1031 static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status)
1032 {
1033     VirtIOBlock *s = VIRTIO_BLK(vdev);
1034 
1035     if (!(status & (VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK))) {
1036         assert(!s->dataplane_started);
1037     }
1038 
1039     if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
1040         return;
1041     }
1042 
1043     /* A guest that supports VIRTIO_BLK_F_CONFIG_WCE must be able to send
1044      * cache flushes.  Thus, the "auto writethrough" behavior is never
1045      * necessary for guests that support the VIRTIO_BLK_F_CONFIG_WCE feature.
1046      * Leaving it enabled would break the following sequence:
1047      *
1048      *     Guest started with "-drive cache=writethrough"
1049      *     Guest sets status to 0
1050      *     Guest sets DRIVER bit in status field
1051      *     Guest reads host features (WCE=0, CONFIG_WCE=1)
1052      *     Guest writes guest features (WCE=0, CONFIG_WCE=1)
1053      *     Guest writes 1 to the WCE configuration field (writeback mode)
1054      *     Guest sets DRIVER_OK bit in status field
1055      *
1056      * s->blk would erroneously be placed in writethrough mode.
1057      */
1058     if (!virtio_vdev_has_feature(vdev, VIRTIO_BLK_F_CONFIG_WCE)) {
1059         aio_context_acquire(blk_get_aio_context(s->blk));
1060         blk_set_enable_write_cache(s->blk,
1061                                    virtio_vdev_has_feature(vdev,
1062                                                            VIRTIO_BLK_F_WCE));
1063         aio_context_release(blk_get_aio_context(s->blk));
1064     }
1065 }
1066 
1067 static void virtio_blk_save_device(VirtIODevice *vdev, QEMUFile *f)
1068 {
1069     VirtIOBlock *s = VIRTIO_BLK(vdev);
1070     VirtIOBlockReq *req = s->rq;
1071 
1072     while (req) {
1073         qemu_put_sbyte(f, 1);
1074 
1075         if (s->conf.num_queues > 1) {
1076             qemu_put_be32(f, virtio_get_queue_index(req->vq));
1077         }
1078 
1079         qemu_put_virtqueue_element(vdev, f, &req->elem);
1080         req = req->next;
1081     }
1082     qemu_put_sbyte(f, 0);
1083 }
1084 
1085 static int virtio_blk_load_device(VirtIODevice *vdev, QEMUFile *f,
1086                                   int version_id)
1087 {
1088     VirtIOBlock *s = VIRTIO_BLK(vdev);
1089 
1090     while (qemu_get_sbyte(f)) {
1091         unsigned nvqs = s->conf.num_queues;
1092         unsigned vq_idx = 0;
1093         VirtIOBlockReq *req;
1094 
1095         if (nvqs > 1) {
1096             vq_idx = qemu_get_be32(f);
1097 
1098             if (vq_idx >= nvqs) {
1099                 error_report("Invalid virtqueue index in request list: %#x",
1100                              vq_idx);
1101                 return -EINVAL;
1102             }
1103         }
1104 
1105         req = qemu_get_virtqueue_element(vdev, f, sizeof(VirtIOBlockReq));
1106         virtio_blk_init_request(s, virtio_get_queue(vdev, vq_idx), req);
1107         req->next = s->rq;
1108         s->rq = req;
1109     }
1110 
1111     return 0;
1112 }
1113 
1114 static void virtio_resize_cb(void *opaque)
1115 {
1116     VirtIODevice *vdev = opaque;
1117 
1118     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1119     virtio_notify_config(vdev);
1120 }
1121 
1122 static void virtio_blk_resize(void *opaque)
1123 {
1124     VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
1125 
1126     /*
1127      * virtio_notify_config() needs to acquire the global mutex,
1128      * so it can't be called from an iothread. Instead, schedule
1129      * it to be run in the main context BH.
1130      */
1131     aio_bh_schedule_oneshot(qemu_get_aio_context(), virtio_resize_cb, vdev);
1132 }
1133 
1134 static const BlockDevOps virtio_block_ops = {
1135     .resize_cb = virtio_blk_resize,
1136 };
1137 
1138 static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
1139 {
1140     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1141     VirtIOBlock *s = VIRTIO_BLK(dev);
1142     VirtIOBlkConf *conf = &s->conf;
1143     Error *err = NULL;
1144     unsigned i;
1145 
1146     if (!conf->conf.blk) {
1147         error_setg(errp, "drive property not set");
1148         return;
1149     }
1150     if (!blk_is_inserted(conf->conf.blk)) {
1151         error_setg(errp, "Device needs media, but drive is empty");
1152         return;
1153     }
1154     if (conf->num_queues == VIRTIO_BLK_AUTO_NUM_QUEUES) {
1155         conf->num_queues = 1;
1156     }
1157     if (!conf->num_queues) {
1158         error_setg(errp, "num-queues property must be larger than 0");
1159         return;
1160     }
1161     if (conf->queue_size <= 2) {
1162         error_setg(errp, "invalid queue-size property (%" PRIu16 "), "
1163                    "must be > 2", conf->queue_size);
1164         return;
1165     }
1166     if (!is_power_of_2(conf->queue_size) ||
1167         conf->queue_size > VIRTQUEUE_MAX_SIZE) {
1168         error_setg(errp, "invalid queue-size property (%" PRIu16 "), "
1169                    "must be a power of 2 (max %d)",
1170                    conf->queue_size, VIRTQUEUE_MAX_SIZE);
1171         return;
1172     }
1173 
1174     if (!blkconf_apply_backend_options(&conf->conf,
1175                                        !blk_supports_write_perm(conf->conf.blk),
1176                                        true, errp)) {
1177         return;
1178     }
1179     s->original_wce = blk_enable_write_cache(conf->conf.blk);
1180     if (!blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, errp)) {
1181         return;
1182     }
1183 
1184     if (!blkconf_blocksizes(&conf->conf, errp)) {
1185         return;
1186     }
1187 
1188     if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) &&
1189         (!conf->max_discard_sectors ||
1190          conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) {
1191         error_setg(errp, "invalid max-discard-sectors property (%" PRIu32 ")"
1192                    ", must be between 1 and %d",
1193                    conf->max_discard_sectors, (int)BDRV_REQUEST_MAX_SECTORS);
1194         return;
1195     }
1196 
1197     if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES) &&
1198         (!conf->max_write_zeroes_sectors ||
1199          conf->max_write_zeroes_sectors > BDRV_REQUEST_MAX_SECTORS)) {
1200         error_setg(errp, "invalid max-write-zeroes-sectors property (%" PRIu32
1201                    "), must be between 1 and %d",
1202                    conf->max_write_zeroes_sectors,
1203                    (int)BDRV_REQUEST_MAX_SECTORS);
1204         return;
1205     }
1206 
1207     virtio_blk_set_config_size(s, s->host_features);
1208 
1209     virtio_init(vdev, VIRTIO_ID_BLOCK, s->config_size);
1210 
1211     s->blk = conf->conf.blk;
1212     s->rq = NULL;
1213     s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1;
1214 
1215     for (i = 0; i < conf->num_queues; i++) {
1216         virtio_add_queue(vdev, conf->queue_size, virtio_blk_handle_output);
1217     }
1218     qemu_coroutine_inc_pool_size(conf->num_queues * conf->queue_size / 2);
1219     virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);
1220     if (err != NULL) {
1221         error_propagate(errp, err);
1222         for (i = 0; i < conf->num_queues; i++) {
1223             virtio_del_queue(vdev, i);
1224         }
1225         virtio_cleanup(vdev);
1226         return;
1227     }
1228 
1229     s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s);
1230     blk_set_dev_ops(s->blk, &virtio_block_ops, s);
1231     blk_set_guest_block_size(s->blk, s->conf.conf.logical_block_size);
1232 
1233     blk_iostatus_enable(s->blk);
1234 
1235     add_boot_device_lchs(dev, "/disk@0,0",
1236                          conf->conf.lcyls,
1237                          conf->conf.lheads,
1238                          conf->conf.lsecs);
1239 }
1240 
1241 static void virtio_blk_device_unrealize(DeviceState *dev)
1242 {
1243     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1244     VirtIOBlock *s = VIRTIO_BLK(dev);
1245     VirtIOBlkConf *conf = &s->conf;
1246     unsigned i;
1247 
1248     blk_drain(s->blk);
1249     del_boot_device_lchs(dev, "/disk@0,0");
1250     virtio_blk_data_plane_destroy(s->dataplane);
1251     s->dataplane = NULL;
1252     for (i = 0; i < conf->num_queues; i++) {
1253         virtio_del_queue(vdev, i);
1254     }
1255     qemu_coroutine_dec_pool_size(conf->num_queues * conf->queue_size / 2);
1256     qemu_del_vm_change_state_handler(s->change);
1257     blockdev_mark_auto_del(s->blk);
1258     virtio_cleanup(vdev);
1259 }
1260 
1261 static void virtio_blk_instance_init(Object *obj)
1262 {
1263     VirtIOBlock *s = VIRTIO_BLK(obj);
1264 
1265     device_add_bootindex_property(obj, &s->conf.conf.bootindex,
1266                                   "bootindex", "/disk@0,0",
1267                                   DEVICE(obj));
1268 }
1269 
1270 static const VMStateDescription vmstate_virtio_blk = {
1271     .name = "virtio-blk",
1272     .minimum_version_id = 2,
1273     .version_id = 2,
1274     .fields = (VMStateField[]) {
1275         VMSTATE_VIRTIO_DEVICE,
1276         VMSTATE_END_OF_LIST()
1277     },
1278 };
1279 
1280 static Property virtio_blk_properties[] = {
1281     DEFINE_BLOCK_PROPERTIES(VirtIOBlock, conf.conf),
1282     DEFINE_BLOCK_ERROR_PROPERTIES(VirtIOBlock, conf.conf),
1283     DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf),
1284     DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial),
1285     DEFINE_PROP_BIT64("config-wce", VirtIOBlock, host_features,
1286                       VIRTIO_BLK_F_CONFIG_WCE, true),
1287 #ifdef __linux__
1288     DEFINE_PROP_BIT64("scsi", VirtIOBlock, host_features,
1289                       VIRTIO_BLK_F_SCSI, false),
1290 #endif
1291     DEFINE_PROP_BIT("request-merging", VirtIOBlock, conf.request_merging, 0,
1292                     true),
1293     DEFINE_PROP_UINT16("num-queues", VirtIOBlock, conf.num_queues,
1294                        VIRTIO_BLK_AUTO_NUM_QUEUES),
1295     DEFINE_PROP_UINT16("queue-size", VirtIOBlock, conf.queue_size, 256),
1296     DEFINE_PROP_BOOL("seg-max-adjust", VirtIOBlock, conf.seg_max_adjust, true),
1297     DEFINE_PROP_LINK("iothread", VirtIOBlock, conf.iothread, TYPE_IOTHREAD,
1298                      IOThread *),
1299     DEFINE_PROP_BIT64("discard", VirtIOBlock, host_features,
1300                       VIRTIO_BLK_F_DISCARD, true),
1301     DEFINE_PROP_BOOL("report-discard-granularity", VirtIOBlock,
1302                      conf.report_discard_granularity, true),
1303     DEFINE_PROP_BIT64("write-zeroes", VirtIOBlock, host_features,
1304                       VIRTIO_BLK_F_WRITE_ZEROES, true),
1305     DEFINE_PROP_UINT32("max-discard-sectors", VirtIOBlock,
1306                        conf.max_discard_sectors, BDRV_REQUEST_MAX_SECTORS),
1307     DEFINE_PROP_UINT32("max-write-zeroes-sectors", VirtIOBlock,
1308                        conf.max_write_zeroes_sectors, BDRV_REQUEST_MAX_SECTORS),
1309     DEFINE_PROP_BOOL("x-enable-wce-if-config-wce", VirtIOBlock,
1310                      conf.x_enable_wce_if_config_wce, true),
1311     DEFINE_PROP_END_OF_LIST(),
1312 };
1313 
1314 static void virtio_blk_class_init(ObjectClass *klass, void *data)
1315 {
1316     DeviceClass *dc = DEVICE_CLASS(klass);
1317     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
1318 
1319     device_class_set_props(dc, virtio_blk_properties);
1320     dc->vmsd = &vmstate_virtio_blk;
1321     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1322     vdc->realize = virtio_blk_device_realize;
1323     vdc->unrealize = virtio_blk_device_unrealize;
1324     vdc->get_config = virtio_blk_update_config;
1325     vdc->set_config = virtio_blk_set_config;
1326     vdc->get_features = virtio_blk_get_features;
1327     vdc->set_status = virtio_blk_set_status;
1328     vdc->reset = virtio_blk_reset;
1329     vdc->save = virtio_blk_save_device;
1330     vdc->load = virtio_blk_load_device;
1331     vdc->start_ioeventfd = virtio_blk_data_plane_start;
1332     vdc->stop_ioeventfd = virtio_blk_data_plane_stop;
1333 }
1334 
1335 static const TypeInfo virtio_blk_info = {
1336     .name = TYPE_VIRTIO_BLK,
1337     .parent = TYPE_VIRTIO_DEVICE,
1338     .instance_size = sizeof(VirtIOBlock),
1339     .instance_init = virtio_blk_instance_init,
1340     .class_init = virtio_blk_class_init,
1341 };
1342 
1343 static void virtio_register_types(void)
1344 {
1345     type_register_static(&virtio_blk_info);
1346 }
1347 
1348 type_init(virtio_register_types)
1349