]> Git Repo - qemu.git/blob - block.c
Merge remote-tracking branch 'remotes/kvm/tags/for-upstream' into staging
[qemu.git] / block.c
1 /*
2  * QEMU System Emulator block driver
3  *
4  * Copyright (c) 2003 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/sysemu.h"
32 #include "qemu/notify.h"
33 #include "block/coroutine.h"
34 #include "block/qapi.h"
35 #include "qmp-commands.h"
36 #include "qemu/timer.h"
37 #include "qapi-event.h"
38
39 #ifdef CONFIG_BSD
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <sys/ioctl.h>
43 #include <sys/queue.h>
44 #ifndef __DragonFly__
45 #include <sys/disk.h>
46 #endif
47 #endif
48
49 #ifdef _WIN32
50 #include <windows.h>
51 #endif
52
53 struct BdrvDirtyBitmap {
54     HBitmap *bitmap;
55     QLIST_ENTRY(BdrvDirtyBitmap) list;
56 };
57
58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
59
60 #define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */
61
62 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
63 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
64         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
65         BlockDriverCompletionFunc *cb, void *opaque);
66 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
67         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
68         BlockDriverCompletionFunc *cb, void *opaque);
69 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
70                                          int64_t sector_num, int nb_sectors,
71                                          QEMUIOVector *iov);
72 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
73                                          int64_t sector_num, int nb_sectors,
74                                          QEMUIOVector *iov);
75 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
76     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
77     BdrvRequestFlags flags);
78 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
79     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
80     BdrvRequestFlags flags);
81 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
82                                                int64_t sector_num,
83                                                QEMUIOVector *qiov,
84                                                int nb_sectors,
85                                                BdrvRequestFlags flags,
86                                                BlockDriverCompletionFunc *cb,
87                                                void *opaque,
88                                                bool is_write);
89 static void coroutine_fn bdrv_co_do_rw(void *opaque);
90 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
91     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
92
93 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
94     QTAILQ_HEAD_INITIALIZER(bdrv_states);
95
96 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
97     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
98
99 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
100     QLIST_HEAD_INITIALIZER(bdrv_drivers);
101
102 /* If non-zero, use only whitelisted block drivers */
103 static int use_bdrv_whitelist;
104
105 #ifdef _WIN32
106 static int is_windows_drive_prefix(const char *filename)
107 {
108     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
109              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
110             filename[1] == ':');
111 }
112
113 int is_windows_drive(const char *filename)
114 {
115     if (is_windows_drive_prefix(filename) &&
116         filename[2] == '\0')
117         return 1;
118     if (strstart(filename, "\\\\.\\", NULL) ||
119         strstart(filename, "//./", NULL))
120         return 1;
121     return 0;
122 }
123 #endif
124
125 /* throttling disk I/O limits */
126 void bdrv_set_io_limits(BlockDriverState *bs,
127                         ThrottleConfig *cfg)
128 {
129     int i;
130
131     throttle_config(&bs->throttle_state, cfg);
132
133     for (i = 0; i < 2; i++) {
134         qemu_co_enter_next(&bs->throttled_reqs[i]);
135     }
136 }
137
138 /* this function drain all the throttled IOs */
139 static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
140 {
141     bool drained = false;
142     bool enabled = bs->io_limits_enabled;
143     int i;
144
145     bs->io_limits_enabled = false;
146
147     for (i = 0; i < 2; i++) {
148         while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
149             drained = true;
150         }
151     }
152
153     bs->io_limits_enabled = enabled;
154
155     return drained;
156 }
157
158 void bdrv_io_limits_disable(BlockDriverState *bs)
159 {
160     bs->io_limits_enabled = false;
161
162     bdrv_start_throttled_reqs(bs);
163
164     throttle_destroy(&bs->throttle_state);
165 }
166
167 static void bdrv_throttle_read_timer_cb(void *opaque)
168 {
169     BlockDriverState *bs = opaque;
170     qemu_co_enter_next(&bs->throttled_reqs[0]);
171 }
172
173 static void bdrv_throttle_write_timer_cb(void *opaque)
174 {
175     BlockDriverState *bs = opaque;
176     qemu_co_enter_next(&bs->throttled_reqs[1]);
177 }
178
179 /* should be called before bdrv_set_io_limits if a limit is set */
180 void bdrv_io_limits_enable(BlockDriverState *bs)
181 {
182     assert(!bs->io_limits_enabled);
183     throttle_init(&bs->throttle_state,
184                   bdrv_get_aio_context(bs),
185                   QEMU_CLOCK_VIRTUAL,
186                   bdrv_throttle_read_timer_cb,
187                   bdrv_throttle_write_timer_cb,
188                   bs);
189     bs->io_limits_enabled = true;
190 }
191
192 /* This function makes an IO wait if needed
193  *
194  * @nb_sectors: the number of sectors of the IO
195  * @is_write:   is the IO a write
196  */
197 static void bdrv_io_limits_intercept(BlockDriverState *bs,
198                                      unsigned int bytes,
199                                      bool is_write)
200 {
201     /* does this io must wait */
202     bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
203
204     /* if must wait or any request of this type throttled queue the IO */
205     if (must_wait ||
206         !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
207         qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
208     }
209
210     /* the IO will be executed, do the accounting */
211     throttle_account(&bs->throttle_state, is_write, bytes);
212
213
214     /* if the next request must wait -> do nothing */
215     if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
216         return;
217     }
218
219     /* else queue next request for execution */
220     qemu_co_queue_next(&bs->throttled_reqs[is_write]);
221 }
222
223 size_t bdrv_opt_mem_align(BlockDriverState *bs)
224 {
225     if (!bs || !bs->drv) {
226         /* 4k should be on the safe side */
227         return 4096;
228     }
229
230     return bs->bl.opt_mem_alignment;
231 }
232
233 /* check if the path starts with "<protocol>:" */
234 static int path_has_protocol(const char *path)
235 {
236     const char *p;
237
238 #ifdef _WIN32
239     if (is_windows_drive(path) ||
240         is_windows_drive_prefix(path)) {
241         return 0;
242     }
243     p = path + strcspn(path, ":/\\");
244 #else
245     p = path + strcspn(path, ":/");
246 #endif
247
248     return *p == ':';
249 }
250
251 int path_is_absolute(const char *path)
252 {
253 #ifdef _WIN32
254     /* specific case for names like: "\\.\d:" */
255     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
256         return 1;
257     }
258     return (*path == '/' || *path == '\\');
259 #else
260     return (*path == '/');
261 #endif
262 }
263
264 /* if filename is absolute, just copy it to dest. Otherwise, build a
265    path to it by considering it is relative to base_path. URL are
266    supported. */
267 void path_combine(char *dest, int dest_size,
268                   const char *base_path,
269                   const char *filename)
270 {
271     const char *p, *p1;
272     int len;
273
274     if (dest_size <= 0)
275         return;
276     if (path_is_absolute(filename)) {
277         pstrcpy(dest, dest_size, filename);
278     } else {
279         p = strchr(base_path, ':');
280         if (p)
281             p++;
282         else
283             p = base_path;
284         p1 = strrchr(base_path, '/');
285 #ifdef _WIN32
286         {
287             const char *p2;
288             p2 = strrchr(base_path, '\\');
289             if (!p1 || p2 > p1)
290                 p1 = p2;
291         }
292 #endif
293         if (p1)
294             p1++;
295         else
296             p1 = base_path;
297         if (p1 > p)
298             p = p1;
299         len = p - base_path;
300         if (len > dest_size - 1)
301             len = dest_size - 1;
302         memcpy(dest, base_path, len);
303         dest[len] = '\0';
304         pstrcat(dest, dest_size, filename);
305     }
306 }
307
308 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
309 {
310     if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
311         pstrcpy(dest, sz, bs->backing_file);
312     } else {
313         path_combine(dest, sz, bs->filename, bs->backing_file);
314     }
315 }
316
317 void bdrv_register(BlockDriver *bdrv)
318 {
319     /* Block drivers without coroutine functions need emulation */
320     if (!bdrv->bdrv_co_readv) {
321         bdrv->bdrv_co_readv = bdrv_co_readv_em;
322         bdrv->bdrv_co_writev = bdrv_co_writev_em;
323
324         /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
325          * the block driver lacks aio we need to emulate that too.
326          */
327         if (!bdrv->bdrv_aio_readv) {
328             /* add AIO emulation layer */
329             bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
330             bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
331         }
332     }
333
334     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
335 }
336
337 /* create a new block device (by default it is empty) */
338 BlockDriverState *bdrv_new(const char *device_name, Error **errp)
339 {
340     BlockDriverState *bs;
341     int i;
342
343     if (bdrv_find(device_name)) {
344         error_setg(errp, "Device with id '%s' already exists",
345                    device_name);
346         return NULL;
347     }
348     if (bdrv_find_node(device_name)) {
349         error_setg(errp, "Device with node-name '%s' already exists",
350                    device_name);
351         return NULL;
352     }
353
354     bs = g_new0(BlockDriverState, 1);
355     QLIST_INIT(&bs->dirty_bitmaps);
356     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
357     if (device_name[0] != '\0') {
358         QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
359     }
360     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
361         QLIST_INIT(&bs->op_blockers[i]);
362     }
363     bdrv_iostatus_disable(bs);
364     notifier_list_init(&bs->close_notifiers);
365     notifier_with_return_list_init(&bs->before_write_notifiers);
366     qemu_co_queue_init(&bs->throttled_reqs[0]);
367     qemu_co_queue_init(&bs->throttled_reqs[1]);
368     bs->refcnt = 1;
369     bs->aio_context = qemu_get_aio_context();
370
371     return bs;
372 }
373
374 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
375 {
376     notifier_list_add(&bs->close_notifiers, notify);
377 }
378
379 BlockDriver *bdrv_find_format(const char *format_name)
380 {
381     BlockDriver *drv1;
382     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
383         if (!strcmp(drv1->format_name, format_name)) {
384             return drv1;
385         }
386     }
387     return NULL;
388 }
389
390 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
391 {
392     static const char *whitelist_rw[] = {
393         CONFIG_BDRV_RW_WHITELIST
394     };
395     static const char *whitelist_ro[] = {
396         CONFIG_BDRV_RO_WHITELIST
397     };
398     const char **p;
399
400     if (!whitelist_rw[0] && !whitelist_ro[0]) {
401         return 1;               /* no whitelist, anything goes */
402     }
403
404     for (p = whitelist_rw; *p; p++) {
405         if (!strcmp(drv->format_name, *p)) {
406             return 1;
407         }
408     }
409     if (read_only) {
410         for (p = whitelist_ro; *p; p++) {
411             if (!strcmp(drv->format_name, *p)) {
412                 return 1;
413             }
414         }
415     }
416     return 0;
417 }
418
419 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
420                                           bool read_only)
421 {
422     BlockDriver *drv = bdrv_find_format(format_name);
423     return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
424 }
425
426 typedef struct CreateCo {
427     BlockDriver *drv;
428     char *filename;
429     QemuOpts *opts;
430     int ret;
431     Error *err;
432 } CreateCo;
433
434 static void coroutine_fn bdrv_create_co_entry(void *opaque)
435 {
436     Error *local_err = NULL;
437     int ret;
438
439     CreateCo *cco = opaque;
440     assert(cco->drv);
441
442     ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
443     if (local_err) {
444         error_propagate(&cco->err, local_err);
445     }
446     cco->ret = ret;
447 }
448
449 int bdrv_create(BlockDriver *drv, const char* filename,
450                 QemuOpts *opts, Error **errp)
451 {
452     int ret;
453
454     Coroutine *co;
455     CreateCo cco = {
456         .drv = drv,
457         .filename = g_strdup(filename),
458         .opts = opts,
459         .ret = NOT_DONE,
460         .err = NULL,
461     };
462
463     if (!drv->bdrv_create) {
464         error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
465         ret = -ENOTSUP;
466         goto out;
467     }
468
469     if (qemu_in_coroutine()) {
470         /* Fast-path if already in coroutine context */
471         bdrv_create_co_entry(&cco);
472     } else {
473         co = qemu_coroutine_create(bdrv_create_co_entry);
474         qemu_coroutine_enter(co, &cco);
475         while (cco.ret == NOT_DONE) {
476             aio_poll(qemu_get_aio_context(), true);
477         }
478     }
479
480     ret = cco.ret;
481     if (ret < 0) {
482         if (cco.err) {
483             error_propagate(errp, cco.err);
484         } else {
485             error_setg_errno(errp, -ret, "Could not create image");
486         }
487     }
488
489 out:
490     g_free(cco.filename);
491     return ret;
492 }
493
494 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
495 {
496     BlockDriver *drv;
497     Error *local_err = NULL;
498     int ret;
499
500     drv = bdrv_find_protocol(filename, true);
501     if (drv == NULL) {
502         error_setg(errp, "Could not find protocol for file '%s'", filename);
503         return -ENOENT;
504     }
505
506     ret = bdrv_create(drv, filename, opts, &local_err);
507     if (local_err) {
508         error_propagate(errp, local_err);
509     }
510     return ret;
511 }
512
513 void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
514 {
515     BlockDriver *drv = bs->drv;
516     Error *local_err = NULL;
517
518     memset(&bs->bl, 0, sizeof(bs->bl));
519
520     if (!drv) {
521         return;
522     }
523
524     /* Take some limits from the children as a default */
525     if (bs->file) {
526         bdrv_refresh_limits(bs->file, &local_err);
527         if (local_err) {
528             error_propagate(errp, local_err);
529             return;
530         }
531         bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
532         bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
533     } else {
534         bs->bl.opt_mem_alignment = 512;
535     }
536
537     if (bs->backing_hd) {
538         bdrv_refresh_limits(bs->backing_hd, &local_err);
539         if (local_err) {
540             error_propagate(errp, local_err);
541             return;
542         }
543         bs->bl.opt_transfer_length =
544             MAX(bs->bl.opt_transfer_length,
545                 bs->backing_hd->bl.opt_transfer_length);
546         bs->bl.opt_mem_alignment =
547             MAX(bs->bl.opt_mem_alignment,
548                 bs->backing_hd->bl.opt_mem_alignment);
549     }
550
551     /* Then let the driver override it */
552     if (drv->bdrv_refresh_limits) {
553         drv->bdrv_refresh_limits(bs, errp);
554     }
555 }
556
557 /*
558  * Create a uniquely-named empty temporary file.
559  * Return 0 upon success, otherwise a negative errno value.
560  */
561 int get_tmp_filename(char *filename, int size)
562 {
563 #ifdef _WIN32
564     char temp_dir[MAX_PATH];
565     /* GetTempFileName requires that its output buffer (4th param)
566        have length MAX_PATH or greater.  */
567     assert(size >= MAX_PATH);
568     return (GetTempPath(MAX_PATH, temp_dir)
569             && GetTempFileName(temp_dir, "qem", 0, filename)
570             ? 0 : -GetLastError());
571 #else
572     int fd;
573     const char *tmpdir;
574     tmpdir = getenv("TMPDIR");
575     if (!tmpdir) {
576         tmpdir = "/var/tmp";
577     }
578     if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
579         return -EOVERFLOW;
580     }
581     fd = mkstemp(filename);
582     if (fd < 0) {
583         return -errno;
584     }
585     if (close(fd) != 0) {
586         unlink(filename);
587         return -errno;
588     }
589     return 0;
590 #endif
591 }
592
593 /*
594  * Detect host devices. By convention, /dev/cdrom[N] is always
595  * recognized as a host CDROM.
596  */
597 static BlockDriver *find_hdev_driver(const char *filename)
598 {
599     int score_max = 0, score;
600     BlockDriver *drv = NULL, *d;
601
602     QLIST_FOREACH(d, &bdrv_drivers, list) {
603         if (d->bdrv_probe_device) {
604             score = d->bdrv_probe_device(filename);
605             if (score > score_max) {
606                 score_max = score;
607                 drv = d;
608             }
609         }
610     }
611
612     return drv;
613 }
614
615 BlockDriver *bdrv_find_protocol(const char *filename,
616                                 bool allow_protocol_prefix)
617 {
618     BlockDriver *drv1;
619     char protocol[128];
620     int len;
621     const char *p;
622
623     /* TODO Drivers without bdrv_file_open must be specified explicitly */
624
625     /*
626      * XXX(hch): we really should not let host device detection
627      * override an explicit protocol specification, but moving this
628      * later breaks access to device names with colons in them.
629      * Thanks to the brain-dead persistent naming schemes on udev-
630      * based Linux systems those actually are quite common.
631      */
632     drv1 = find_hdev_driver(filename);
633     if (drv1) {
634         return drv1;
635     }
636
637     if (!path_has_protocol(filename) || !allow_protocol_prefix) {
638         return bdrv_find_format("file");
639     }
640
641     p = strchr(filename, ':');
642     assert(p != NULL);
643     len = p - filename;
644     if (len > sizeof(protocol) - 1)
645         len = sizeof(protocol) - 1;
646     memcpy(protocol, filename, len);
647     protocol[len] = '\0';
648     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
649         if (drv1->protocol_name &&
650             !strcmp(drv1->protocol_name, protocol)) {
651             return drv1;
652         }
653     }
654     return NULL;
655 }
656
657 static int find_image_format(BlockDriverState *bs, const char *filename,
658                              BlockDriver **pdrv, Error **errp)
659 {
660     int score, score_max;
661     BlockDriver *drv1, *drv;
662     uint8_t buf[2048];
663     int ret = 0;
664
665     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
666     if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
667         drv = bdrv_find_format("raw");
668         if (!drv) {
669             error_setg(errp, "Could not find raw image format");
670             ret = -ENOENT;
671         }
672         *pdrv = drv;
673         return ret;
674     }
675
676     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
677     if (ret < 0) {
678         error_setg_errno(errp, -ret, "Could not read image for determining its "
679                          "format");
680         *pdrv = NULL;
681         return ret;
682     }
683
684     score_max = 0;
685     drv = NULL;
686     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
687         if (drv1->bdrv_probe) {
688             score = drv1->bdrv_probe(buf, ret, filename);
689             if (score > score_max) {
690                 score_max = score;
691                 drv = drv1;
692             }
693         }
694     }
695     if (!drv) {
696         error_setg(errp, "Could not determine image format: No compatible "
697                    "driver found");
698         ret = -ENOENT;
699     }
700     *pdrv = drv;
701     return ret;
702 }
703
704 /**
705  * Set the current 'total_sectors' value
706  * Return 0 on success, -errno on error.
707  */
708 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
709 {
710     BlockDriver *drv = bs->drv;
711
712     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
713     if (bs->sg)
714         return 0;
715
716     /* query actual device if possible, otherwise just trust the hint */
717     if (drv->bdrv_getlength) {
718         int64_t length = drv->bdrv_getlength(bs);
719         if (length < 0) {
720             return length;
721         }
722         hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
723     }
724
725     bs->total_sectors = hint;
726     return 0;
727 }
728
729 /**
730  * Set open flags for a given discard mode
731  *
732  * Return 0 on success, -1 if the discard mode was invalid.
733  */
734 int bdrv_parse_discard_flags(const char *mode, int *flags)
735 {
736     *flags &= ~BDRV_O_UNMAP;
737
738     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
739         /* do nothing */
740     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
741         *flags |= BDRV_O_UNMAP;
742     } else {
743         return -1;
744     }
745
746     return 0;
747 }
748
749 /**
750  * Set open flags for a given cache mode
751  *
752  * Return 0 on success, -1 if the cache mode was invalid.
753  */
754 int bdrv_parse_cache_flags(const char *mode, int *flags)
755 {
756     *flags &= ~BDRV_O_CACHE_MASK;
757
758     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
759         *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
760     } else if (!strcmp(mode, "directsync")) {
761         *flags |= BDRV_O_NOCACHE;
762     } else if (!strcmp(mode, "writeback")) {
763         *flags |= BDRV_O_CACHE_WB;
764     } else if (!strcmp(mode, "unsafe")) {
765         *flags |= BDRV_O_CACHE_WB;
766         *flags |= BDRV_O_NO_FLUSH;
767     } else if (!strcmp(mode, "writethrough")) {
768         /* this is the default */
769     } else {
770         return -1;
771     }
772
773     return 0;
774 }
775
776 /**
777  * The copy-on-read flag is actually a reference count so multiple users may
778  * use the feature without worrying about clobbering its previous state.
779  * Copy-on-read stays enabled until all users have called to disable it.
780  */
781 void bdrv_enable_copy_on_read(BlockDriverState *bs)
782 {
783     bs->copy_on_read++;
784 }
785
786 void bdrv_disable_copy_on_read(BlockDriverState *bs)
787 {
788     assert(bs->copy_on_read > 0);
789     bs->copy_on_read--;
790 }
791
792 /*
793  * Returns the flags that a temporary snapshot should get, based on the
794  * originally requested flags (the originally requested image will have flags
795  * like a backing file)
796  */
797 static int bdrv_temp_snapshot_flags(int flags)
798 {
799     return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
800 }
801
802 /*
803  * Returns the flags that bs->file should get, based on the given flags for
804  * the parent BDS
805  */
806 static int bdrv_inherited_flags(int flags)
807 {
808     /* Enable protocol handling, disable format probing for bs->file */
809     flags |= BDRV_O_PROTOCOL;
810
811     /* Our block drivers take care to send flushes and respect unmap policy,
812      * so we can enable both unconditionally on lower layers. */
813     flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
814
815     /* Clear flags that only apply to the top layer */
816     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
817
818     return flags;
819 }
820
821 /*
822  * Returns the flags that bs->backing_hd should get, based on the given flags
823  * for the parent BDS
824  */
825 static int bdrv_backing_flags(int flags)
826 {
827     /* backing files always opened read-only */
828     flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
829
830     /* snapshot=on is handled on the top layer */
831     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
832
833     return flags;
834 }
835
836 static int bdrv_open_flags(BlockDriverState *bs, int flags)
837 {
838     int open_flags = flags | BDRV_O_CACHE_WB;
839
840     /*
841      * Clear flags that are internal to the block layer before opening the
842      * image.
843      */
844     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
845
846     /*
847      * Snapshots should be writable.
848      */
849     if (flags & BDRV_O_TEMPORARY) {
850         open_flags |= BDRV_O_RDWR;
851     }
852
853     return open_flags;
854 }
855
856 static void bdrv_assign_node_name(BlockDriverState *bs,
857                                   const char *node_name,
858                                   Error **errp)
859 {
860     if (!node_name) {
861         return;
862     }
863
864     /* empty string node name is invalid */
865     if (node_name[0] == '\0') {
866         error_setg(errp, "Empty node name");
867         return;
868     }
869
870     /* takes care of avoiding namespaces collisions */
871     if (bdrv_find(node_name)) {
872         error_setg(errp, "node-name=%s is conflicting with a device id",
873                    node_name);
874         return;
875     }
876
877     /* takes care of avoiding duplicates node names */
878     if (bdrv_find_node(node_name)) {
879         error_setg(errp, "Duplicate node name");
880         return;
881     }
882
883     /* copy node name into the bs and insert it into the graph list */
884     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
885     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
886 }
887
888 /*
889  * Common part for opening disk images and files
890  *
891  * Removes all processed options from *options.
892  */
893 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
894     QDict *options, int flags, BlockDriver *drv, Error **errp)
895 {
896     int ret, open_flags;
897     const char *filename;
898     const char *node_name = NULL;
899     Error *local_err = NULL;
900
901     assert(drv != NULL);
902     assert(bs->file == NULL);
903     assert(options != NULL && bs->options != options);
904
905     if (file != NULL) {
906         filename = file->filename;
907     } else {
908         filename = qdict_get_try_str(options, "filename");
909     }
910
911     if (drv->bdrv_needs_filename && !filename) {
912         error_setg(errp, "The '%s' block driver requires a file name",
913                    drv->format_name);
914         return -EINVAL;
915     }
916
917     trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
918
919     node_name = qdict_get_try_str(options, "node-name");
920     bdrv_assign_node_name(bs, node_name, &local_err);
921     if (local_err) {
922         error_propagate(errp, local_err);
923         return -EINVAL;
924     }
925     qdict_del(options, "node-name");
926
927     /* bdrv_open() with directly using a protocol as drv. This layer is already
928      * opened, so assign it to bs (while file becomes a closed BlockDriverState)
929      * and return immediately. */
930     if (file != NULL && drv->bdrv_file_open) {
931         bdrv_swap(file, bs);
932         return 0;
933     }
934
935     bs->open_flags = flags;
936     bs->guest_block_size = 512;
937     bs->request_alignment = 512;
938     bs->zero_beyond_eof = true;
939     open_flags = bdrv_open_flags(bs, flags);
940     bs->read_only = !(open_flags & BDRV_O_RDWR);
941     bs->growable = !!(flags & BDRV_O_PROTOCOL);
942
943     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
944         error_setg(errp,
945                    !bs->read_only && bdrv_is_whitelisted(drv, true)
946                         ? "Driver '%s' can only be used for read-only devices"
947                         : "Driver '%s' is not whitelisted",
948                    drv->format_name);
949         return -ENOTSUP;
950     }
951
952     assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
953     if (flags & BDRV_O_COPY_ON_READ) {
954         if (!bs->read_only) {
955             bdrv_enable_copy_on_read(bs);
956         } else {
957             error_setg(errp, "Can't use copy-on-read on read-only device");
958             return -EINVAL;
959         }
960     }
961
962     if (filename != NULL) {
963         pstrcpy(bs->filename, sizeof(bs->filename), filename);
964     } else {
965         bs->filename[0] = '\0';
966     }
967     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
968
969     bs->drv = drv;
970     bs->opaque = g_malloc0(drv->instance_size);
971
972     bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
973
974     /* Open the image, either directly or using a protocol */
975     if (drv->bdrv_file_open) {
976         assert(file == NULL);
977         assert(!drv->bdrv_needs_filename || filename != NULL);
978         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
979     } else {
980         if (file == NULL) {
981             error_setg(errp, "Can't use '%s' as a block driver for the "
982                        "protocol level", drv->format_name);
983             ret = -EINVAL;
984             goto free_and_fail;
985         }
986         bs->file = file;
987         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
988     }
989
990     if (ret < 0) {
991         if (local_err) {
992             error_propagate(errp, local_err);
993         } else if (bs->filename[0]) {
994             error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
995         } else {
996             error_setg_errno(errp, -ret, "Could not open image");
997         }
998         goto free_and_fail;
999     }
1000
1001     ret = refresh_total_sectors(bs, bs->total_sectors);
1002     if (ret < 0) {
1003         error_setg_errno(errp, -ret, "Could not refresh total sector count");
1004         goto free_and_fail;
1005     }
1006
1007     bdrv_refresh_limits(bs, &local_err);
1008     if (local_err) {
1009         error_propagate(errp, local_err);
1010         ret = -EINVAL;
1011         goto free_and_fail;
1012     }
1013
1014     assert(bdrv_opt_mem_align(bs) != 0);
1015     assert((bs->request_alignment != 0) || bs->sg);
1016     return 0;
1017
1018 free_and_fail:
1019     bs->file = NULL;
1020     g_free(bs->opaque);
1021     bs->opaque = NULL;
1022     bs->drv = NULL;
1023     return ret;
1024 }
1025
1026 static QDict *parse_json_filename(const char *filename, Error **errp)
1027 {
1028     QObject *options_obj;
1029     QDict *options;
1030     int ret;
1031
1032     ret = strstart(filename, "json:", &filename);
1033     assert(ret);
1034
1035     options_obj = qobject_from_json(filename);
1036     if (!options_obj) {
1037         error_setg(errp, "Could not parse the JSON options");
1038         return NULL;
1039     }
1040
1041     if (qobject_type(options_obj) != QTYPE_QDICT) {
1042         qobject_decref(options_obj);
1043         error_setg(errp, "Invalid JSON object given");
1044         return NULL;
1045     }
1046
1047     options = qobject_to_qdict(options_obj);
1048     qdict_flatten(options);
1049
1050     return options;
1051 }
1052
1053 /*
1054  * Fills in default options for opening images and converts the legacy
1055  * filename/flags pair to option QDict entries.
1056  */
1057 static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
1058                              BlockDriver *drv, Error **errp)
1059 {
1060     const char *filename = *pfilename;
1061     const char *drvname;
1062     bool protocol = flags & BDRV_O_PROTOCOL;
1063     bool parse_filename = false;
1064     Error *local_err = NULL;
1065
1066     /* Parse json: pseudo-protocol */
1067     if (filename && g_str_has_prefix(filename, "json:")) {
1068         QDict *json_options = parse_json_filename(filename, &local_err);
1069         if (local_err) {
1070             error_propagate(errp, local_err);
1071             return -EINVAL;
1072         }
1073
1074         /* Options given in the filename have lower priority than options
1075          * specified directly */
1076         qdict_join(*options, json_options, false);
1077         QDECREF(json_options);
1078         *pfilename = filename = NULL;
1079     }
1080
1081     /* Fetch the file name from the options QDict if necessary */
1082     if (protocol && filename) {
1083         if (!qdict_haskey(*options, "filename")) {
1084             qdict_put(*options, "filename", qstring_from_str(filename));
1085             parse_filename = true;
1086         } else {
1087             error_setg(errp, "Can't specify 'file' and 'filename' options at "
1088                              "the same time");
1089             return -EINVAL;
1090         }
1091     }
1092
1093     /* Find the right block driver */
1094     filename = qdict_get_try_str(*options, "filename");
1095     drvname = qdict_get_try_str(*options, "driver");
1096
1097     if (drv) {
1098         if (drvname) {
1099             error_setg(errp, "Driver specified twice");
1100             return -EINVAL;
1101         }
1102         drvname = drv->format_name;
1103         qdict_put(*options, "driver", qstring_from_str(drvname));
1104     } else {
1105         if (!drvname && protocol) {
1106             if (filename) {
1107                 drv = bdrv_find_protocol(filename, parse_filename);
1108                 if (!drv) {
1109                     error_setg(errp, "Unknown protocol");
1110                     return -EINVAL;
1111                 }
1112
1113                 drvname = drv->format_name;
1114                 qdict_put(*options, "driver", qstring_from_str(drvname));
1115             } else {
1116                 error_setg(errp, "Must specify either driver or file");
1117                 return -EINVAL;
1118             }
1119         } else if (drvname) {
1120             drv = bdrv_find_format(drvname);
1121             if (!drv) {
1122                 error_setg(errp, "Unknown driver '%s'", drvname);
1123                 return -ENOENT;
1124             }
1125         }
1126     }
1127
1128     assert(drv || !protocol);
1129
1130     /* Driver-specific filename parsing */
1131     if (drv && drv->bdrv_parse_filename && parse_filename) {
1132         drv->bdrv_parse_filename(filename, *options, &local_err);
1133         if (local_err) {
1134             error_propagate(errp, local_err);
1135             return -EINVAL;
1136         }
1137
1138         if (!drv->bdrv_needs_filename) {
1139             qdict_del(*options, "filename");
1140         }
1141     }
1142
1143     return 0;
1144 }
1145
1146 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1147 {
1148
1149     if (bs->backing_hd) {
1150         assert(bs->backing_blocker);
1151         bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1152     } else if (backing_hd) {
1153         error_setg(&bs->backing_blocker,
1154                    "device is used as backing hd of '%s'",
1155                    bs->device_name);
1156     }
1157
1158     bs->backing_hd = backing_hd;
1159     if (!backing_hd) {
1160         error_free(bs->backing_blocker);
1161         bs->backing_blocker = NULL;
1162         goto out;
1163     }
1164     bs->open_flags &= ~BDRV_O_NO_BACKING;
1165     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1166     pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1167             backing_hd->drv ? backing_hd->drv->format_name : "");
1168
1169     bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1170     /* Otherwise we won't be able to commit due to check in bdrv_commit */
1171     bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1172                     bs->backing_blocker);
1173 out:
1174     bdrv_refresh_limits(bs, NULL);
1175 }
1176
1177 /*
1178  * Opens the backing file for a BlockDriverState if not yet open
1179  *
1180  * options is a QDict of options to pass to the block drivers, or NULL for an
1181  * empty set of options. The reference to the QDict is transferred to this
1182  * function (even on failure), so if the caller intends to reuse the dictionary,
1183  * it needs to use QINCREF() before calling bdrv_file_open.
1184  */
1185 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1186 {
1187     char *backing_filename = g_malloc0(PATH_MAX);
1188     int ret = 0;
1189     BlockDriver *back_drv = NULL;
1190     BlockDriverState *backing_hd;
1191     Error *local_err = NULL;
1192
1193     if (bs->backing_hd != NULL) {
1194         QDECREF(options);
1195         goto free_exit;
1196     }
1197
1198     /* NULL means an empty set of options */
1199     if (options == NULL) {
1200         options = qdict_new();
1201     }
1202
1203     bs->open_flags &= ~BDRV_O_NO_BACKING;
1204     if (qdict_haskey(options, "file.filename")) {
1205         backing_filename[0] = '\0';
1206     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1207         QDECREF(options);
1208         goto free_exit;
1209     } else {
1210         bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
1211     }
1212
1213     if (!bs->drv || !bs->drv->supports_backing) {
1214         ret = -EINVAL;
1215         error_setg(errp, "Driver doesn't support backing files");
1216         QDECREF(options);
1217         goto free_exit;
1218     }
1219
1220     backing_hd = bdrv_new("", errp);
1221
1222     if (bs->backing_format[0] != '\0') {
1223         back_drv = bdrv_find_format(bs->backing_format);
1224     }
1225
1226     assert(bs->backing_hd == NULL);
1227     ret = bdrv_open(&backing_hd,
1228                     *backing_filename ? backing_filename : NULL, NULL, options,
1229                     bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
1230     if (ret < 0) {
1231         bdrv_unref(backing_hd);
1232         backing_hd = NULL;
1233         bs->open_flags |= BDRV_O_NO_BACKING;
1234         error_setg(errp, "Could not open backing file: %s",
1235                    error_get_pretty(local_err));
1236         error_free(local_err);
1237         goto free_exit;
1238     }
1239     bdrv_set_backing_hd(bs, backing_hd);
1240
1241 free_exit:
1242     g_free(backing_filename);
1243     return ret;
1244 }
1245
1246 /*
1247  * Opens a disk image whose options are given as BlockdevRef in another block
1248  * device's options.
1249  *
1250  * If allow_none is true, no image will be opened if filename is false and no
1251  * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1252  *
1253  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1254  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1255  * itself, all options starting with "${bdref_key}." are considered part of the
1256  * BlockdevRef.
1257  *
1258  * The BlockdevRef will be removed from the options QDict.
1259  *
1260  * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1261  */
1262 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1263                     QDict *options, const char *bdref_key, int flags,
1264                     bool allow_none, Error **errp)
1265 {
1266     QDict *image_options;
1267     int ret;
1268     char *bdref_key_dot;
1269     const char *reference;
1270
1271     assert(pbs);
1272     assert(*pbs == NULL);
1273
1274     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1275     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1276     g_free(bdref_key_dot);
1277
1278     reference = qdict_get_try_str(options, bdref_key);
1279     if (!filename && !reference && !qdict_size(image_options)) {
1280         if (allow_none) {
1281             ret = 0;
1282         } else {
1283             error_setg(errp, "A block device must be specified for \"%s\"",
1284                        bdref_key);
1285             ret = -EINVAL;
1286         }
1287         QDECREF(image_options);
1288         goto done;
1289     }
1290
1291     ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
1292
1293 done:
1294     qdict_del(options, bdref_key);
1295     return ret;
1296 }
1297
1298 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1299 {
1300     /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1301     char *tmp_filename = g_malloc0(PATH_MAX + 1);
1302     int64_t total_size;
1303     BlockDriver *bdrv_qcow2;
1304     QemuOpts *opts = NULL;
1305     QDict *snapshot_options;
1306     BlockDriverState *bs_snapshot;
1307     Error *local_err;
1308     int ret;
1309
1310     /* if snapshot, we create a temporary backing file and open it
1311        instead of opening 'filename' directly */
1312
1313     /* Get the required size from the image */
1314     total_size = bdrv_getlength(bs);
1315     if (total_size < 0) {
1316         ret = total_size;
1317         error_setg_errno(errp, -total_size, "Could not get image size");
1318         goto out;
1319     }
1320
1321     /* Create the temporary image */
1322     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1323     if (ret < 0) {
1324         error_setg_errno(errp, -ret, "Could not get temporary filename");
1325         goto out;
1326     }
1327
1328     bdrv_qcow2 = bdrv_find_format("qcow2");
1329     opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1330                             &error_abort);
1331     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
1332     ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
1333     qemu_opts_del(opts);
1334     if (ret < 0) {
1335         error_setg_errno(errp, -ret, "Could not create temporary overlay "
1336                          "'%s': %s", tmp_filename,
1337                          error_get_pretty(local_err));
1338         error_free(local_err);
1339         goto out;
1340     }
1341
1342     /* Prepare a new options QDict for the temporary file */
1343     snapshot_options = qdict_new();
1344     qdict_put(snapshot_options, "file.driver",
1345               qstring_from_str("file"));
1346     qdict_put(snapshot_options, "file.filename",
1347               qstring_from_str(tmp_filename));
1348
1349     bs_snapshot = bdrv_new("", &error_abort);
1350
1351     ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1352                     flags, bdrv_qcow2, &local_err);
1353     if (ret < 0) {
1354         error_propagate(errp, local_err);
1355         goto out;
1356     }
1357
1358     bdrv_append(bs_snapshot, bs);
1359
1360 out:
1361     g_free(tmp_filename);
1362     return ret;
1363 }
1364
1365 /*
1366  * Opens a disk image (raw, qcow2, vmdk, ...)
1367  *
1368  * options is a QDict of options to pass to the block drivers, or NULL for an
1369  * empty set of options. The reference to the QDict belongs to the block layer
1370  * after the call (even on failure), so if the caller intends to reuse the
1371  * dictionary, it needs to use QINCREF() before calling bdrv_open.
1372  *
1373  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1374  * If it is not NULL, the referenced BDS will be reused.
1375  *
1376  * The reference parameter may be used to specify an existing block device which
1377  * should be opened. If specified, neither options nor a filename may be given,
1378  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1379  */
1380 int bdrv_open(BlockDriverState **pbs, const char *filename,
1381               const char *reference, QDict *options, int flags,
1382               BlockDriver *drv, Error **errp)
1383 {
1384     int ret;
1385     BlockDriverState *file = NULL, *bs;
1386     const char *drvname;
1387     Error *local_err = NULL;
1388     int snapshot_flags = 0;
1389
1390     assert(pbs);
1391
1392     if (reference) {
1393         bool options_non_empty = options ? qdict_size(options) : false;
1394         QDECREF(options);
1395
1396         if (*pbs) {
1397             error_setg(errp, "Cannot reuse an existing BDS when referencing "
1398                        "another block device");
1399             return -EINVAL;
1400         }
1401
1402         if (filename || options_non_empty) {
1403             error_setg(errp, "Cannot reference an existing block device with "
1404                        "additional options or a new filename");
1405             return -EINVAL;
1406         }
1407
1408         bs = bdrv_lookup_bs(reference, reference, errp);
1409         if (!bs) {
1410             return -ENODEV;
1411         }
1412         bdrv_ref(bs);
1413         *pbs = bs;
1414         return 0;
1415     }
1416
1417     if (*pbs) {
1418         bs = *pbs;
1419     } else {
1420         bs = bdrv_new("", &error_abort);
1421     }
1422
1423     /* NULL means an empty set of options */
1424     if (options == NULL) {
1425         options = qdict_new();
1426     }
1427
1428     ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
1429     if (local_err) {
1430         goto fail;
1431     }
1432
1433     /* Find the right image format driver */
1434     drv = NULL;
1435     drvname = qdict_get_try_str(options, "driver");
1436     if (drvname) {
1437         drv = bdrv_find_format(drvname);
1438         qdict_del(options, "driver");
1439         if (!drv) {
1440             error_setg(errp, "Unknown driver: '%s'", drvname);
1441             ret = -EINVAL;
1442             goto fail;
1443         }
1444     }
1445
1446     assert(drvname || !(flags & BDRV_O_PROTOCOL));
1447     if (drv && !drv->bdrv_file_open) {
1448         /* If the user explicitly wants a format driver here, we'll need to add
1449          * another layer for the protocol in bs->file */
1450         flags &= ~BDRV_O_PROTOCOL;
1451     }
1452
1453     bs->options = options;
1454     options = qdict_clone_shallow(options);
1455
1456     /* Open image file without format layer */
1457     if ((flags & BDRV_O_PROTOCOL) == 0) {
1458         if (flags & BDRV_O_RDWR) {
1459             flags |= BDRV_O_ALLOW_RDWR;
1460         }
1461         if (flags & BDRV_O_SNAPSHOT) {
1462             snapshot_flags = bdrv_temp_snapshot_flags(flags);
1463             flags = bdrv_backing_flags(flags);
1464         }
1465
1466         assert(file == NULL);
1467         ret = bdrv_open_image(&file, filename, options, "file",
1468                               bdrv_inherited_flags(flags),
1469                               true, &local_err);
1470         if (ret < 0) {
1471             goto fail;
1472         }
1473     }
1474
1475     /* Image format probing */
1476     if (!drv && file) {
1477         ret = find_image_format(file, filename, &drv, &local_err);
1478         if (ret < 0) {
1479             goto fail;
1480         }
1481     } else if (!drv) {
1482         error_setg(errp, "Must specify either driver or file");
1483         ret = -EINVAL;
1484         goto fail;
1485     }
1486
1487     /* Open the image */
1488     ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1489     if (ret < 0) {
1490         goto fail;
1491     }
1492
1493     if (file && (bs->file != file)) {
1494         bdrv_unref(file);
1495         file = NULL;
1496     }
1497
1498     /* If there is a backing file, use it */
1499     if ((flags & BDRV_O_NO_BACKING) == 0) {
1500         QDict *backing_options;
1501
1502         qdict_extract_subqdict(options, &backing_options, "backing.");
1503         ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1504         if (ret < 0) {
1505             goto close_and_fail;
1506         }
1507     }
1508
1509     bdrv_refresh_filename(bs);
1510
1511     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1512      * temporary snapshot afterwards. */
1513     if (snapshot_flags) {
1514         ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1515         if (local_err) {
1516             goto close_and_fail;
1517         }
1518     }
1519
1520     /* Check if any unknown options were used */
1521     if (options && (qdict_size(options) != 0)) {
1522         const QDictEntry *entry = qdict_first(options);
1523         if (flags & BDRV_O_PROTOCOL) {
1524             error_setg(errp, "Block protocol '%s' doesn't support the option "
1525                        "'%s'", drv->format_name, entry->key);
1526         } else {
1527             error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1528                        "support the option '%s'", drv->format_name,
1529                        bs->device_name, entry->key);
1530         }
1531
1532         ret = -EINVAL;
1533         goto close_and_fail;
1534     }
1535
1536     if (!bdrv_key_required(bs)) {
1537         bdrv_dev_change_media_cb(bs, true);
1538     } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1539                && !runstate_check(RUN_STATE_INMIGRATE)
1540                && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1541         error_setg(errp,
1542                    "Guest must be stopped for opening of encrypted image");
1543         ret = -EBUSY;
1544         goto close_and_fail;
1545     }
1546
1547     QDECREF(options);
1548     *pbs = bs;
1549     return 0;
1550
1551 fail:
1552     if (file != NULL) {
1553         bdrv_unref(file);
1554     }
1555     QDECREF(bs->options);
1556     QDECREF(options);
1557     bs->options = NULL;
1558     if (!*pbs) {
1559         /* If *pbs is NULL, a new BDS has been created in this function and
1560            needs to be freed now. Otherwise, it does not need to be closed,
1561            since it has not really been opened yet. */
1562         bdrv_unref(bs);
1563     }
1564     if (local_err) {
1565         error_propagate(errp, local_err);
1566     }
1567     return ret;
1568
1569 close_and_fail:
1570     /* See fail path, but now the BDS has to be always closed */
1571     if (*pbs) {
1572         bdrv_close(bs);
1573     } else {
1574         bdrv_unref(bs);
1575     }
1576     QDECREF(options);
1577     if (local_err) {
1578         error_propagate(errp, local_err);
1579     }
1580     return ret;
1581 }
1582
1583 typedef struct BlockReopenQueueEntry {
1584      bool prepared;
1585      BDRVReopenState state;
1586      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1587 } BlockReopenQueueEntry;
1588
1589 /*
1590  * Adds a BlockDriverState to a simple queue for an atomic, transactional
1591  * reopen of multiple devices.
1592  *
1593  * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1594  * already performed, or alternatively may be NULL a new BlockReopenQueue will
1595  * be created and initialized. This newly created BlockReopenQueue should be
1596  * passed back in for subsequent calls that are intended to be of the same
1597  * atomic 'set'.
1598  *
1599  * bs is the BlockDriverState to add to the reopen queue.
1600  *
1601  * flags contains the open flags for the associated bs
1602  *
1603  * returns a pointer to bs_queue, which is either the newly allocated
1604  * bs_queue, or the existing bs_queue being used.
1605  *
1606  */
1607 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1608                                     BlockDriverState *bs, int flags)
1609 {
1610     assert(bs != NULL);
1611
1612     BlockReopenQueueEntry *bs_entry;
1613     if (bs_queue == NULL) {
1614         bs_queue = g_new0(BlockReopenQueue, 1);
1615         QSIMPLEQ_INIT(bs_queue);
1616     }
1617
1618     /* bdrv_open() masks this flag out */
1619     flags &= ~BDRV_O_PROTOCOL;
1620
1621     if (bs->file) {
1622         bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
1623     }
1624
1625     bs_entry = g_new0(BlockReopenQueueEntry, 1);
1626     QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1627
1628     bs_entry->state.bs = bs;
1629     bs_entry->state.flags = flags;
1630
1631     return bs_queue;
1632 }
1633
1634 /*
1635  * Reopen multiple BlockDriverStates atomically & transactionally.
1636  *
1637  * The queue passed in (bs_queue) must have been built up previous
1638  * via bdrv_reopen_queue().
1639  *
1640  * Reopens all BDS specified in the queue, with the appropriate
1641  * flags.  All devices are prepared for reopen, and failure of any
1642  * device will cause all device changes to be abandonded, and intermediate
1643  * data cleaned up.
1644  *
1645  * If all devices prepare successfully, then the changes are committed
1646  * to all devices.
1647  *
1648  */
1649 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1650 {
1651     int ret = -1;
1652     BlockReopenQueueEntry *bs_entry, *next;
1653     Error *local_err = NULL;
1654
1655     assert(bs_queue != NULL);
1656
1657     bdrv_drain_all();
1658
1659     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1660         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1661             error_propagate(errp, local_err);
1662             goto cleanup;
1663         }
1664         bs_entry->prepared = true;
1665     }
1666
1667     /* If we reach this point, we have success and just need to apply the
1668      * changes
1669      */
1670     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1671         bdrv_reopen_commit(&bs_entry->state);
1672     }
1673
1674     ret = 0;
1675
1676 cleanup:
1677     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1678         if (ret && bs_entry->prepared) {
1679             bdrv_reopen_abort(&bs_entry->state);
1680         }
1681         g_free(bs_entry);
1682     }
1683     g_free(bs_queue);
1684     return ret;
1685 }
1686
1687
1688 /* Reopen a single BlockDriverState with the specified flags. */
1689 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1690 {
1691     int ret = -1;
1692     Error *local_err = NULL;
1693     BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1694
1695     ret = bdrv_reopen_multiple(queue, &local_err);
1696     if (local_err != NULL) {
1697         error_propagate(errp, local_err);
1698     }
1699     return ret;
1700 }
1701
1702
1703 /*
1704  * Prepares a BlockDriverState for reopen. All changes are staged in the
1705  * 'opaque' field of the BDRVReopenState, which is used and allocated by
1706  * the block driver layer .bdrv_reopen_prepare()
1707  *
1708  * bs is the BlockDriverState to reopen
1709  * flags are the new open flags
1710  * queue is the reopen queue
1711  *
1712  * Returns 0 on success, non-zero on error.  On error errp will be set
1713  * as well.
1714  *
1715  * On failure, bdrv_reopen_abort() will be called to clean up any data.
1716  * It is the responsibility of the caller to then call the abort() or
1717  * commit() for any other BDS that have been left in a prepare() state
1718  *
1719  */
1720 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1721                         Error **errp)
1722 {
1723     int ret = -1;
1724     Error *local_err = NULL;
1725     BlockDriver *drv;
1726
1727     assert(reopen_state != NULL);
1728     assert(reopen_state->bs->drv != NULL);
1729     drv = reopen_state->bs->drv;
1730
1731     /* if we are to stay read-only, do not allow permission change
1732      * to r/w */
1733     if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1734         reopen_state->flags & BDRV_O_RDWR) {
1735         error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1736                   reopen_state->bs->device_name);
1737         goto error;
1738     }
1739
1740
1741     ret = bdrv_flush(reopen_state->bs);
1742     if (ret) {
1743         error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1744                   strerror(-ret));
1745         goto error;
1746     }
1747
1748     if (drv->bdrv_reopen_prepare) {
1749         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1750         if (ret) {
1751             if (local_err != NULL) {
1752                 error_propagate(errp, local_err);
1753             } else {
1754                 error_setg(errp, "failed while preparing to reopen image '%s'",
1755                            reopen_state->bs->filename);
1756             }
1757             goto error;
1758         }
1759     } else {
1760         /* It is currently mandatory to have a bdrv_reopen_prepare()
1761          * handler for each supported drv. */
1762         error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1763                   drv->format_name, reopen_state->bs->device_name,
1764                  "reopening of file");
1765         ret = -1;
1766         goto error;
1767     }
1768
1769     ret = 0;
1770
1771 error:
1772     return ret;
1773 }
1774
1775 /*
1776  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1777  * makes them final by swapping the staging BlockDriverState contents into
1778  * the active BlockDriverState contents.
1779  */
1780 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1781 {
1782     BlockDriver *drv;
1783
1784     assert(reopen_state != NULL);
1785     drv = reopen_state->bs->drv;
1786     assert(drv != NULL);
1787
1788     /* If there are any driver level actions to take */
1789     if (drv->bdrv_reopen_commit) {
1790         drv->bdrv_reopen_commit(reopen_state);
1791     }
1792
1793     /* set BDS specific flags now */
1794     reopen_state->bs->open_flags         = reopen_state->flags;
1795     reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1796                                               BDRV_O_CACHE_WB);
1797     reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1798
1799     bdrv_refresh_limits(reopen_state->bs, NULL);
1800 }
1801
1802 /*
1803  * Abort the reopen, and delete and free the staged changes in
1804  * reopen_state
1805  */
1806 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1807 {
1808     BlockDriver *drv;
1809
1810     assert(reopen_state != NULL);
1811     drv = reopen_state->bs->drv;
1812     assert(drv != NULL);
1813
1814     if (drv->bdrv_reopen_abort) {
1815         drv->bdrv_reopen_abort(reopen_state);
1816     }
1817 }
1818
1819
1820 void bdrv_close(BlockDriverState *bs)
1821 {
1822     if (bs->job) {
1823         block_job_cancel_sync(bs->job);
1824     }
1825     bdrv_drain_all(); /* complete I/O */
1826     bdrv_flush(bs);
1827     bdrv_drain_all(); /* in case flush left pending I/O */
1828     notifier_list_notify(&bs->close_notifiers, bs);
1829
1830     if (bs->drv) {
1831         if (bs->backing_hd) {
1832             BlockDriverState *backing_hd = bs->backing_hd;
1833             bdrv_set_backing_hd(bs, NULL);
1834             bdrv_unref(backing_hd);
1835         }
1836         bs->drv->bdrv_close(bs);
1837         g_free(bs->opaque);
1838         bs->opaque = NULL;
1839         bs->drv = NULL;
1840         bs->copy_on_read = 0;
1841         bs->backing_file[0] = '\0';
1842         bs->backing_format[0] = '\0';
1843         bs->total_sectors = 0;
1844         bs->encrypted = 0;
1845         bs->valid_key = 0;
1846         bs->sg = 0;
1847         bs->growable = 0;
1848         bs->zero_beyond_eof = false;
1849         QDECREF(bs->options);
1850         bs->options = NULL;
1851         QDECREF(bs->full_open_options);
1852         bs->full_open_options = NULL;
1853
1854         if (bs->file != NULL) {
1855             bdrv_unref(bs->file);
1856             bs->file = NULL;
1857         }
1858     }
1859
1860     bdrv_dev_change_media_cb(bs, false);
1861
1862     /*throttling disk I/O limits*/
1863     if (bs->io_limits_enabled) {
1864         bdrv_io_limits_disable(bs);
1865     }
1866 }
1867
1868 void bdrv_close_all(void)
1869 {
1870     BlockDriverState *bs;
1871
1872     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1873         AioContext *aio_context = bdrv_get_aio_context(bs);
1874
1875         aio_context_acquire(aio_context);
1876         bdrv_close(bs);
1877         aio_context_release(aio_context);
1878     }
1879 }
1880
1881 /* Check if any requests are in-flight (including throttled requests) */
1882 static bool bdrv_requests_pending(BlockDriverState *bs)
1883 {
1884     if (!QLIST_EMPTY(&bs->tracked_requests)) {
1885         return true;
1886     }
1887     if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1888         return true;
1889     }
1890     if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1891         return true;
1892     }
1893     if (bs->file && bdrv_requests_pending(bs->file)) {
1894         return true;
1895     }
1896     if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1897         return true;
1898     }
1899     return false;
1900 }
1901
1902 /*
1903  * Wait for pending requests to complete across all BlockDriverStates
1904  *
1905  * This function does not flush data to disk, use bdrv_flush_all() for that
1906  * after calling this function.
1907  *
1908  * Note that completion of an asynchronous I/O operation can trigger any
1909  * number of other I/O operations on other devices---for example a coroutine
1910  * can be arbitrarily complex and a constant flow of I/O can come until the
1911  * coroutine is complete.  Because of this, it is not possible to have a
1912  * function to drain a single device's I/O queue.
1913  */
1914 void bdrv_drain_all(void)
1915 {
1916     /* Always run first iteration so any pending completion BHs run */
1917     bool busy = true;
1918     BlockDriverState *bs;
1919
1920     while (busy) {
1921         busy = false;
1922
1923         QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1924             AioContext *aio_context = bdrv_get_aio_context(bs);
1925             bool bs_busy;
1926
1927             aio_context_acquire(aio_context);
1928             bdrv_flush_io_queue(bs);
1929             bdrv_start_throttled_reqs(bs);
1930             bs_busy = bdrv_requests_pending(bs);
1931             bs_busy |= aio_poll(aio_context, bs_busy);
1932             aio_context_release(aio_context);
1933
1934             busy |= bs_busy;
1935         }
1936     }
1937 }
1938
1939 /* make a BlockDriverState anonymous by removing from bdrv_state and
1940  * graph_bdrv_state list.
1941    Also, NULL terminate the device_name to prevent double remove */
1942 void bdrv_make_anon(BlockDriverState *bs)
1943 {
1944     if (bs->device_name[0] != '\0') {
1945         QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1946     }
1947     bs->device_name[0] = '\0';
1948     if (bs->node_name[0] != '\0') {
1949         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1950     }
1951     bs->node_name[0] = '\0';
1952 }
1953
1954 static void bdrv_rebind(BlockDriverState *bs)
1955 {
1956     if (bs->drv && bs->drv->bdrv_rebind) {
1957         bs->drv->bdrv_rebind(bs);
1958     }
1959 }
1960
1961 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1962                                      BlockDriverState *bs_src)
1963 {
1964     /* move some fields that need to stay attached to the device */
1965
1966     /* dev info */
1967     bs_dest->dev_ops            = bs_src->dev_ops;
1968     bs_dest->dev_opaque         = bs_src->dev_opaque;
1969     bs_dest->dev                = bs_src->dev;
1970     bs_dest->guest_block_size   = bs_src->guest_block_size;
1971     bs_dest->copy_on_read       = bs_src->copy_on_read;
1972
1973     bs_dest->enable_write_cache = bs_src->enable_write_cache;
1974
1975     /* i/o throttled req */
1976     memcpy(&bs_dest->throttle_state,
1977            &bs_src->throttle_state,
1978            sizeof(ThrottleState));
1979     bs_dest->throttled_reqs[0]  = bs_src->throttled_reqs[0];
1980     bs_dest->throttled_reqs[1]  = bs_src->throttled_reqs[1];
1981     bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1982
1983     /* r/w error */
1984     bs_dest->on_read_error      = bs_src->on_read_error;
1985     bs_dest->on_write_error     = bs_src->on_write_error;
1986
1987     /* i/o status */
1988     bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
1989     bs_dest->iostatus           = bs_src->iostatus;
1990
1991     /* dirty bitmap */
1992     bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
1993
1994     /* reference count */
1995     bs_dest->refcnt             = bs_src->refcnt;
1996
1997     /* job */
1998     bs_dest->job                = bs_src->job;
1999
2000     /* keep the same entry in bdrv_states */
2001     pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
2002             bs_src->device_name);
2003     bs_dest->device_list = bs_src->device_list;
2004     memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2005            sizeof(bs_dest->op_blockers));
2006 }
2007
2008 /*
2009  * Swap bs contents for two image chains while they are live,
2010  * while keeping required fields on the BlockDriverState that is
2011  * actually attached to a device.
2012  *
2013  * This will modify the BlockDriverState fields, and swap contents
2014  * between bs_new and bs_old. Both bs_new and bs_old are modified.
2015  *
2016  * bs_new is required to be anonymous.
2017  *
2018  * This function does not create any image files.
2019  */
2020 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2021 {
2022     BlockDriverState tmp;
2023
2024     /* The code needs to swap the node_name but simply swapping node_list won't
2025      * work so first remove the nodes from the graph list, do the swap then
2026      * insert them back if needed.
2027      */
2028     if (bs_new->node_name[0] != '\0') {
2029         QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2030     }
2031     if (bs_old->node_name[0] != '\0') {
2032         QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2033     }
2034
2035     /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2036     assert(bs_new->device_name[0] == '\0');
2037     assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2038     assert(bs_new->job == NULL);
2039     assert(bs_new->dev == NULL);
2040     assert(bs_new->io_limits_enabled == false);
2041     assert(!throttle_have_timer(&bs_new->throttle_state));
2042
2043     tmp = *bs_new;
2044     *bs_new = *bs_old;
2045     *bs_old = tmp;
2046
2047     /* there are some fields that should not be swapped, move them back */
2048     bdrv_move_feature_fields(&tmp, bs_old);
2049     bdrv_move_feature_fields(bs_old, bs_new);
2050     bdrv_move_feature_fields(bs_new, &tmp);
2051
2052     /* bs_new shouldn't be in bdrv_states even after the swap!  */
2053     assert(bs_new->device_name[0] == '\0');
2054
2055     /* Check a few fields that should remain attached to the device */
2056     assert(bs_new->dev == NULL);
2057     assert(bs_new->job == NULL);
2058     assert(bs_new->io_limits_enabled == false);
2059     assert(!throttle_have_timer(&bs_new->throttle_state));
2060
2061     /* insert the nodes back into the graph node list if needed */
2062     if (bs_new->node_name[0] != '\0') {
2063         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2064     }
2065     if (bs_old->node_name[0] != '\0') {
2066         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2067     }
2068
2069     bdrv_rebind(bs_new);
2070     bdrv_rebind(bs_old);
2071 }
2072
2073 /*
2074  * Add new bs contents at the top of an image chain while the chain is
2075  * live, while keeping required fields on the top layer.
2076  *
2077  * This will modify the BlockDriverState fields, and swap contents
2078  * between bs_new and bs_top. Both bs_new and bs_top are modified.
2079  *
2080  * bs_new is required to be anonymous.
2081  *
2082  * This function does not create any image files.
2083  */
2084 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2085 {
2086     bdrv_swap(bs_new, bs_top);
2087
2088     /* The contents of 'tmp' will become bs_top, as we are
2089      * swapping bs_new and bs_top contents. */
2090     bdrv_set_backing_hd(bs_top, bs_new);
2091 }
2092
2093 static void bdrv_delete(BlockDriverState *bs)
2094 {
2095     assert(!bs->dev);
2096     assert(!bs->job);
2097     assert(bdrv_op_blocker_is_empty(bs));
2098     assert(!bs->refcnt);
2099     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2100
2101     bdrv_close(bs);
2102
2103     /* remove from list, if necessary */
2104     bdrv_make_anon(bs);
2105
2106     g_free(bs);
2107 }
2108
2109 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2110 /* TODO change to DeviceState *dev when all users are qdevified */
2111 {
2112     if (bs->dev) {
2113         return -EBUSY;
2114     }
2115     bs->dev = dev;
2116     bdrv_iostatus_reset(bs);
2117
2118     /* We're expecting I/O from the device so bump up coroutine pool size */
2119     qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION);
2120     return 0;
2121 }
2122
2123 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2124 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
2125 {
2126     if (bdrv_attach_dev(bs, dev) < 0) {
2127         abort();
2128     }
2129 }
2130
2131 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2132 /* TODO change to DeviceState *dev when all users are qdevified */
2133 {
2134     assert(bs->dev == dev);
2135     bs->dev = NULL;
2136     bs->dev_ops = NULL;
2137     bs->dev_opaque = NULL;
2138     bs->guest_block_size = 512;
2139     qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION);
2140 }
2141
2142 /* TODO change to return DeviceState * when all users are qdevified */
2143 void *bdrv_get_attached_dev(BlockDriverState *bs)
2144 {
2145     return bs->dev;
2146 }
2147
2148 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2149                       void *opaque)
2150 {
2151     bs->dev_ops = ops;
2152     bs->dev_opaque = opaque;
2153 }
2154
2155 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
2156 {
2157     if (bs->dev_ops && bs->dev_ops->change_media_cb) {
2158         bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
2159         bs->dev_ops->change_media_cb(bs->dev_opaque, load);
2160         if (tray_was_closed) {
2161             /* tray open */
2162             qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2163                                               true, &error_abort);
2164         }
2165         if (load) {
2166             /* tray close */
2167             qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2168                                               false, &error_abort);
2169         }
2170     }
2171 }
2172
2173 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2174 {
2175     return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2176 }
2177
2178 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2179 {
2180     if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2181         bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2182     }
2183 }
2184
2185 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2186 {
2187     if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2188         return bs->dev_ops->is_tray_open(bs->dev_opaque);
2189     }
2190     return false;
2191 }
2192
2193 static void bdrv_dev_resize_cb(BlockDriverState *bs)
2194 {
2195     if (bs->dev_ops && bs->dev_ops->resize_cb) {
2196         bs->dev_ops->resize_cb(bs->dev_opaque);
2197     }
2198 }
2199
2200 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2201 {
2202     if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2203         return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2204     }
2205     return false;
2206 }
2207
2208 /*
2209  * Run consistency checks on an image
2210  *
2211  * Returns 0 if the check could be completed (it doesn't mean that the image is
2212  * free of errors) or -errno when an internal error occurred. The results of the
2213  * check are stored in res.
2214  */
2215 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2216 {
2217     if (bs->drv == NULL) {
2218         return -ENOMEDIUM;
2219     }
2220     if (bs->drv->bdrv_check == NULL) {
2221         return -ENOTSUP;
2222     }
2223
2224     memset(res, 0, sizeof(*res));
2225     return bs->drv->bdrv_check(bs, res, fix);
2226 }
2227
2228 #define COMMIT_BUF_SECTORS 2048
2229
2230 /* commit COW file into the raw image */
2231 int bdrv_commit(BlockDriverState *bs)
2232 {
2233     BlockDriver *drv = bs->drv;
2234     int64_t sector, total_sectors, length, backing_length;
2235     int n, ro, open_flags;
2236     int ret = 0;
2237     uint8_t *buf = NULL;
2238     char filename[PATH_MAX];
2239
2240     if (!drv)
2241         return -ENOMEDIUM;
2242     
2243     if (!bs->backing_hd) {
2244         return -ENOTSUP;
2245     }
2246
2247     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2248         bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2249         return -EBUSY;
2250     }
2251
2252     ro = bs->backing_hd->read_only;
2253     /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2254     pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2255     open_flags =  bs->backing_hd->open_flags;
2256
2257     if (ro) {
2258         if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2259             return -EACCES;
2260         }
2261     }
2262
2263     length = bdrv_getlength(bs);
2264     if (length < 0) {
2265         ret = length;
2266         goto ro_cleanup;
2267     }
2268
2269     backing_length = bdrv_getlength(bs->backing_hd);
2270     if (backing_length < 0) {
2271         ret = backing_length;
2272         goto ro_cleanup;
2273     }
2274
2275     /* If our top snapshot is larger than the backing file image,
2276      * grow the backing file image if possible.  If not possible,
2277      * we must return an error */
2278     if (length > backing_length) {
2279         ret = bdrv_truncate(bs->backing_hd, length);
2280         if (ret < 0) {
2281             goto ro_cleanup;
2282         }
2283     }
2284
2285     total_sectors = length >> BDRV_SECTOR_BITS;
2286
2287     /* qemu_try_blockalign() for bs will choose an alignment that works for
2288      * bs->backing_hd as well, so no need to compare the alignment manually. */
2289     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2290     if (buf == NULL) {
2291         ret = -ENOMEM;
2292         goto ro_cleanup;
2293     }
2294
2295     for (sector = 0; sector < total_sectors; sector += n) {
2296         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2297         if (ret < 0) {
2298             goto ro_cleanup;
2299         }
2300         if (ret) {
2301             ret = bdrv_read(bs, sector, buf, n);
2302             if (ret < 0) {
2303                 goto ro_cleanup;
2304             }
2305
2306             ret = bdrv_write(bs->backing_hd, sector, buf, n);
2307             if (ret < 0) {
2308                 goto ro_cleanup;
2309             }
2310         }
2311     }
2312
2313     if (drv->bdrv_make_empty) {
2314         ret = drv->bdrv_make_empty(bs);
2315         if (ret < 0) {
2316             goto ro_cleanup;
2317         }
2318         bdrv_flush(bs);
2319     }
2320
2321     /*
2322      * Make sure all data we wrote to the backing device is actually
2323      * stable on disk.
2324      */
2325     if (bs->backing_hd) {
2326         bdrv_flush(bs->backing_hd);
2327     }
2328
2329     ret = 0;
2330 ro_cleanup:
2331     qemu_vfree(buf);
2332
2333     if (ro) {
2334         /* ignoring error return here */
2335         bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2336     }
2337
2338     return ret;
2339 }
2340
2341 int bdrv_commit_all(void)
2342 {
2343     BlockDriverState *bs;
2344
2345     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2346         AioContext *aio_context = bdrv_get_aio_context(bs);
2347
2348         aio_context_acquire(aio_context);
2349         if (bs->drv && bs->backing_hd) {
2350             int ret = bdrv_commit(bs);
2351             if (ret < 0) {
2352                 aio_context_release(aio_context);
2353                 return ret;
2354             }
2355         }
2356         aio_context_release(aio_context);
2357     }
2358     return 0;
2359 }
2360
2361 /**
2362  * Remove an active request from the tracked requests list
2363  *
2364  * This function should be called when a tracked request is completing.
2365  */
2366 static void tracked_request_end(BdrvTrackedRequest *req)
2367 {
2368     if (req->serialising) {
2369         req->bs->serialising_in_flight--;
2370     }
2371
2372     QLIST_REMOVE(req, list);
2373     qemu_co_queue_restart_all(&req->wait_queue);
2374 }
2375
2376 /**
2377  * Add an active request to the tracked requests list
2378  */
2379 static void tracked_request_begin(BdrvTrackedRequest *req,
2380                                   BlockDriverState *bs,
2381                                   int64_t offset,
2382                                   unsigned int bytes, bool is_write)
2383 {
2384     *req = (BdrvTrackedRequest){
2385         .bs = bs,
2386         .offset         = offset,
2387         .bytes          = bytes,
2388         .is_write       = is_write,
2389         .co             = qemu_coroutine_self(),
2390         .serialising    = false,
2391         .overlap_offset = offset,
2392         .overlap_bytes  = bytes,
2393     };
2394
2395     qemu_co_queue_init(&req->wait_queue);
2396
2397     QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2398 }
2399
2400 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2401 {
2402     int64_t overlap_offset = req->offset & ~(align - 1);
2403     unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2404                                - overlap_offset;
2405
2406     if (!req->serialising) {
2407         req->bs->serialising_in_flight++;
2408         req->serialising = true;
2409     }
2410
2411     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2412     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2413 }
2414
2415 /**
2416  * Round a region to cluster boundaries
2417  */
2418 void bdrv_round_to_clusters(BlockDriverState *bs,
2419                             int64_t sector_num, int nb_sectors,
2420                             int64_t *cluster_sector_num,
2421                             int *cluster_nb_sectors)
2422 {
2423     BlockDriverInfo bdi;
2424
2425     if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2426         *cluster_sector_num = sector_num;
2427         *cluster_nb_sectors = nb_sectors;
2428     } else {
2429         int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2430         *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2431         *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2432                                             nb_sectors, c);
2433     }
2434 }
2435
2436 static int bdrv_get_cluster_size(BlockDriverState *bs)
2437 {
2438     BlockDriverInfo bdi;
2439     int ret;
2440
2441     ret = bdrv_get_info(bs, &bdi);
2442     if (ret < 0 || bdi.cluster_size == 0) {
2443         return bs->request_alignment;
2444     } else {
2445         return bdi.cluster_size;
2446     }
2447 }
2448
2449 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2450                                      int64_t offset, unsigned int bytes)
2451 {
2452     /*        aaaa   bbbb */
2453     if (offset >= req->overlap_offset + req->overlap_bytes) {
2454         return false;
2455     }
2456     /* bbbb   aaaa        */
2457     if (req->overlap_offset >= offset + bytes) {
2458         return false;
2459     }
2460     return true;
2461 }
2462
2463 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2464 {
2465     BlockDriverState *bs = self->bs;
2466     BdrvTrackedRequest *req;
2467     bool retry;
2468     bool waited = false;
2469
2470     if (!bs->serialising_in_flight) {
2471         return false;
2472     }
2473
2474     do {
2475         retry = false;
2476         QLIST_FOREACH(req, &bs->tracked_requests, list) {
2477             if (req == self || (!req->serialising && !self->serialising)) {
2478                 continue;
2479             }
2480             if (tracked_request_overlaps(req, self->overlap_offset,
2481                                          self->overlap_bytes))
2482             {
2483                 /* Hitting this means there was a reentrant request, for
2484                  * example, a block driver issuing nested requests.  This must
2485                  * never happen since it means deadlock.
2486                  */
2487                 assert(qemu_coroutine_self() != req->co);
2488
2489                 /* If the request is already (indirectly) waiting for us, or
2490                  * will wait for us as soon as it wakes up, then just go on
2491                  * (instead of producing a deadlock in the former case). */
2492                 if (!req->waiting_for) {
2493                     self->waiting_for = req;
2494                     qemu_co_queue_wait(&req->wait_queue);
2495                     self->waiting_for = NULL;
2496                     retry = true;
2497                     waited = true;
2498                     break;
2499                 }
2500             }
2501         }
2502     } while (retry);
2503
2504     return waited;
2505 }
2506
2507 /*
2508  * Return values:
2509  * 0        - success
2510  * -EINVAL  - backing format specified, but no file
2511  * -ENOSPC  - can't update the backing file because no space is left in the
2512  *            image file header
2513  * -ENOTSUP - format driver doesn't support changing the backing file
2514  */
2515 int bdrv_change_backing_file(BlockDriverState *bs,
2516     const char *backing_file, const char *backing_fmt)
2517 {
2518     BlockDriver *drv = bs->drv;
2519     int ret;
2520
2521     /* Backing file format doesn't make sense without a backing file */
2522     if (backing_fmt && !backing_file) {
2523         return -EINVAL;
2524     }
2525
2526     if (drv->bdrv_change_backing_file != NULL) {
2527         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2528     } else {
2529         ret = -ENOTSUP;
2530     }
2531
2532     if (ret == 0) {
2533         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2534         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2535     }
2536     return ret;
2537 }
2538
2539 /*
2540  * Finds the image layer in the chain that has 'bs' as its backing file.
2541  *
2542  * active is the current topmost image.
2543  *
2544  * Returns NULL if bs is not found in active's image chain,
2545  * or if active == bs.
2546  *
2547  * Returns the bottommost base image if bs == NULL.
2548  */
2549 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2550                                     BlockDriverState *bs)
2551 {
2552     while (active && bs != active->backing_hd) {
2553         active = active->backing_hd;
2554     }
2555
2556     return active;
2557 }
2558
2559 /* Given a BDS, searches for the base layer. */
2560 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2561 {
2562     return bdrv_find_overlay(bs, NULL);
2563 }
2564
2565 typedef struct BlkIntermediateStates {
2566     BlockDriverState *bs;
2567     QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2568 } BlkIntermediateStates;
2569
2570
2571 /*
2572  * Drops images above 'base' up to and including 'top', and sets the image
2573  * above 'top' to have base as its backing file.
2574  *
2575  * Requires that the overlay to 'top' is opened r/w, so that the backing file
2576  * information in 'bs' can be properly updated.
2577  *
2578  * E.g., this will convert the following chain:
2579  * bottom <- base <- intermediate <- top <- active
2580  *
2581  * to
2582  *
2583  * bottom <- base <- active
2584  *
2585  * It is allowed for bottom==base, in which case it converts:
2586  *
2587  * base <- intermediate <- top <- active
2588  *
2589  * to
2590  *
2591  * base <- active
2592  *
2593  * If backing_file_str is non-NULL, it will be used when modifying top's
2594  * overlay image metadata.
2595  *
2596  * Error conditions:
2597  *  if active == top, that is considered an error
2598  *
2599  */
2600 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2601                            BlockDriverState *base, const char *backing_file_str)
2602 {
2603     BlockDriverState *intermediate;
2604     BlockDriverState *base_bs = NULL;
2605     BlockDriverState *new_top_bs = NULL;
2606     BlkIntermediateStates *intermediate_state, *next;
2607     int ret = -EIO;
2608
2609     QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2610     QSIMPLEQ_INIT(&states_to_delete);
2611
2612     if (!top->drv || !base->drv) {
2613         goto exit;
2614     }
2615
2616     new_top_bs = bdrv_find_overlay(active, top);
2617
2618     if (new_top_bs == NULL) {
2619         /* we could not find the image above 'top', this is an error */
2620         goto exit;
2621     }
2622
2623     /* special case of new_top_bs->backing_hd already pointing to base - nothing
2624      * to do, no intermediate images */
2625     if (new_top_bs->backing_hd == base) {
2626         ret = 0;
2627         goto exit;
2628     }
2629
2630     intermediate = top;
2631
2632     /* now we will go down through the list, and add each BDS we find
2633      * into our deletion queue, until we hit the 'base'
2634      */
2635     while (intermediate) {
2636         intermediate_state = g_new0(BlkIntermediateStates, 1);
2637         intermediate_state->bs = intermediate;
2638         QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2639
2640         if (intermediate->backing_hd == base) {
2641             base_bs = intermediate->backing_hd;
2642             break;
2643         }
2644         intermediate = intermediate->backing_hd;
2645     }
2646     if (base_bs == NULL) {
2647         /* something went wrong, we did not end at the base. safely
2648          * unravel everything, and exit with error */
2649         goto exit;
2650     }
2651
2652     /* success - we can delete the intermediate states, and link top->base */
2653     backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2654     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2655                                    base_bs->drv ? base_bs->drv->format_name : "");
2656     if (ret) {
2657         goto exit;
2658     }
2659     bdrv_set_backing_hd(new_top_bs, base_bs);
2660
2661     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2662         /* so that bdrv_close() does not recursively close the chain */
2663         bdrv_set_backing_hd(intermediate_state->bs, NULL);
2664         bdrv_unref(intermediate_state->bs);
2665     }
2666     ret = 0;
2667
2668 exit:
2669     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2670         g_free(intermediate_state);
2671     }
2672     return ret;
2673 }
2674
2675
2676 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2677                                    size_t size)
2678 {
2679     int64_t len;
2680
2681     if (size > INT_MAX) {
2682         return -EIO;
2683     }
2684
2685     if (!bdrv_is_inserted(bs))
2686         return -ENOMEDIUM;
2687
2688     if (bs->growable)
2689         return 0;
2690
2691     len = bdrv_getlength(bs);
2692
2693     if (offset < 0)
2694         return -EIO;
2695
2696     if ((offset > len) || (len - offset < size))
2697         return -EIO;
2698
2699     return 0;
2700 }
2701
2702 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2703                               int nb_sectors)
2704 {
2705     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2706         return -EIO;
2707     }
2708
2709     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2710                                    nb_sectors * BDRV_SECTOR_SIZE);
2711 }
2712
2713 typedef struct RwCo {
2714     BlockDriverState *bs;
2715     int64_t offset;
2716     QEMUIOVector *qiov;
2717     bool is_write;
2718     int ret;
2719     BdrvRequestFlags flags;
2720 } RwCo;
2721
2722 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2723 {
2724     RwCo *rwco = opaque;
2725
2726     if (!rwco->is_write) {
2727         rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2728                                       rwco->qiov->size, rwco->qiov,
2729                                       rwco->flags);
2730     } else {
2731         rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2732                                        rwco->qiov->size, rwco->qiov,
2733                                        rwco->flags);
2734     }
2735 }
2736
2737 /*
2738  * Process a vectored synchronous request using coroutines
2739  */
2740 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2741                         QEMUIOVector *qiov, bool is_write,
2742                         BdrvRequestFlags flags)
2743 {
2744     Coroutine *co;
2745     RwCo rwco = {
2746         .bs = bs,
2747         .offset = offset,
2748         .qiov = qiov,
2749         .is_write = is_write,
2750         .ret = NOT_DONE,
2751         .flags = flags,
2752     };
2753
2754     /**
2755      * In sync call context, when the vcpu is blocked, this throttling timer
2756      * will not fire; so the I/O throttling function has to be disabled here
2757      * if it has been enabled.
2758      */
2759     if (bs->io_limits_enabled) {
2760         fprintf(stderr, "Disabling I/O throttling on '%s' due "
2761                         "to synchronous I/O.\n", bdrv_get_device_name(bs));
2762         bdrv_io_limits_disable(bs);
2763     }
2764
2765     if (qemu_in_coroutine()) {
2766         /* Fast-path if already in coroutine context */
2767         bdrv_rw_co_entry(&rwco);
2768     } else {
2769         AioContext *aio_context = bdrv_get_aio_context(bs);
2770
2771         co = qemu_coroutine_create(bdrv_rw_co_entry);
2772         qemu_coroutine_enter(co, &rwco);
2773         while (rwco.ret == NOT_DONE) {
2774             aio_poll(aio_context, true);
2775         }
2776     }
2777     return rwco.ret;
2778 }
2779
2780 /*
2781  * Process a synchronous request using coroutines
2782  */
2783 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2784                       int nb_sectors, bool is_write, BdrvRequestFlags flags)
2785 {
2786     QEMUIOVector qiov;
2787     struct iovec iov = {
2788         .iov_base = (void *)buf,
2789         .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2790     };
2791
2792     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2793         return -EINVAL;
2794     }
2795
2796     qemu_iovec_init_external(&qiov, &iov, 1);
2797     return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2798                         &qiov, is_write, flags);
2799 }
2800
2801 /* return < 0 if error. See bdrv_write() for the return codes */
2802 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2803               uint8_t *buf, int nb_sectors)
2804 {
2805     return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
2806 }
2807
2808 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2809 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2810                           uint8_t *buf, int nb_sectors)
2811 {
2812     bool enabled;
2813     int ret;
2814
2815     enabled = bs->io_limits_enabled;
2816     bs->io_limits_enabled = false;
2817     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2818     bs->io_limits_enabled = enabled;
2819     return ret;
2820 }
2821
2822 /* Return < 0 if error. Important errors are:
2823   -EIO         generic I/O error (may happen for all errors)
2824   -ENOMEDIUM   No media inserted.
2825   -EINVAL      Invalid sector number or nb_sectors
2826   -EACCES      Trying to write a read-only device
2827 */
2828 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2829                const uint8_t *buf, int nb_sectors)
2830 {
2831     return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
2832 }
2833
2834 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2835                       int nb_sectors, BdrvRequestFlags flags)
2836 {
2837     return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2838                       BDRV_REQ_ZERO_WRITE | flags);
2839 }
2840
2841 /*
2842  * Completely zero out a block device with the help of bdrv_write_zeroes.
2843  * The operation is sped up by checking the block status and only writing
2844  * zeroes to the device if they currently do not return zeroes. Optional
2845  * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2846  *
2847  * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2848  */
2849 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2850 {
2851     int64_t target_sectors, ret, nb_sectors, sector_num = 0;
2852     int n;
2853
2854     target_sectors = bdrv_nb_sectors(bs);
2855     if (target_sectors < 0) {
2856         return target_sectors;
2857     }
2858
2859     for (;;) {
2860         nb_sectors = target_sectors - sector_num;
2861         if (nb_sectors <= 0) {
2862             return 0;
2863         }
2864         if (nb_sectors > INT_MAX) {
2865             nb_sectors = INT_MAX;
2866         }
2867         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2868         if (ret < 0) {
2869             error_report("error getting block status at sector %" PRId64 ": %s",
2870                          sector_num, strerror(-ret));
2871             return ret;
2872         }
2873         if (ret & BDRV_BLOCK_ZERO) {
2874             sector_num += n;
2875             continue;
2876         }
2877         ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2878         if (ret < 0) {
2879             error_report("error writing zeroes at sector %" PRId64 ": %s",
2880                          sector_num, strerror(-ret));
2881             return ret;
2882         }
2883         sector_num += n;
2884     }
2885 }
2886
2887 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
2888 {
2889     QEMUIOVector qiov;
2890     struct iovec iov = {
2891         .iov_base = (void *)buf,
2892         .iov_len = bytes,
2893     };
2894     int ret;
2895
2896     if (bytes < 0) {
2897         return -EINVAL;
2898     }
2899
2900     qemu_iovec_init_external(&qiov, &iov, 1);
2901     ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2902     if (ret < 0) {
2903         return ret;
2904     }
2905
2906     return bytes;
2907 }
2908
2909 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
2910 {
2911     int ret;
2912
2913     ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2914     if (ret < 0) {
2915         return ret;
2916     }
2917
2918     return qiov->size;
2919 }
2920
2921 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2922                 const void *buf, int bytes)
2923 {
2924     QEMUIOVector qiov;
2925     struct iovec iov = {
2926         .iov_base   = (void *) buf,
2927         .iov_len    = bytes,
2928     };
2929
2930     if (bytes < 0) {
2931         return -EINVAL;
2932     }
2933
2934     qemu_iovec_init_external(&qiov, &iov, 1);
2935     return bdrv_pwritev(bs, offset, &qiov);
2936 }
2937
2938 /*
2939  * Writes to the file and ensures that no writes are reordered across this
2940  * request (acts as a barrier)
2941  *
2942  * Returns 0 on success, -errno in error cases.
2943  */
2944 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2945     const void *buf, int count)
2946 {
2947     int ret;
2948
2949     ret = bdrv_pwrite(bs, offset, buf, count);
2950     if (ret < 0) {
2951         return ret;
2952     }
2953
2954     /* No flush needed for cache modes that already do it */
2955     if (bs->enable_write_cache) {
2956         bdrv_flush(bs);
2957     }
2958
2959     return 0;
2960 }
2961
2962 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2963         int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2964 {
2965     /* Perform I/O through a temporary buffer so that users who scribble over
2966      * their read buffer while the operation is in progress do not end up
2967      * modifying the image file.  This is critical for zero-copy guest I/O
2968      * where anything might happen inside guest memory.
2969      */
2970     void *bounce_buffer;
2971
2972     BlockDriver *drv = bs->drv;
2973     struct iovec iov;
2974     QEMUIOVector bounce_qiov;
2975     int64_t cluster_sector_num;
2976     int cluster_nb_sectors;
2977     size_t skip_bytes;
2978     int ret;
2979
2980     /* Cover entire cluster so no additional backing file I/O is required when
2981      * allocating cluster in the image file.
2982      */
2983     bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2984                            &cluster_sector_num, &cluster_nb_sectors);
2985
2986     trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2987                                    cluster_sector_num, cluster_nb_sectors);
2988
2989     iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2990     iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
2991     if (bounce_buffer == NULL) {
2992         ret = -ENOMEM;
2993         goto err;
2994     }
2995
2996     qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2997
2998     ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2999                              &bounce_qiov);
3000     if (ret < 0) {
3001         goto err;
3002     }
3003
3004     if (drv->bdrv_co_write_zeroes &&
3005         buffer_is_zero(bounce_buffer, iov.iov_len)) {
3006         ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
3007                                       cluster_nb_sectors, 0);
3008     } else {
3009         /* This does not change the data on the disk, it is not necessary
3010          * to flush even in cache=writethrough mode.
3011          */
3012         ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
3013                                   &bounce_qiov);
3014     }
3015
3016     if (ret < 0) {
3017         /* It might be okay to ignore write errors for guest requests.  If this
3018          * is a deliberate copy-on-read then we don't want to ignore the error.
3019          * Simply report it in all cases.
3020          */
3021         goto err;
3022     }
3023
3024     skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
3025     qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3026                         nb_sectors * BDRV_SECTOR_SIZE);
3027
3028 err:
3029     qemu_vfree(bounce_buffer);
3030     return ret;
3031 }
3032
3033 /*
3034  * Forwards an already correctly aligned request to the BlockDriver. This
3035  * handles copy on read and zeroing after EOF; any other features must be
3036  * implemented by the caller.
3037  */
3038 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
3039     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3040     int64_t align, QEMUIOVector *qiov, int flags)
3041 {
3042     BlockDriver *drv = bs->drv;
3043     int ret;
3044
3045     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3046     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3047
3048     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3049     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3050     assert(!qiov || bytes == qiov->size);
3051
3052     /* Handle Copy on Read and associated serialisation */
3053     if (flags & BDRV_REQ_COPY_ON_READ) {
3054         /* If we touch the same cluster it counts as an overlap.  This
3055          * guarantees that allocating writes will be serialized and not race
3056          * with each other for the same cluster.  For example, in copy-on-read
3057          * it ensures that the CoR read and write operations are atomic and
3058          * guest writes cannot interleave between them. */
3059         mark_request_serialising(req, bdrv_get_cluster_size(bs));
3060     }
3061
3062     wait_serialising_requests(req);
3063
3064     if (flags & BDRV_REQ_COPY_ON_READ) {
3065         int pnum;
3066
3067         ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
3068         if (ret < 0) {
3069             goto out;
3070         }
3071
3072         if (!ret || pnum != nb_sectors) {
3073             ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
3074             goto out;
3075         }
3076     }
3077
3078     /* Forward the request to the BlockDriver */
3079     if (!(bs->zero_beyond_eof && bs->growable)) {
3080         ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3081     } else {
3082         /* Read zeros after EOF of growable BDSes */
3083         int64_t total_sectors, max_nb_sectors;
3084
3085         total_sectors = bdrv_nb_sectors(bs);
3086         if (total_sectors < 0) {
3087             ret = total_sectors;
3088             goto out;
3089         }
3090
3091         max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3092                                   align >> BDRV_SECTOR_BITS);
3093         if (max_nb_sectors > 0) {
3094             QEMUIOVector local_qiov;
3095             size_t local_sectors;
3096
3097             max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);
3098             local_sectors = MIN(max_nb_sectors, nb_sectors);
3099
3100             qemu_iovec_init(&local_qiov, qiov->niov);
3101             qemu_iovec_concat(&local_qiov, qiov, 0,
3102                               local_sectors * BDRV_SECTOR_SIZE);
3103
3104             ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,
3105                                      &local_qiov);
3106
3107             qemu_iovec_destroy(&local_qiov);
3108         } else {
3109             ret = 0;
3110         }
3111
3112         /* Reading beyond end of file is supposed to produce zeroes */
3113         if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3114             uint64_t offset = MAX(0, total_sectors - sector_num);
3115             uint64_t bytes = (sector_num + nb_sectors - offset) *
3116                               BDRV_SECTOR_SIZE;
3117             qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3118         }
3119     }
3120
3121 out:
3122     return ret;
3123 }
3124
3125 /*
3126  * Handle a read request in coroutine context
3127  */
3128 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3129     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3130     BdrvRequestFlags flags)
3131 {
3132     BlockDriver *drv = bs->drv;
3133     BdrvTrackedRequest req;
3134
3135     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3136     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3137     uint8_t *head_buf = NULL;
3138     uint8_t *tail_buf = NULL;
3139     QEMUIOVector local_qiov;
3140     bool use_local_qiov = false;
3141     int ret;
3142
3143     if (!drv) {
3144         return -ENOMEDIUM;
3145     }
3146     if (bdrv_check_byte_request(bs, offset, bytes)) {
3147         return -EIO;
3148     }
3149
3150     if (bs->copy_on_read) {
3151         flags |= BDRV_REQ_COPY_ON_READ;
3152     }
3153
3154     /* throttling disk I/O */
3155     if (bs->io_limits_enabled) {
3156         bdrv_io_limits_intercept(bs, bytes, false);
3157     }
3158
3159     /* Align read if necessary by padding qiov */
3160     if (offset & (align - 1)) {
3161         head_buf = qemu_blockalign(bs, align);
3162         qemu_iovec_init(&local_qiov, qiov->niov + 2);
3163         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3164         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3165         use_local_qiov = true;
3166
3167         bytes += offset & (align - 1);
3168         offset = offset & ~(align - 1);
3169     }
3170
3171     if ((offset + bytes) & (align - 1)) {
3172         if (!use_local_qiov) {
3173             qemu_iovec_init(&local_qiov, qiov->niov + 1);
3174             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3175             use_local_qiov = true;
3176         }
3177         tail_buf = qemu_blockalign(bs, align);
3178         qemu_iovec_add(&local_qiov, tail_buf,
3179                        align - ((offset + bytes) & (align - 1)));
3180
3181         bytes = ROUND_UP(bytes, align);
3182     }
3183
3184     tracked_request_begin(&req, bs, offset, bytes, false);
3185     ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3186                               use_local_qiov ? &local_qiov : qiov,
3187                               flags);
3188     tracked_request_end(&req);
3189
3190     if (use_local_qiov) {
3191         qemu_iovec_destroy(&local_qiov);
3192         qemu_vfree(head_buf);
3193         qemu_vfree(tail_buf);
3194     }
3195
3196     return ret;
3197 }
3198
3199 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3200     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3201     BdrvRequestFlags flags)
3202 {
3203     if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3204         return -EINVAL;
3205     }
3206
3207     return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3208                              nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3209 }
3210
3211 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
3212     int nb_sectors, QEMUIOVector *qiov)
3213 {
3214     trace_bdrv_co_readv(bs, sector_num, nb_sectors);
3215
3216     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3217 }
3218
3219 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3220     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3221 {
3222     trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3223
3224     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3225                             BDRV_REQ_COPY_ON_READ);
3226 }
3227
3228 /* if no limit is specified in the BlockLimits use a default
3229  * of 32768 512-byte sectors (16 MiB) per request.
3230  */
3231 #define MAX_WRITE_ZEROES_DEFAULT 32768
3232
3233 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3234     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3235 {
3236     BlockDriver *drv = bs->drv;
3237     QEMUIOVector qiov;
3238     struct iovec iov = {0};
3239     int ret = 0;
3240
3241     int max_write_zeroes = bs->bl.max_write_zeroes ?
3242                            bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
3243
3244     while (nb_sectors > 0 && !ret) {
3245         int num = nb_sectors;
3246
3247         /* Align request.  Block drivers can expect the "bulk" of the request
3248          * to be aligned.
3249          */
3250         if (bs->bl.write_zeroes_alignment
3251             && num > bs->bl.write_zeroes_alignment) {
3252             if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3253                 /* Make a small request up to the first aligned sector.  */
3254                 num = bs->bl.write_zeroes_alignment;
3255                 num -= sector_num % bs->bl.write_zeroes_alignment;
3256             } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3257                 /* Shorten the request to the last aligned sector.  num cannot
3258                  * underflow because num > bs->bl.write_zeroes_alignment.
3259                  */
3260                 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3261             }
3262         }
3263
3264         /* limit request size */
3265         if (num > max_write_zeroes) {
3266             num = max_write_zeroes;
3267         }
3268
3269         ret = -ENOTSUP;
3270         /* First try the efficient write zeroes operation */
3271         if (drv->bdrv_co_write_zeroes) {
3272             ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3273         }
3274
3275         if (ret == -ENOTSUP) {
3276             /* Fall back to bounce buffer if write zeroes is unsupported */
3277             iov.iov_len = num * BDRV_SECTOR_SIZE;
3278             if (iov.iov_base == NULL) {
3279                 iov.iov_base = qemu_try_blockalign(bs, num * BDRV_SECTOR_SIZE);
3280                 if (iov.iov_base == NULL) {
3281                     ret = -ENOMEM;
3282                     goto fail;
3283                 }
3284                 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3285             }
3286             qemu_iovec_init_external(&qiov, &iov, 1);
3287
3288             ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3289
3290             /* Keep bounce buffer around if it is big enough for all
3291              * all future requests.
3292              */
3293             if (num < max_write_zeroes) {
3294                 qemu_vfree(iov.iov_base);
3295                 iov.iov_base = NULL;
3296             }
3297         }
3298
3299         sector_num += num;
3300         nb_sectors -= num;
3301     }
3302
3303 fail:
3304     qemu_vfree(iov.iov_base);
3305     return ret;
3306 }
3307
3308 /*
3309  * Forwards an already correctly aligned write request to the BlockDriver.
3310  */
3311 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3312     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3313     QEMUIOVector *qiov, int flags)
3314 {
3315     BlockDriver *drv = bs->drv;
3316     bool waited;
3317     int ret;
3318
3319     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3320     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3321
3322     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3323     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3324     assert(!qiov || bytes == qiov->size);
3325
3326     waited = wait_serialising_requests(req);
3327     assert(!waited || !req->serialising);
3328     assert(req->overlap_offset <= offset);
3329     assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3330
3331     ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3332
3333     if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3334         !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3335         qemu_iovec_is_zero(qiov)) {
3336         flags |= BDRV_REQ_ZERO_WRITE;
3337         if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3338             flags |= BDRV_REQ_MAY_UNMAP;
3339         }
3340     }
3341
3342     if (ret < 0) {
3343         /* Do nothing, write notifier decided to fail this request */
3344     } else if (flags & BDRV_REQ_ZERO_WRITE) {
3345         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3346         ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3347     } else {
3348         BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3349         ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3350     }
3351     BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3352
3353     if (ret == 0 && !bs->enable_write_cache) {
3354         ret = bdrv_co_flush(bs);
3355     }
3356
3357     bdrv_set_dirty(bs, sector_num, nb_sectors);
3358
3359     if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3360         bs->wr_highest_sector = sector_num + nb_sectors - 1;
3361     }
3362     if (bs->growable && ret >= 0) {
3363         bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3364     }
3365
3366     return ret;
3367 }
3368
3369 /*
3370  * Handle a write request in coroutine context
3371  */
3372 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3373     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3374     BdrvRequestFlags flags)
3375 {
3376     BdrvTrackedRequest req;
3377     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3378     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3379     uint8_t *head_buf = NULL;
3380     uint8_t *tail_buf = NULL;
3381     QEMUIOVector local_qiov;
3382     bool use_local_qiov = false;
3383     int ret;
3384
3385     if (!bs->drv) {
3386         return -ENOMEDIUM;
3387     }
3388     if (bs->read_only) {
3389         return -EACCES;
3390     }
3391     if (bdrv_check_byte_request(bs, offset, bytes)) {
3392         return -EIO;
3393     }
3394
3395     /* throttling disk I/O */
3396     if (bs->io_limits_enabled) {
3397         bdrv_io_limits_intercept(bs, bytes, true);
3398     }
3399
3400     /*
3401      * Align write if necessary by performing a read-modify-write cycle.
3402      * Pad qiov with the read parts and be sure to have a tracked request not
3403      * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3404      */
3405     tracked_request_begin(&req, bs, offset, bytes, true);
3406
3407     if (offset & (align - 1)) {
3408         QEMUIOVector head_qiov;
3409         struct iovec head_iov;
3410
3411         mark_request_serialising(&req, align);
3412         wait_serialising_requests(&req);
3413
3414         head_buf = qemu_blockalign(bs, align);
3415         head_iov = (struct iovec) {
3416             .iov_base   = head_buf,
3417             .iov_len    = align,
3418         };
3419         qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3420
3421         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3422         ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3423                                   align, &head_qiov, 0);
3424         if (ret < 0) {
3425             goto fail;
3426         }
3427         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3428
3429         qemu_iovec_init(&local_qiov, qiov->niov + 2);
3430         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3431         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3432         use_local_qiov = true;
3433
3434         bytes += offset & (align - 1);
3435         offset = offset & ~(align - 1);
3436     }
3437
3438     if ((offset + bytes) & (align - 1)) {
3439         QEMUIOVector tail_qiov;
3440         struct iovec tail_iov;
3441         size_t tail_bytes;
3442         bool waited;
3443
3444         mark_request_serialising(&req, align);
3445         waited = wait_serialising_requests(&req);
3446         assert(!waited || !use_local_qiov);
3447
3448         tail_buf = qemu_blockalign(bs, align);
3449         tail_iov = (struct iovec) {
3450             .iov_base   = tail_buf,
3451             .iov_len    = align,
3452         };
3453         qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3454
3455         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3456         ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3457                                   align, &tail_qiov, 0);
3458         if (ret < 0) {
3459             goto fail;
3460         }
3461         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3462
3463         if (!use_local_qiov) {
3464             qemu_iovec_init(&local_qiov, qiov->niov + 1);
3465             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3466             use_local_qiov = true;
3467         }
3468
3469         tail_bytes = (offset + bytes) & (align - 1);
3470         qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3471
3472         bytes = ROUND_UP(bytes, align);
3473     }
3474
3475     ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3476                                use_local_qiov ? &local_qiov : qiov,
3477                                flags);
3478
3479 fail:
3480     tracked_request_end(&req);
3481
3482     if (use_local_qiov) {
3483         qemu_iovec_destroy(&local_qiov);
3484     }
3485     qemu_vfree(head_buf);
3486     qemu_vfree(tail_buf);
3487
3488     return ret;
3489 }
3490
3491 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3492     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3493     BdrvRequestFlags flags)
3494 {
3495     if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3496         return -EINVAL;
3497     }
3498
3499     return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3500                               nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3501 }
3502
3503 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3504     int nb_sectors, QEMUIOVector *qiov)
3505 {
3506     trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3507
3508     return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3509 }
3510
3511 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3512                                       int64_t sector_num, int nb_sectors,
3513                                       BdrvRequestFlags flags)
3514 {
3515     trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3516
3517     if (!(bs->open_flags & BDRV_O_UNMAP)) {
3518         flags &= ~BDRV_REQ_MAY_UNMAP;
3519     }
3520
3521     return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3522                              BDRV_REQ_ZERO_WRITE | flags);
3523 }
3524
3525 /**
3526  * Truncate file to 'offset' bytes (needed only for file protocols)
3527  */
3528 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3529 {
3530     BlockDriver *drv = bs->drv;
3531     int ret;
3532     if (!drv)
3533         return -ENOMEDIUM;
3534     if (!drv->bdrv_truncate)
3535         return -ENOTSUP;
3536     if (bs->read_only)
3537         return -EACCES;
3538
3539     ret = drv->bdrv_truncate(bs, offset);
3540     if (ret == 0) {
3541         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3542         bdrv_dev_resize_cb(bs);
3543     }
3544     return ret;
3545 }
3546
3547 /**
3548  * Length of a allocated file in bytes. Sparse files are counted by actual
3549  * allocated space. Return < 0 if error or unknown.
3550  */
3551 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3552 {
3553     BlockDriver *drv = bs->drv;
3554     if (!drv) {
3555         return -ENOMEDIUM;
3556     }
3557     if (drv->bdrv_get_allocated_file_size) {
3558         return drv->bdrv_get_allocated_file_size(bs);
3559     }
3560     if (bs->file) {
3561         return bdrv_get_allocated_file_size(bs->file);
3562     }
3563     return -ENOTSUP;
3564 }
3565
3566 /**
3567  * Return number of sectors on success, -errno on error.
3568  */
3569 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3570 {
3571     BlockDriver *drv = bs->drv;
3572
3573     if (!drv)
3574         return -ENOMEDIUM;
3575
3576     if (drv->has_variable_length) {
3577         int ret = refresh_total_sectors(bs, bs->total_sectors);
3578         if (ret < 0) {
3579             return ret;
3580         }
3581     }
3582     return bs->total_sectors;
3583 }
3584
3585 /**
3586  * Return length in bytes on success, -errno on error.
3587  * The length is always a multiple of BDRV_SECTOR_SIZE.
3588  */
3589 int64_t bdrv_getlength(BlockDriverState *bs)
3590 {
3591     int64_t ret = bdrv_nb_sectors(bs);
3592
3593     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3594 }
3595
3596 /* return 0 as number of sectors if no device present or error */
3597 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3598 {
3599     int64_t nb_sectors = bdrv_nb_sectors(bs);
3600
3601     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3602 }
3603
3604 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3605                        BlockdevOnError on_write_error)
3606 {
3607     bs->on_read_error = on_read_error;
3608     bs->on_write_error = on_write_error;
3609 }
3610
3611 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3612 {
3613     return is_read ? bs->on_read_error : bs->on_write_error;
3614 }
3615
3616 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3617 {
3618     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3619
3620     switch (on_err) {
3621     case BLOCKDEV_ON_ERROR_ENOSPC:
3622         return (error == ENOSPC) ?
3623                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
3624     case BLOCKDEV_ON_ERROR_STOP:
3625         return BLOCK_ERROR_ACTION_STOP;
3626     case BLOCKDEV_ON_ERROR_REPORT:
3627         return BLOCK_ERROR_ACTION_REPORT;
3628     case BLOCKDEV_ON_ERROR_IGNORE:
3629         return BLOCK_ERROR_ACTION_IGNORE;
3630     default:
3631         abort();
3632     }
3633 }
3634
3635 /* This is done by device models because, while the block layer knows
3636  * about the error, it does not know whether an operation comes from
3637  * the device or the block layer (from a job, for example).
3638  */
3639 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3640                        bool is_read, int error)
3641 {
3642     assert(error >= 0);
3643
3644     if (action == BLOCK_ERROR_ACTION_STOP) {
3645         /* First set the iostatus, so that "info block" returns an iostatus
3646          * that matches the events raised so far (an additional error iostatus
3647          * is fine, but not a lost one).
3648          */
3649         bdrv_iostatus_set_err(bs, error);
3650
3651         /* Then raise the request to stop the VM and the event.
3652          * qemu_system_vmstop_request_prepare has two effects.  First,
3653          * it ensures that the STOP event always comes after the
3654          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
3655          * can observe the STOP event and do a "cont" before the STOP
3656          * event is issued, the VM will not stop.  In this case, vm_start()
3657          * also ensures that the STOP/RESUME pair of events is emitted.
3658          */
3659         qemu_system_vmstop_request_prepare();
3660         qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3661                                        is_read ? IO_OPERATION_TYPE_READ :
3662                                        IO_OPERATION_TYPE_WRITE,
3663                                        action, &error_abort);
3664         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
3665     } else {
3666         qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3667                                        is_read ? IO_OPERATION_TYPE_READ :
3668                                        IO_OPERATION_TYPE_WRITE,
3669                                        action, &error_abort);
3670     }
3671 }
3672
3673 int bdrv_is_read_only(BlockDriverState *bs)
3674 {
3675     return bs->read_only;
3676 }
3677
3678 int bdrv_is_sg(BlockDriverState *bs)
3679 {
3680     return bs->sg;
3681 }
3682
3683 int bdrv_enable_write_cache(BlockDriverState *bs)
3684 {
3685     return bs->enable_write_cache;
3686 }
3687
3688 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3689 {
3690     bs->enable_write_cache = wce;
3691
3692     /* so a reopen() will preserve wce */
3693     if (wce) {
3694         bs->open_flags |= BDRV_O_CACHE_WB;
3695     } else {
3696         bs->open_flags &= ~BDRV_O_CACHE_WB;
3697     }
3698 }
3699
3700 int bdrv_is_encrypted(BlockDriverState *bs)
3701 {
3702     if (bs->backing_hd && bs->backing_hd->encrypted)
3703         return 1;
3704     return bs->encrypted;
3705 }
3706
3707 int bdrv_key_required(BlockDriverState *bs)
3708 {
3709     BlockDriverState *backing_hd = bs->backing_hd;
3710
3711     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3712         return 1;
3713     return (bs->encrypted && !bs->valid_key);
3714 }
3715
3716 int bdrv_set_key(BlockDriverState *bs, const char *key)
3717 {
3718     int ret;
3719     if (bs->backing_hd && bs->backing_hd->encrypted) {
3720         ret = bdrv_set_key(bs->backing_hd, key);
3721         if (ret < 0)
3722             return ret;
3723         if (!bs->encrypted)
3724             return 0;
3725     }
3726     if (!bs->encrypted) {
3727         return -EINVAL;
3728     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3729         return -ENOMEDIUM;
3730     }
3731     ret = bs->drv->bdrv_set_key(bs, key);
3732     if (ret < 0) {
3733         bs->valid_key = 0;
3734     } else if (!bs->valid_key) {
3735         bs->valid_key = 1;
3736         /* call the change callback now, we skipped it on open */
3737         bdrv_dev_change_media_cb(bs, true);
3738     }
3739     return ret;
3740 }
3741
3742 const char *bdrv_get_format_name(BlockDriverState *bs)
3743 {
3744     return bs->drv ? bs->drv->format_name : NULL;
3745 }
3746
3747 static int qsort_strcmp(const void *a, const void *b)
3748 {
3749     return strcmp(a, b);
3750 }
3751
3752 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3753                          void *opaque)
3754 {
3755     BlockDriver *drv;
3756     int count = 0;
3757     int i;
3758     const char **formats = NULL;
3759
3760     QLIST_FOREACH(drv, &bdrv_drivers, list) {
3761         if (drv->format_name) {
3762             bool found = false;
3763             int i = count;
3764             while (formats && i && !found) {
3765                 found = !strcmp(formats[--i], drv->format_name);
3766             }
3767
3768             if (!found) {
3769                 formats = g_renew(const char *, formats, count + 1);
3770                 formats[count++] = drv->format_name;
3771             }
3772         }
3773     }
3774
3775     qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
3776
3777     for (i = 0; i < count; i++) {
3778         it(opaque, formats[i]);
3779     }
3780
3781     g_free(formats);
3782 }
3783
3784 /* This function is to find block backend bs */
3785 BlockDriverState *bdrv_find(const char *name)
3786 {
3787     BlockDriverState *bs;
3788
3789     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3790         if (!strcmp(name, bs->device_name)) {
3791             return bs;
3792         }
3793     }
3794     return NULL;
3795 }
3796
3797 /* This function is to find a node in the bs graph */
3798 BlockDriverState *bdrv_find_node(const char *node_name)
3799 {
3800     BlockDriverState *bs;
3801
3802     assert(node_name);
3803
3804     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3805         if (!strcmp(node_name, bs->node_name)) {
3806             return bs;
3807         }
3808     }
3809     return NULL;
3810 }
3811
3812 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3813 BlockDeviceInfoList *bdrv_named_nodes_list(void)
3814 {
3815     BlockDeviceInfoList *list, *entry;
3816     BlockDriverState *bs;
3817
3818     list = NULL;
3819     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3820         entry = g_malloc0(sizeof(*entry));
3821         entry->value = bdrv_block_device_info(bs);
3822         entry->next = list;
3823         list = entry;
3824     }
3825
3826     return list;
3827 }
3828
3829 BlockDriverState *bdrv_lookup_bs(const char *device,
3830                                  const char *node_name,
3831                                  Error **errp)
3832 {
3833     BlockDriverState *bs = NULL;
3834
3835     if (device) {
3836         bs = bdrv_find(device);
3837
3838         if (bs) {
3839             return bs;
3840         }
3841     }
3842
3843     if (node_name) {
3844         bs = bdrv_find_node(node_name);
3845
3846         if (bs) {
3847             return bs;
3848         }
3849     }
3850
3851     error_setg(errp, "Cannot find device=%s nor node_name=%s",
3852                      device ? device : "",
3853                      node_name ? node_name : "");
3854     return NULL;
3855 }
3856
3857 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3858  * return false.  If either argument is NULL, return false. */
3859 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3860 {
3861     while (top && top != base) {
3862         top = top->backing_hd;
3863     }
3864
3865     return top != NULL;
3866 }
3867
3868 BlockDriverState *bdrv_next(BlockDriverState *bs)
3869 {
3870     if (!bs) {
3871         return QTAILQ_FIRST(&bdrv_states);
3872     }
3873     return QTAILQ_NEXT(bs, device_list);
3874 }
3875
3876 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
3877 {
3878     BlockDriverState *bs;
3879
3880     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3881         it(opaque, bs);
3882     }
3883 }
3884
3885 const char *bdrv_get_device_name(BlockDriverState *bs)
3886 {
3887     return bs->device_name;
3888 }
3889
3890 int bdrv_get_flags(BlockDriverState *bs)
3891 {
3892     return bs->open_flags;
3893 }
3894
3895 int bdrv_flush_all(void)
3896 {
3897     BlockDriverState *bs;
3898     int result = 0;
3899
3900     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3901         AioContext *aio_context = bdrv_get_aio_context(bs);
3902         int ret;
3903
3904         aio_context_acquire(aio_context);
3905         ret = bdrv_flush(bs);
3906         if (ret < 0 && !result) {
3907             result = ret;
3908         }
3909         aio_context_release(aio_context);
3910     }
3911
3912     return result;
3913 }
3914
3915 int bdrv_has_zero_init_1(BlockDriverState *bs)
3916 {
3917     return 1;
3918 }
3919
3920 int bdrv_has_zero_init(BlockDriverState *bs)
3921 {
3922     assert(bs->drv);
3923
3924     /* If BS is a copy on write image, it is initialized to
3925        the contents of the base image, which may not be zeroes.  */
3926     if (bs->backing_hd) {
3927         return 0;
3928     }
3929     if (bs->drv->bdrv_has_zero_init) {
3930         return bs->drv->bdrv_has_zero_init(bs);
3931     }
3932
3933     /* safe default */
3934     return 0;
3935 }
3936
3937 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3938 {
3939     BlockDriverInfo bdi;
3940
3941     if (bs->backing_hd) {
3942         return false;
3943     }
3944
3945     if (bdrv_get_info(bs, &bdi) == 0) {
3946         return bdi.unallocated_blocks_are_zero;
3947     }
3948
3949     return false;
3950 }
3951
3952 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3953 {
3954     BlockDriverInfo bdi;
3955
3956     if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3957         return false;
3958     }
3959
3960     if (bdrv_get_info(bs, &bdi) == 0) {
3961         return bdi.can_write_zeroes_with_unmap;
3962     }
3963
3964     return false;
3965 }
3966
3967 typedef struct BdrvCoGetBlockStatusData {
3968     BlockDriverState *bs;
3969     BlockDriverState *base;
3970     int64_t sector_num;
3971     int nb_sectors;
3972     int *pnum;
3973     int64_t ret;
3974     bool done;
3975 } BdrvCoGetBlockStatusData;
3976
3977 /*
3978  * Returns true iff the specified sector is present in the disk image. Drivers
3979  * not implementing the functionality are assumed to not support backing files,
3980  * hence all their sectors are reported as allocated.
3981  *
3982  * If 'sector_num' is beyond the end of the disk image the return value is 0
3983  * and 'pnum' is set to 0.
3984  *
3985  * 'pnum' is set to the number of sectors (including and immediately following
3986  * the specified sector) that are known to be in the same
3987  * allocated/unallocated state.
3988  *
3989  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
3990  * beyond the end of the disk image it will be clamped.
3991  */
3992 static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3993                                                      int64_t sector_num,
3994                                                      int nb_sectors, int *pnum)
3995 {
3996     int64_t total_sectors;
3997     int64_t n;
3998     int64_t ret, ret2;
3999
4000     total_sectors = bdrv_nb_sectors(bs);
4001     if (total_sectors < 0) {
4002         return total_sectors;
4003     }
4004
4005     if (sector_num >= total_sectors) {
4006         *pnum = 0;
4007         return 0;
4008     }
4009
4010     n = total_sectors - sector_num;
4011     if (n < nb_sectors) {
4012         nb_sectors = n;
4013     }
4014
4015     if (!bs->drv->bdrv_co_get_block_status) {
4016         *pnum = nb_sectors;
4017         ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
4018         if (bs->drv->protocol_name) {
4019             ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
4020         }
4021         return ret;
4022     }
4023
4024     ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
4025     if (ret < 0) {
4026         *pnum = 0;
4027         return ret;
4028     }
4029
4030     if (ret & BDRV_BLOCK_RAW) {
4031         assert(ret & BDRV_BLOCK_OFFSET_VALID);
4032         return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4033                                      *pnum, pnum);
4034     }
4035
4036     if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
4037         ret |= BDRV_BLOCK_ALLOCATED;
4038     }
4039
4040     if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
4041         if (bdrv_unallocated_blocks_are_zero(bs)) {
4042             ret |= BDRV_BLOCK_ZERO;
4043         } else if (bs->backing_hd) {
4044             BlockDriverState *bs2 = bs->backing_hd;
4045             int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
4046             if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
4047                 ret |= BDRV_BLOCK_ZERO;
4048             }
4049         }
4050     }
4051
4052     if (bs->file &&
4053         (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
4054         (ret & BDRV_BLOCK_OFFSET_VALID)) {
4055         ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4056                                         *pnum, pnum);
4057         if (ret2 >= 0) {
4058             /* Ignore errors.  This is just providing extra information, it
4059              * is useful but not necessary.
4060              */
4061             ret |= (ret2 & BDRV_BLOCK_ZERO);
4062         }
4063     }
4064
4065     return ret;
4066 }
4067
4068 /* Coroutine wrapper for bdrv_get_block_status() */
4069 static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
4070 {
4071     BdrvCoGetBlockStatusData *data = opaque;
4072     BlockDriverState *bs = data->bs;
4073
4074     data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4075                                          data->pnum);
4076     data->done = true;
4077 }
4078
4079 /*
4080  * Synchronous wrapper around bdrv_co_get_block_status().
4081  *
4082  * See bdrv_co_get_block_status() for details.
4083  */
4084 int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4085                               int nb_sectors, int *pnum)
4086 {
4087     Coroutine *co;
4088     BdrvCoGetBlockStatusData data = {
4089         .bs = bs,
4090         .sector_num = sector_num,
4091         .nb_sectors = nb_sectors,
4092         .pnum = pnum,
4093         .done = false,
4094     };
4095
4096     if (qemu_in_coroutine()) {
4097         /* Fast-path if already in coroutine context */
4098         bdrv_get_block_status_co_entry(&data);
4099     } else {
4100         AioContext *aio_context = bdrv_get_aio_context(bs);
4101
4102         co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
4103         qemu_coroutine_enter(co, &data);
4104         while (!data.done) {
4105             aio_poll(aio_context, true);
4106         }
4107     }
4108     return data.ret;
4109 }
4110
4111 int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4112                                    int nb_sectors, int *pnum)
4113 {
4114     int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4115     if (ret < 0) {
4116         return ret;
4117     }
4118     return !!(ret & BDRV_BLOCK_ALLOCATED);
4119 }
4120
4121 /*
4122  * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4123  *
4124  * Return true if the given sector is allocated in any image between
4125  * BASE and TOP (inclusive).  BASE can be NULL to check if the given
4126  * sector is allocated in any image of the chain.  Return false otherwise.
4127  *
4128  * 'pnum' is set to the number of sectors (including and immediately following
4129  *  the specified sector) that are known to be in the same
4130  *  allocated/unallocated state.
4131  *
4132  */
4133 int bdrv_is_allocated_above(BlockDriverState *top,
4134                             BlockDriverState *base,
4135                             int64_t sector_num,
4136                             int nb_sectors, int *pnum)
4137 {
4138     BlockDriverState *intermediate;
4139     int ret, n = nb_sectors;
4140
4141     intermediate = top;
4142     while (intermediate && intermediate != base) {
4143         int pnum_inter;
4144         ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4145                                 &pnum_inter);
4146         if (ret < 0) {
4147             return ret;
4148         } else if (ret) {
4149             *pnum = pnum_inter;
4150             return 1;
4151         }
4152
4153         /*
4154          * [sector_num, nb_sectors] is unallocated on top but intermediate
4155          * might have
4156          *
4157          * [sector_num+x, nr_sectors] allocated.
4158          */
4159         if (n > pnum_inter &&
4160             (intermediate == top ||
4161              sector_num + pnum_inter < intermediate->total_sectors)) {
4162             n = pnum_inter;
4163         }
4164
4165         intermediate = intermediate->backing_hd;
4166     }
4167
4168     *pnum = n;
4169     return 0;
4170 }
4171
4172 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4173 {
4174     if (bs->backing_hd && bs->backing_hd->encrypted)
4175         return bs->backing_file;
4176     else if (bs->encrypted)
4177         return bs->filename;
4178     else
4179         return NULL;
4180 }
4181
4182 void bdrv_get_backing_filename(BlockDriverState *bs,
4183                                char *filename, int filename_size)
4184 {
4185     pstrcpy(filename, filename_size, bs->backing_file);
4186 }
4187
4188 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
4189                           const uint8_t *buf, int nb_sectors)
4190 {
4191     BlockDriver *drv = bs->drv;
4192     if (!drv)
4193         return -ENOMEDIUM;
4194     if (!drv->bdrv_write_compressed)
4195         return -ENOTSUP;
4196     if (bdrv_check_request(bs, sector_num, nb_sectors))
4197         return -EIO;
4198
4199     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4200
4201     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4202 }
4203
4204 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4205 {
4206     BlockDriver *drv = bs->drv;
4207     if (!drv)
4208         return -ENOMEDIUM;
4209     if (!drv->bdrv_get_info)
4210         return -ENOTSUP;
4211     memset(bdi, 0, sizeof(*bdi));
4212     return drv->bdrv_get_info(bs, bdi);
4213 }
4214
4215 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4216 {
4217     BlockDriver *drv = bs->drv;
4218     if (drv && drv->bdrv_get_specific_info) {
4219         return drv->bdrv_get_specific_info(bs);
4220     }
4221     return NULL;
4222 }
4223
4224 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4225                       int64_t pos, int size)
4226 {
4227     QEMUIOVector qiov;
4228     struct iovec iov = {
4229         .iov_base   = (void *) buf,
4230         .iov_len    = size,
4231     };
4232
4233     qemu_iovec_init_external(&qiov, &iov, 1);
4234     return bdrv_writev_vmstate(bs, &qiov, pos);
4235 }
4236
4237 int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4238 {
4239     BlockDriver *drv = bs->drv;
4240
4241     if (!drv) {
4242         return -ENOMEDIUM;
4243     } else if (drv->bdrv_save_vmstate) {
4244         return drv->bdrv_save_vmstate(bs, qiov, pos);
4245     } else if (bs->file) {
4246         return bdrv_writev_vmstate(bs->file, qiov, pos);
4247     }
4248
4249     return -ENOTSUP;
4250 }
4251
4252 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4253                       int64_t pos, int size)
4254 {
4255     BlockDriver *drv = bs->drv;
4256     if (!drv)
4257         return -ENOMEDIUM;
4258     if (drv->bdrv_load_vmstate)
4259         return drv->bdrv_load_vmstate(bs, buf, pos, size);
4260     if (bs->file)
4261         return bdrv_load_vmstate(bs->file, buf, pos, size);
4262     return -ENOTSUP;
4263 }
4264
4265 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4266 {
4267     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4268         return;
4269     }
4270
4271     bs->drv->bdrv_debug_event(bs, event);
4272 }
4273
4274 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4275                           const char *tag)
4276 {
4277     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4278         bs = bs->file;
4279     }
4280
4281     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4282         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4283     }
4284
4285     return -ENOTSUP;
4286 }
4287
4288 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4289 {
4290     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4291         bs = bs->file;
4292     }
4293
4294     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4295         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4296     }
4297
4298     return -ENOTSUP;
4299 }
4300
4301 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4302 {
4303     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4304         bs = bs->file;
4305     }
4306
4307     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4308         return bs->drv->bdrv_debug_resume(bs, tag);
4309     }
4310
4311     return -ENOTSUP;
4312 }
4313
4314 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4315 {
4316     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4317         bs = bs->file;
4318     }
4319
4320     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4321         return bs->drv->bdrv_debug_is_suspended(bs, tag);
4322     }
4323
4324     return false;
4325 }
4326
4327 int bdrv_is_snapshot(BlockDriverState *bs)
4328 {
4329     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4330 }
4331
4332 /* backing_file can either be relative, or absolute, or a protocol.  If it is
4333  * relative, it must be relative to the chain.  So, passing in bs->filename
4334  * from a BDS as backing_file should not be done, as that may be relative to
4335  * the CWD rather than the chain. */
4336 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4337         const char *backing_file)
4338 {
4339     char *filename_full = NULL;
4340     char *backing_file_full = NULL;
4341     char *filename_tmp = NULL;
4342     int is_protocol = 0;
4343     BlockDriverState *curr_bs = NULL;
4344     BlockDriverState *retval = NULL;
4345
4346     if (!bs || !bs->drv || !backing_file) {
4347         return NULL;
4348     }
4349
4350     filename_full     = g_malloc(PATH_MAX);
4351     backing_file_full = g_malloc(PATH_MAX);
4352     filename_tmp      = g_malloc(PATH_MAX);
4353
4354     is_protocol = path_has_protocol(backing_file);
4355
4356     for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4357
4358         /* If either of the filename paths is actually a protocol, then
4359          * compare unmodified paths; otherwise make paths relative */
4360         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4361             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4362                 retval = curr_bs->backing_hd;
4363                 break;
4364             }
4365         } else {
4366             /* If not an absolute filename path, make it relative to the current
4367              * image's filename path */
4368             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4369                          backing_file);
4370
4371             /* We are going to compare absolute pathnames */
4372             if (!realpath(filename_tmp, filename_full)) {
4373                 continue;
4374             }
4375
4376             /* We need to make sure the backing filename we are comparing against
4377              * is relative to the current image filename (or absolute) */
4378             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4379                          curr_bs->backing_file);
4380
4381             if (!realpath(filename_tmp, backing_file_full)) {
4382                 continue;
4383             }
4384
4385             if (strcmp(backing_file_full, filename_full) == 0) {
4386                 retval = curr_bs->backing_hd;
4387                 break;
4388             }
4389         }
4390     }
4391
4392     g_free(filename_full);
4393     g_free(backing_file_full);
4394     g_free(filename_tmp);
4395     return retval;
4396 }
4397
4398 int bdrv_get_backing_file_depth(BlockDriverState *bs)
4399 {
4400     if (!bs->drv) {
4401         return 0;
4402     }
4403
4404     if (!bs->backing_hd) {
4405         return 0;
4406     }
4407
4408     return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4409 }
4410
4411 /**************************************************************/
4412 /* async I/Os */
4413
4414 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4415                                  QEMUIOVector *qiov, int nb_sectors,
4416                                  BlockDriverCompletionFunc *cb, void *opaque)
4417 {
4418     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4419
4420     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4421                                  cb, opaque, false);
4422 }
4423
4424 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4425                                   QEMUIOVector *qiov, int nb_sectors,
4426                                   BlockDriverCompletionFunc *cb, void *opaque)
4427 {
4428     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4429
4430     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4431                                  cb, opaque, true);
4432 }
4433
4434 BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4435         int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4436         BlockDriverCompletionFunc *cb, void *opaque)
4437 {
4438     trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4439
4440     return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4441                                  BDRV_REQ_ZERO_WRITE | flags,
4442                                  cb, opaque, true);
4443 }
4444
4445
4446 typedef struct MultiwriteCB {
4447     int error;
4448     int num_requests;
4449     int num_callbacks;
4450     struct {
4451         BlockDriverCompletionFunc *cb;
4452         void *opaque;
4453         QEMUIOVector *free_qiov;
4454     } callbacks[];
4455 } MultiwriteCB;
4456
4457 static void multiwrite_user_cb(MultiwriteCB *mcb)
4458 {
4459     int i;
4460
4461     for (i = 0; i < mcb->num_callbacks; i++) {
4462         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
4463         if (mcb->callbacks[i].free_qiov) {
4464             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4465         }
4466         g_free(mcb->callbacks[i].free_qiov);
4467     }
4468 }
4469
4470 static void multiwrite_cb(void *opaque, int ret)
4471 {
4472     MultiwriteCB *mcb = opaque;
4473
4474     trace_multiwrite_cb(mcb, ret);
4475
4476     if (ret < 0 && !mcb->error) {
4477         mcb->error = ret;
4478     }
4479
4480     mcb->num_requests--;
4481     if (mcb->num_requests == 0) {
4482         multiwrite_user_cb(mcb);
4483         g_free(mcb);
4484     }
4485 }
4486
4487 static int multiwrite_req_compare(const void *a, const void *b)
4488 {
4489     const BlockRequest *req1 = a, *req2 = b;
4490
4491     /*
4492      * Note that we can't simply subtract req2->sector from req1->sector
4493      * here as that could overflow the return value.
4494      */
4495     if (req1->sector > req2->sector) {
4496         return 1;
4497     } else if (req1->sector < req2->sector) {
4498         return -1;
4499     } else {
4500         return 0;
4501     }
4502 }
4503
4504 /*
4505  * Takes a bunch of requests and tries to merge them. Returns the number of
4506  * requests that remain after merging.
4507  */
4508 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4509     int num_reqs, MultiwriteCB *mcb)
4510 {
4511     int i, outidx;
4512
4513     // Sort requests by start sector
4514     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4515
4516     // Check if adjacent requests touch the same clusters. If so, combine them,
4517     // filling up gaps with zero sectors.
4518     outidx = 0;
4519     for (i = 1; i < num_reqs; i++) {
4520         int merge = 0;
4521         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4522
4523         // Handle exactly sequential writes and overlapping writes.
4524         if (reqs[i].sector <= oldreq_last) {
4525             merge = 1;
4526         }
4527
4528         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4529             merge = 0;
4530         }
4531
4532         if (merge) {
4533             size_t size;
4534             QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
4535             qemu_iovec_init(qiov,
4536                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4537
4538             // Add the first request to the merged one. If the requests are
4539             // overlapping, drop the last sectors of the first request.
4540             size = (reqs[i].sector - reqs[outidx].sector) << 9;
4541             qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
4542
4543             // We should need to add any zeros between the two requests
4544             assert (reqs[i].sector <= oldreq_last);
4545
4546             // Add the second request
4547             qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
4548
4549             reqs[outidx].nb_sectors = qiov->size >> 9;
4550             reqs[outidx].qiov = qiov;
4551
4552             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4553         } else {
4554             outidx++;
4555             reqs[outidx].sector     = reqs[i].sector;
4556             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4557             reqs[outidx].qiov       = reqs[i].qiov;
4558         }
4559     }
4560
4561     return outidx + 1;
4562 }
4563
4564 /*
4565  * Submit multiple AIO write requests at once.
4566  *
4567  * On success, the function returns 0 and all requests in the reqs array have
4568  * been submitted. In error case this function returns -1, and any of the
4569  * requests may or may not be submitted yet. In particular, this means that the
4570  * callback will be called for some of the requests, for others it won't. The
4571  * caller must check the error field of the BlockRequest to wait for the right
4572  * callbacks (if error != 0, no callback will be called).
4573  *
4574  * The implementation may modify the contents of the reqs array, e.g. to merge
4575  * requests. However, the fields opaque and error are left unmodified as they
4576  * are used to signal failure for a single request to the caller.
4577  */
4578 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4579 {
4580     MultiwriteCB *mcb;
4581     int i;
4582
4583     /* don't submit writes if we don't have a medium */
4584     if (bs->drv == NULL) {
4585         for (i = 0; i < num_reqs; i++) {
4586             reqs[i].error = -ENOMEDIUM;
4587         }
4588         return -1;
4589     }
4590
4591     if (num_reqs == 0) {
4592         return 0;
4593     }
4594
4595     // Create MultiwriteCB structure
4596     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
4597     mcb->num_requests = 0;
4598     mcb->num_callbacks = num_reqs;
4599
4600     for (i = 0; i < num_reqs; i++) {
4601         mcb->callbacks[i].cb = reqs[i].cb;
4602         mcb->callbacks[i].opaque = reqs[i].opaque;
4603     }
4604
4605     // Check for mergable requests
4606     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4607
4608     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4609
4610     /* Run the aio requests. */
4611     mcb->num_requests = num_reqs;
4612     for (i = 0; i < num_reqs; i++) {
4613         bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4614                               reqs[i].nb_sectors, reqs[i].flags,
4615                               multiwrite_cb, mcb,
4616                               true);
4617     }
4618
4619     return 0;
4620 }
4621
4622 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
4623 {
4624     acb->aiocb_info->cancel(acb);
4625 }
4626
4627 /**************************************************************/
4628 /* async block device emulation */
4629
4630 typedef struct BlockDriverAIOCBSync {
4631     BlockDriverAIOCB common;
4632     QEMUBH *bh;
4633     int ret;
4634     /* vector translation state */
4635     QEMUIOVector *qiov;
4636     uint8_t *bounce;
4637     int is_write;
4638 } BlockDriverAIOCBSync;
4639
4640 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4641 {
4642     BlockDriverAIOCBSync *acb =
4643         container_of(blockacb, BlockDriverAIOCBSync, common);
4644     qemu_bh_delete(acb->bh);
4645     acb->bh = NULL;
4646     qemu_aio_release(acb);
4647 }
4648
4649 static const AIOCBInfo bdrv_em_aiocb_info = {
4650     .aiocb_size         = sizeof(BlockDriverAIOCBSync),
4651     .cancel             = bdrv_aio_cancel_em,
4652 };
4653
4654 static void bdrv_aio_bh_cb(void *opaque)
4655 {
4656     BlockDriverAIOCBSync *acb = opaque;
4657
4658     if (!acb->is_write && acb->ret >= 0) {
4659         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4660     }
4661     qemu_vfree(acb->bounce);
4662     acb->common.cb(acb->common.opaque, acb->ret);
4663     qemu_bh_delete(acb->bh);
4664     acb->bh = NULL;
4665     qemu_aio_release(acb);
4666 }
4667
4668 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4669                                             int64_t sector_num,
4670                                             QEMUIOVector *qiov,
4671                                             int nb_sectors,
4672                                             BlockDriverCompletionFunc *cb,
4673                                             void *opaque,
4674                                             int is_write)
4675
4676 {
4677     BlockDriverAIOCBSync *acb;
4678
4679     acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4680     acb->is_write = is_write;
4681     acb->qiov = qiov;
4682     acb->bounce = qemu_try_blockalign(bs, qiov->size);
4683     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
4684
4685     if (acb->bounce == NULL) {
4686         acb->ret = -ENOMEM;
4687     } else if (is_write) {
4688         qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4689         acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4690     } else {
4691         acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4692     }
4693
4694     qemu_bh_schedule(acb->bh);
4695
4696     return &acb->common;
4697 }
4698
4699 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4700         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4701         BlockDriverCompletionFunc *cb, void *opaque)
4702 {
4703     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
4704 }
4705
4706 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4707         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4708         BlockDriverCompletionFunc *cb, void *opaque)
4709 {
4710     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4711 }
4712
4713
4714 typedef struct BlockDriverAIOCBCoroutine {
4715     BlockDriverAIOCB common;
4716     BlockRequest req;
4717     bool is_write;
4718     bool *done;
4719     QEMUBH* bh;
4720 } BlockDriverAIOCBCoroutine;
4721
4722 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4723 {
4724     AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
4725     BlockDriverAIOCBCoroutine *acb =
4726         container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4727     bool done = false;
4728
4729     acb->done = &done;
4730     while (!done) {
4731         aio_poll(aio_context, true);
4732     }
4733 }
4734
4735 static const AIOCBInfo bdrv_em_co_aiocb_info = {
4736     .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
4737     .cancel             = bdrv_aio_co_cancel_em,
4738 };
4739
4740 static void bdrv_co_em_bh(void *opaque)
4741 {
4742     BlockDriverAIOCBCoroutine *acb = opaque;
4743
4744     acb->common.cb(acb->common.opaque, acb->req.error);
4745
4746     if (acb->done) {
4747         *acb->done = true;
4748     }
4749
4750     qemu_bh_delete(acb->bh);
4751     qemu_aio_release(acb);
4752 }
4753
4754 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4755 static void coroutine_fn bdrv_co_do_rw(void *opaque)
4756 {
4757     BlockDriverAIOCBCoroutine *acb = opaque;
4758     BlockDriverState *bs = acb->common.bs;
4759
4760     if (!acb->is_write) {
4761         acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
4762             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4763     } else {
4764         acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
4765             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4766     }
4767
4768     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4769     qemu_bh_schedule(acb->bh);
4770 }
4771
4772 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4773                                                int64_t sector_num,
4774                                                QEMUIOVector *qiov,
4775                                                int nb_sectors,
4776                                                BdrvRequestFlags flags,
4777                                                BlockDriverCompletionFunc *cb,
4778                                                void *opaque,
4779                                                bool is_write)
4780 {
4781     Coroutine *co;
4782     BlockDriverAIOCBCoroutine *acb;
4783
4784     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4785     acb->req.sector = sector_num;
4786     acb->req.nb_sectors = nb_sectors;
4787     acb->req.qiov = qiov;
4788     acb->req.flags = flags;
4789     acb->is_write = is_write;
4790     acb->done = NULL;
4791
4792     co = qemu_coroutine_create(bdrv_co_do_rw);
4793     qemu_coroutine_enter(co, acb);
4794
4795     return &acb->common;
4796 }
4797
4798 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4799 {
4800     BlockDriverAIOCBCoroutine *acb = opaque;
4801     BlockDriverState *bs = acb->common.bs;
4802
4803     acb->req.error = bdrv_co_flush(bs);
4804     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4805     qemu_bh_schedule(acb->bh);
4806 }
4807
4808 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4809         BlockDriverCompletionFunc *cb, void *opaque)
4810 {
4811     trace_bdrv_aio_flush(bs, opaque);
4812
4813     Coroutine *co;
4814     BlockDriverAIOCBCoroutine *acb;
4815
4816     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4817     acb->done = NULL;
4818
4819     co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4820     qemu_coroutine_enter(co, acb);
4821
4822     return &acb->common;
4823 }
4824
4825 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4826 {
4827     BlockDriverAIOCBCoroutine *acb = opaque;
4828     BlockDriverState *bs = acb->common.bs;
4829
4830     acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4831     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4832     qemu_bh_schedule(acb->bh);
4833 }
4834
4835 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4836         int64_t sector_num, int nb_sectors,
4837         BlockDriverCompletionFunc *cb, void *opaque)
4838 {
4839     Coroutine *co;
4840     BlockDriverAIOCBCoroutine *acb;
4841
4842     trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4843
4844     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4845     acb->req.sector = sector_num;
4846     acb->req.nb_sectors = nb_sectors;
4847     acb->done = NULL;
4848     co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4849     qemu_coroutine_enter(co, acb);
4850
4851     return &acb->common;
4852 }
4853
4854 void bdrv_init(void)
4855 {
4856     module_call_init(MODULE_INIT_BLOCK);
4857 }
4858
4859 void bdrv_init_with_whitelist(void)
4860 {
4861     use_bdrv_whitelist = 1;
4862     bdrv_init();
4863 }
4864
4865 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4866                    BlockDriverCompletionFunc *cb, void *opaque)
4867 {
4868     BlockDriverAIOCB *acb;
4869
4870     acb = g_slice_alloc(aiocb_info->aiocb_size);
4871     acb->aiocb_info = aiocb_info;
4872     acb->bs = bs;
4873     acb->cb = cb;
4874     acb->opaque = opaque;
4875     return acb;
4876 }
4877
4878 void qemu_aio_release(void *p)
4879 {
4880     BlockDriverAIOCB *acb = p;
4881     g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4882 }
4883
4884 /**************************************************************/
4885 /* Coroutine block device emulation */
4886
4887 typedef struct CoroutineIOCompletion {
4888     Coroutine *coroutine;
4889     int ret;
4890 } CoroutineIOCompletion;
4891
4892 static void bdrv_co_io_em_complete(void *opaque, int ret)
4893 {
4894     CoroutineIOCompletion *co = opaque;
4895
4896     co->ret = ret;
4897     qemu_coroutine_enter(co->coroutine, NULL);
4898 }
4899
4900 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4901                                       int nb_sectors, QEMUIOVector *iov,
4902                                       bool is_write)
4903 {
4904     CoroutineIOCompletion co = {
4905         .coroutine = qemu_coroutine_self(),
4906     };
4907     BlockDriverAIOCB *acb;
4908
4909     if (is_write) {
4910         acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4911                                        bdrv_co_io_em_complete, &co);
4912     } else {
4913         acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4914                                       bdrv_co_io_em_complete, &co);
4915     }
4916
4917     trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4918     if (!acb) {
4919         return -EIO;
4920     }
4921     qemu_coroutine_yield();
4922
4923     return co.ret;
4924 }
4925
4926 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4927                                          int64_t sector_num, int nb_sectors,
4928                                          QEMUIOVector *iov)
4929 {
4930     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4931 }
4932
4933 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4934                                          int64_t sector_num, int nb_sectors,
4935                                          QEMUIOVector *iov)
4936 {
4937     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4938 }
4939
4940 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4941 {
4942     RwCo *rwco = opaque;
4943
4944     rwco->ret = bdrv_co_flush(rwco->bs);
4945 }
4946
4947 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4948 {
4949     int ret;
4950
4951     if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4952         return 0;
4953     }
4954
4955     /* Write back cached data to the OS even with cache=unsafe */
4956     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
4957     if (bs->drv->bdrv_co_flush_to_os) {
4958         ret = bs->drv->bdrv_co_flush_to_os(bs);
4959         if (ret < 0) {
4960             return ret;
4961         }
4962     }
4963
4964     /* But don't actually force it to the disk with cache=unsafe */
4965     if (bs->open_flags & BDRV_O_NO_FLUSH) {
4966         goto flush_parent;
4967     }
4968
4969     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
4970     if (bs->drv->bdrv_co_flush_to_disk) {
4971         ret = bs->drv->bdrv_co_flush_to_disk(bs);
4972     } else if (bs->drv->bdrv_aio_flush) {
4973         BlockDriverAIOCB *acb;
4974         CoroutineIOCompletion co = {
4975             .coroutine = qemu_coroutine_self(),
4976         };
4977
4978         acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4979         if (acb == NULL) {
4980             ret = -EIO;
4981         } else {
4982             qemu_coroutine_yield();
4983             ret = co.ret;
4984         }
4985     } else {
4986         /*
4987          * Some block drivers always operate in either writethrough or unsafe
4988          * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4989          * know how the server works (because the behaviour is hardcoded or
4990          * depends on server-side configuration), so we can't ensure that
4991          * everything is safe on disk. Returning an error doesn't work because
4992          * that would break guests even if the server operates in writethrough
4993          * mode.
4994          *
4995          * Let's hope the user knows what he's doing.
4996          */
4997         ret = 0;
4998     }
4999     if (ret < 0) {
5000         return ret;
5001     }
5002
5003     /* Now flush the underlying protocol.  It will also have BDRV_O_NO_FLUSH
5004      * in the case of cache=unsafe, so there are no useless flushes.
5005      */
5006 flush_parent:
5007     return bdrv_co_flush(bs->file);
5008 }
5009
5010 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
5011 {
5012     Error *local_err = NULL;
5013     int ret;
5014
5015     if (!bs->drv)  {
5016         return;
5017     }
5018
5019     if (bs->drv->bdrv_invalidate_cache) {
5020         bs->drv->bdrv_invalidate_cache(bs, &local_err);
5021     } else if (bs->file) {
5022         bdrv_invalidate_cache(bs->file, &local_err);
5023     }
5024     if (local_err) {
5025         error_propagate(errp, local_err);
5026         return;
5027     }
5028
5029     ret = refresh_total_sectors(bs, bs->total_sectors);
5030     if (ret < 0) {
5031         error_setg_errno(errp, -ret, "Could not refresh total sector count");
5032         return;
5033     }
5034 }
5035
5036 void bdrv_invalidate_cache_all(Error **errp)
5037 {
5038     BlockDriverState *bs;
5039     Error *local_err = NULL;
5040
5041     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5042         AioContext *aio_context = bdrv_get_aio_context(bs);
5043
5044         aio_context_acquire(aio_context);
5045         bdrv_invalidate_cache(bs, &local_err);
5046         aio_context_release(aio_context);
5047         if (local_err) {
5048             error_propagate(errp, local_err);
5049             return;
5050         }
5051     }
5052 }
5053
5054 void bdrv_clear_incoming_migration_all(void)
5055 {
5056     BlockDriverState *bs;
5057
5058     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5059         AioContext *aio_context = bdrv_get_aio_context(bs);
5060
5061         aio_context_acquire(aio_context);
5062         bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
5063         aio_context_release(aio_context);
5064     }
5065 }
5066
5067 int bdrv_flush(BlockDriverState *bs)
5068 {
5069     Coroutine *co;
5070     RwCo rwco = {
5071         .bs = bs,
5072         .ret = NOT_DONE,
5073     };
5074
5075     if (qemu_in_coroutine()) {
5076         /* Fast-path if already in coroutine context */
5077         bdrv_flush_co_entry(&rwco);
5078     } else {
5079         AioContext *aio_context = bdrv_get_aio_context(bs);
5080
5081         co = qemu_coroutine_create(bdrv_flush_co_entry);
5082         qemu_coroutine_enter(co, &rwco);
5083         while (rwco.ret == NOT_DONE) {
5084             aio_poll(aio_context, true);
5085         }
5086     }
5087
5088     return rwco.ret;
5089 }
5090
5091 typedef struct DiscardCo {
5092     BlockDriverState *bs;
5093     int64_t sector_num;
5094     int nb_sectors;
5095     int ret;
5096 } DiscardCo;
5097 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5098 {
5099     DiscardCo *rwco = opaque;
5100
5101     rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5102 }
5103
5104 /* if no limit is specified in the BlockLimits use a default
5105  * of 32768 512-byte sectors (16 MiB) per request.
5106  */
5107 #define MAX_DISCARD_DEFAULT 32768
5108
5109 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5110                                  int nb_sectors)
5111 {
5112     int max_discard;
5113
5114     if (!bs->drv) {
5115         return -ENOMEDIUM;
5116     } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5117         return -EIO;
5118     } else if (bs->read_only) {
5119         return -EROFS;
5120     }
5121
5122     bdrv_reset_dirty(bs, sector_num, nb_sectors);
5123
5124     /* Do nothing if disabled.  */
5125     if (!(bs->open_flags & BDRV_O_UNMAP)) {
5126         return 0;
5127     }
5128
5129     if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
5130         return 0;
5131     }
5132
5133     max_discard = bs->bl.max_discard ?  bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5134     while (nb_sectors > 0) {
5135         int ret;
5136         int num = nb_sectors;
5137
5138         /* align request */
5139         if (bs->bl.discard_alignment &&
5140             num >= bs->bl.discard_alignment &&
5141             sector_num % bs->bl.discard_alignment) {
5142             if (num > bs->bl.discard_alignment) {
5143                 num = bs->bl.discard_alignment;
5144             }
5145             num -= sector_num % bs->bl.discard_alignment;
5146         }
5147
5148         /* limit request size */
5149         if (num > max_discard) {
5150             num = max_discard;
5151         }
5152
5153         if (bs->drv->bdrv_co_discard) {
5154             ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5155         } else {
5156             BlockDriverAIOCB *acb;
5157             CoroutineIOCompletion co = {
5158                 .coroutine = qemu_coroutine_self(),
5159             };
5160
5161             acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5162                                             bdrv_co_io_em_complete, &co);
5163             if (acb == NULL) {
5164                 return -EIO;
5165             } else {
5166                 qemu_coroutine_yield();
5167                 ret = co.ret;
5168             }
5169         }
5170         if (ret && ret != -ENOTSUP) {
5171             return ret;
5172         }
5173
5174         sector_num += num;
5175         nb_sectors -= num;
5176     }
5177     return 0;
5178 }
5179
5180 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5181 {
5182     Coroutine *co;
5183     DiscardCo rwco = {
5184         .bs = bs,
5185         .sector_num = sector_num,
5186         .nb_sectors = nb_sectors,
5187         .ret = NOT_DONE,
5188     };
5189
5190     if (qemu_in_coroutine()) {
5191         /* Fast-path if already in coroutine context */
5192         bdrv_discard_co_entry(&rwco);
5193     } else {
5194         AioContext *aio_context = bdrv_get_aio_context(bs);
5195
5196         co = qemu_coroutine_create(bdrv_discard_co_entry);
5197         qemu_coroutine_enter(co, &rwco);
5198         while (rwco.ret == NOT_DONE) {
5199             aio_poll(aio_context, true);
5200         }
5201     }
5202
5203     return rwco.ret;
5204 }
5205
5206 /**************************************************************/
5207 /* removable device support */
5208
5209 /**
5210  * Return TRUE if the media is present
5211  */
5212 int bdrv_is_inserted(BlockDriverState *bs)
5213 {
5214     BlockDriver *drv = bs->drv;
5215
5216     if (!drv)
5217         return 0;
5218     if (!drv->bdrv_is_inserted)
5219         return 1;
5220     return drv->bdrv_is_inserted(bs);
5221 }
5222
5223 /**
5224  * Return whether the media changed since the last call to this
5225  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
5226  */
5227 int bdrv_media_changed(BlockDriverState *bs)
5228 {
5229     BlockDriver *drv = bs->drv;
5230
5231     if (drv && drv->bdrv_media_changed) {
5232         return drv->bdrv_media_changed(bs);
5233     }
5234     return -ENOTSUP;
5235 }
5236
5237 /**
5238  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5239  */
5240 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
5241 {
5242     BlockDriver *drv = bs->drv;
5243
5244     if (drv && drv->bdrv_eject) {
5245         drv->bdrv_eject(bs, eject_flag);
5246     }
5247
5248     if (bs->device_name[0] != '\0') {
5249         qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
5250                                           eject_flag, &error_abort);
5251     }
5252 }
5253
5254 /**
5255  * Lock or unlock the media (if it is locked, the user won't be able
5256  * to eject it manually).
5257  */
5258 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
5259 {
5260     BlockDriver *drv = bs->drv;
5261
5262     trace_bdrv_lock_medium(bs, locked);
5263
5264     if (drv && drv->bdrv_lock_medium) {
5265         drv->bdrv_lock_medium(bs, locked);
5266     }
5267 }
5268
5269 /* needed for generic scsi interface */
5270
5271 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5272 {
5273     BlockDriver *drv = bs->drv;
5274
5275     if (drv && drv->bdrv_ioctl)
5276         return drv->bdrv_ioctl(bs, req, buf);
5277     return -ENOTSUP;
5278 }
5279
5280 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5281         unsigned long int req, void *buf,
5282         BlockDriverCompletionFunc *cb, void *opaque)
5283 {
5284     BlockDriver *drv = bs->drv;
5285
5286     if (drv && drv->bdrv_aio_ioctl)
5287         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5288     return NULL;
5289 }
5290
5291 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5292 {
5293     bs->guest_block_size = align;
5294 }
5295
5296 void *qemu_blockalign(BlockDriverState *bs, size_t size)
5297 {
5298     return qemu_memalign(bdrv_opt_mem_align(bs), size);
5299 }
5300
5301 void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
5302 {
5303     size_t align = bdrv_opt_mem_align(bs);
5304
5305     /* Ensure that NULL is never returned on success */
5306     assert(align > 0);
5307     if (size == 0) {
5308         size = align;
5309     }
5310
5311     return qemu_try_memalign(align, size);
5312 }
5313
5314 /*
5315  * Check if all memory in this vector is sector aligned.
5316  */
5317 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5318 {
5319     int i;
5320     size_t alignment = bdrv_opt_mem_align(bs);
5321
5322     for (i = 0; i < qiov->niov; i++) {
5323         if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5324             return false;
5325         }
5326         if (qiov->iov[i].iov_len % alignment) {
5327             return false;
5328         }
5329     }
5330
5331     return true;
5332 }
5333
5334 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5335                                           Error **errp)
5336 {
5337     int64_t bitmap_size;
5338     BdrvDirtyBitmap *bitmap;
5339
5340     assert((granularity & (granularity - 1)) == 0);
5341
5342     granularity >>= BDRV_SECTOR_BITS;
5343     assert(granularity);
5344     bitmap_size = bdrv_nb_sectors(bs);
5345     if (bitmap_size < 0) {
5346         error_setg_errno(errp, -bitmap_size, "could not get length of device");
5347         errno = -bitmap_size;
5348         return NULL;
5349     }
5350     bitmap = g_new0(BdrvDirtyBitmap, 1);
5351     bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5352     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5353     return bitmap;
5354 }
5355
5356 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5357 {
5358     BdrvDirtyBitmap *bm, *next;
5359     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5360         if (bm == bitmap) {
5361             QLIST_REMOVE(bitmap, list);
5362             hbitmap_free(bitmap->bitmap);
5363             g_free(bitmap);
5364             return;
5365         }
5366     }
5367 }
5368
5369 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5370 {
5371     BdrvDirtyBitmap *bm;
5372     BlockDirtyInfoList *list = NULL;
5373     BlockDirtyInfoList **plist = &list;
5374
5375     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5376         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
5377         BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
5378         info->count = bdrv_get_dirty_count(bs, bm);
5379         info->granularity =
5380             ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5381         entry->value = info;
5382         *plist = entry;
5383         plist = &entry->next;
5384     }
5385
5386     return list;
5387 }
5388
5389 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5390 {
5391     if (bitmap) {
5392         return hbitmap_get(bitmap->bitmap, sector);
5393     } else {
5394         return 0;
5395     }
5396 }
5397
5398 void bdrv_dirty_iter_init(BlockDriverState *bs,
5399                           BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5400 {
5401     hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5402 }
5403
5404 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5405                     int nr_sectors)
5406 {
5407     BdrvDirtyBitmap *bitmap;
5408     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5409         hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
5410     }
5411 }
5412
5413 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5414 {
5415     BdrvDirtyBitmap *bitmap;
5416     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5417         hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5418     }
5419 }
5420
5421 int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5422 {
5423     return hbitmap_count(bitmap->bitmap);
5424 }
5425
5426 /* Get a reference to bs */
5427 void bdrv_ref(BlockDriverState *bs)
5428 {
5429     bs->refcnt++;
5430 }
5431
5432 /* Release a previously grabbed reference to bs.
5433  * If after releasing, reference count is zero, the BlockDriverState is
5434  * deleted. */
5435 void bdrv_unref(BlockDriverState *bs)
5436 {
5437     if (!bs) {
5438         return;
5439     }
5440     assert(bs->refcnt > 0);
5441     if (--bs->refcnt == 0) {
5442         bdrv_delete(bs);
5443     }
5444 }
5445
5446 struct BdrvOpBlocker {
5447     Error *reason;
5448     QLIST_ENTRY(BdrvOpBlocker) list;
5449 };
5450
5451 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5452 {
5453     BdrvOpBlocker *blocker;
5454     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5455     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5456         blocker = QLIST_FIRST(&bs->op_blockers[op]);
5457         if (errp) {
5458             error_setg(errp, "Device '%s' is busy: %s",
5459                        bs->device_name, error_get_pretty(blocker->reason));
5460         }
5461         return true;
5462     }
5463     return false;
5464 }
5465
5466 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5467 {
5468     BdrvOpBlocker *blocker;
5469     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5470
5471     blocker = g_new0(BdrvOpBlocker, 1);
5472     blocker->reason = reason;
5473     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5474 }
5475
5476 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5477 {
5478     BdrvOpBlocker *blocker, *next;
5479     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5480     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5481         if (blocker->reason == reason) {
5482             QLIST_REMOVE(blocker, list);
5483             g_free(blocker);
5484         }
5485     }
5486 }
5487
5488 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5489 {
5490     int i;
5491     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5492         bdrv_op_block(bs, i, reason);
5493     }
5494 }
5495
5496 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5497 {
5498     int i;
5499     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5500         bdrv_op_unblock(bs, i, reason);
5501     }
5502 }
5503
5504 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5505 {
5506     int i;
5507
5508     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5509         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5510             return false;
5511         }
5512     }
5513     return true;
5514 }
5515
5516 void bdrv_iostatus_enable(BlockDriverState *bs)
5517 {
5518     bs->iostatus_enabled = true;
5519     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5520 }
5521
5522 /* The I/O status is only enabled if the drive explicitly
5523  * enables it _and_ the VM is configured to stop on errors */
5524 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5525 {
5526     return (bs->iostatus_enabled &&
5527            (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5528             bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
5529             bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5530 }
5531
5532 void bdrv_iostatus_disable(BlockDriverState *bs)
5533 {
5534     bs->iostatus_enabled = false;
5535 }
5536
5537 void bdrv_iostatus_reset(BlockDriverState *bs)
5538 {
5539     if (bdrv_iostatus_is_enabled(bs)) {
5540         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5541         if (bs->job) {
5542             block_job_iostatus_reset(bs->job);
5543         }
5544     }
5545 }
5546
5547 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5548 {
5549     assert(bdrv_iostatus_is_enabled(bs));
5550     if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5551         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5552                                          BLOCK_DEVICE_IO_STATUS_FAILED;
5553     }
5554 }
5555
5556 void
5557 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5558         enum BlockAcctType type)
5559 {
5560     assert(type < BDRV_MAX_IOTYPE);
5561
5562     cookie->bytes = bytes;
5563     cookie->start_time_ns = get_clock();
5564     cookie->type = type;
5565 }
5566
5567 void
5568 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5569 {
5570     assert(cookie->type < BDRV_MAX_IOTYPE);
5571
5572     bs->nr_bytes[cookie->type] += cookie->bytes;
5573     bs->nr_ops[cookie->type]++;
5574     bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
5575 }
5576
5577 void bdrv_img_create(const char *filename, const char *fmt,
5578                      const char *base_filename, const char *base_fmt,
5579                      char *options, uint64_t img_size, int flags,
5580                      Error **errp, bool quiet)
5581 {
5582     QemuOptsList *create_opts = NULL;
5583     QemuOpts *opts = NULL;
5584     const char *backing_fmt, *backing_file;
5585     int64_t size;
5586     BlockDriver *drv, *proto_drv;
5587     BlockDriver *backing_drv = NULL;
5588     Error *local_err = NULL;
5589     int ret = 0;
5590
5591     /* Find driver and parse its options */
5592     drv = bdrv_find_format(fmt);
5593     if (!drv) {
5594         error_setg(errp, "Unknown file format '%s'", fmt);
5595         return;
5596     }
5597
5598     proto_drv = bdrv_find_protocol(filename, true);
5599     if (!proto_drv) {
5600         error_setg(errp, "Unknown protocol '%s'", filename);
5601         return;
5602     }
5603
5604     create_opts = qemu_opts_append(create_opts, drv->create_opts);
5605     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5606
5607     /* Create parameter list with default values */
5608     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5609     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
5610
5611     /* Parse -o options */
5612     if (options) {
5613         if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5614             error_setg(errp, "Invalid options for file format '%s'", fmt);
5615             goto out;
5616         }
5617     }
5618
5619     if (base_filename) {
5620         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
5621             error_setg(errp, "Backing file not supported for file format '%s'",
5622                        fmt);
5623             goto out;
5624         }
5625     }
5626
5627     if (base_fmt) {
5628         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5629             error_setg(errp, "Backing file format not supported for file "
5630                              "format '%s'", fmt);
5631             goto out;
5632         }
5633     }
5634
5635     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5636     if (backing_file) {
5637         if (!strcmp(filename, backing_file)) {
5638             error_setg(errp, "Error: Trying to create an image with the "
5639                              "same filename as the backing file");
5640             goto out;
5641         }
5642     }
5643
5644     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5645     if (backing_fmt) {
5646         backing_drv = bdrv_find_format(backing_fmt);
5647         if (!backing_drv) {
5648             error_setg(errp, "Unknown backing file format '%s'",
5649                        backing_fmt);
5650             goto out;
5651         }
5652     }
5653
5654     // The size for the image must always be specified, with one exception:
5655     // If we are using a backing file, we can obtain the size from there
5656     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5657     if (size == -1) {
5658         if (backing_file) {
5659             BlockDriverState *bs;
5660             int64_t size;
5661             int back_flags;
5662
5663             /* backing files always opened read-only */
5664             back_flags =
5665                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
5666
5667             bs = NULL;
5668             ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
5669                             backing_drv, &local_err);
5670             if (ret < 0) {
5671                 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5672                                  backing_file,
5673                                  error_get_pretty(local_err));
5674                 error_free(local_err);
5675                 local_err = NULL;
5676                 goto out;
5677             }
5678             size = bdrv_getlength(bs);
5679             if (size < 0) {
5680                 error_setg_errno(errp, -size, "Could not get size of '%s'",
5681                                  backing_file);
5682                 bdrv_unref(bs);
5683                 goto out;
5684             }
5685
5686             qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
5687
5688             bdrv_unref(bs);
5689         } else {
5690             error_setg(errp, "Image creation needs a size parameter");
5691             goto out;
5692         }
5693     }
5694
5695     if (!quiet) {
5696         printf("Formatting '%s', fmt=%s ", filename, fmt);
5697         qemu_opts_print(opts);
5698         puts("");
5699     }
5700
5701     ret = bdrv_create(drv, filename, opts, &local_err);
5702
5703     if (ret == -EFBIG) {
5704         /* This is generally a better message than whatever the driver would
5705          * deliver (especially because of the cluster_size_hint), since that
5706          * is most probably not much different from "image too large". */
5707         const char *cluster_size_hint = "";
5708         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5709             cluster_size_hint = " (try using a larger cluster size)";
5710         }
5711         error_setg(errp, "The image size is too large for file format '%s'"
5712                    "%s", fmt, cluster_size_hint);
5713         error_free(local_err);
5714         local_err = NULL;
5715     }
5716
5717 out:
5718     qemu_opts_del(opts);
5719     qemu_opts_free(create_opts);
5720     if (local_err) {
5721         error_propagate(errp, local_err);
5722     }
5723 }
5724
5725 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5726 {
5727     return bs->aio_context;
5728 }
5729
5730 void bdrv_detach_aio_context(BlockDriverState *bs)
5731 {
5732     if (!bs->drv) {
5733         return;
5734     }
5735
5736     if (bs->io_limits_enabled) {
5737         throttle_detach_aio_context(&bs->throttle_state);
5738     }
5739     if (bs->drv->bdrv_detach_aio_context) {
5740         bs->drv->bdrv_detach_aio_context(bs);
5741     }
5742     if (bs->file) {
5743         bdrv_detach_aio_context(bs->file);
5744     }
5745     if (bs->backing_hd) {
5746         bdrv_detach_aio_context(bs->backing_hd);
5747     }
5748
5749     bs->aio_context = NULL;
5750 }
5751
5752 void bdrv_attach_aio_context(BlockDriverState *bs,
5753                              AioContext *new_context)
5754 {
5755     if (!bs->drv) {
5756         return;
5757     }
5758
5759     bs->aio_context = new_context;
5760
5761     if (bs->backing_hd) {
5762         bdrv_attach_aio_context(bs->backing_hd, new_context);
5763     }
5764     if (bs->file) {
5765         bdrv_attach_aio_context(bs->file, new_context);
5766     }
5767     if (bs->drv->bdrv_attach_aio_context) {
5768         bs->drv->bdrv_attach_aio_context(bs, new_context);
5769     }
5770     if (bs->io_limits_enabled) {
5771         throttle_attach_aio_context(&bs->throttle_state, new_context);
5772     }
5773 }
5774
5775 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5776 {
5777     bdrv_drain_all(); /* ensure there are no in-flight requests */
5778
5779     bdrv_detach_aio_context(bs);
5780
5781     /* This function executes in the old AioContext so acquire the new one in
5782      * case it runs in a different thread.
5783      */
5784     aio_context_acquire(new_context);
5785     bdrv_attach_aio_context(bs, new_context);
5786     aio_context_release(new_context);
5787 }
5788
5789 void bdrv_add_before_write_notifier(BlockDriverState *bs,
5790                                     NotifierWithReturn *notifier)
5791 {
5792     notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5793 }
5794
5795 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
5796 {
5797     if (!bs->drv->bdrv_amend_options) {
5798         return -ENOTSUP;
5799     }
5800     return bs->drv->bdrv_amend_options(bs, opts);
5801 }
5802
5803 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5804  * of block filter and by bdrv_is_first_non_filter.
5805  * It is used to test if the given bs is the candidate or recurse more in the
5806  * node graph.
5807  */
5808 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5809                                       BlockDriverState *candidate)
5810 {
5811     /* return false if basic checks fails */
5812     if (!bs || !bs->drv) {
5813         return false;
5814     }
5815
5816     /* the code reached a non block filter driver -> check if the bs is
5817      * the same as the candidate. It's the recursion termination condition.
5818      */
5819     if (!bs->drv->is_filter) {
5820         return bs == candidate;
5821     }
5822     /* Down this path the driver is a block filter driver */
5823
5824     /* If the block filter recursion method is defined use it to recurse down
5825      * the node graph.
5826      */
5827     if (bs->drv->bdrv_recurse_is_first_non_filter) {
5828         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5829     }
5830
5831     /* the driver is a block filter but don't allow to recurse -> return false
5832      */
5833     return false;
5834 }
5835
5836 /* This function checks if the candidate is the first non filter bs down it's
5837  * bs chain. Since we don't have pointers to parents it explore all bs chains
5838  * from the top. Some filters can choose not to pass down the recursion.
5839  */
5840 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5841 {
5842     BlockDriverState *bs;
5843
5844     /* walk down the bs forest recursively */
5845     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5846         bool perm;
5847
5848         /* try to recurse in this top level bs */
5849         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5850
5851         /* candidate is the first non filter */
5852         if (perm) {
5853             return true;
5854         }
5855     }
5856
5857     return false;
5858 }
5859
5860 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
5861 {
5862     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5863     if (!to_replace_bs) {
5864         error_setg(errp, "Node name '%s' not found", node_name);
5865         return NULL;
5866     }
5867
5868     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5869         return NULL;
5870     }
5871
5872     /* We don't want arbitrary node of the BDS chain to be replaced only the top
5873      * most non filter in order to prevent data corruption.
5874      * Another benefit is that this tests exclude backing files which are
5875      * blocked by the backing blockers.
5876      */
5877     if (!bdrv_is_first_non_filter(to_replace_bs)) {
5878         error_setg(errp, "Only top most non filter can be replaced");
5879         return NULL;
5880     }
5881
5882     return to_replace_bs;
5883 }
5884
5885 void bdrv_io_plug(BlockDriverState *bs)
5886 {
5887     BlockDriver *drv = bs->drv;
5888     if (drv && drv->bdrv_io_plug) {
5889         drv->bdrv_io_plug(bs);
5890     } else if (bs->file) {
5891         bdrv_io_plug(bs->file);
5892     }
5893 }
5894
5895 void bdrv_io_unplug(BlockDriverState *bs)
5896 {
5897     BlockDriver *drv = bs->drv;
5898     if (drv && drv->bdrv_io_unplug) {
5899         drv->bdrv_io_unplug(bs);
5900     } else if (bs->file) {
5901         bdrv_io_unplug(bs->file);
5902     }
5903 }
5904
5905 void bdrv_flush_io_queue(BlockDriverState *bs)
5906 {
5907     BlockDriver *drv = bs->drv;
5908     if (drv && drv->bdrv_flush_io_queue) {
5909         drv->bdrv_flush_io_queue(bs);
5910     } else if (bs->file) {
5911         bdrv_flush_io_queue(bs->file);
5912     }
5913 }
5914
5915 static bool append_open_options(QDict *d, BlockDriverState *bs)
5916 {
5917     const QDictEntry *entry;
5918     bool found_any = false;
5919
5920     for (entry = qdict_first(bs->options); entry;
5921          entry = qdict_next(bs->options, entry))
5922     {
5923         /* Only take options for this level and exclude all non-driver-specific
5924          * options */
5925         if (!strchr(qdict_entry_key(entry), '.') &&
5926             strcmp(qdict_entry_key(entry), "node-name"))
5927         {
5928             qobject_incref(qdict_entry_value(entry));
5929             qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
5930             found_any = true;
5931         }
5932     }
5933
5934     return found_any;
5935 }
5936
5937 /* Updates the following BDS fields:
5938  *  - exact_filename: A filename which may be used for opening a block device
5939  *                    which (mostly) equals the given BDS (even without any
5940  *                    other options; so reading and writing must return the same
5941  *                    results, but caching etc. may be different)
5942  *  - full_open_options: Options which, when given when opening a block device
5943  *                       (without a filename), result in a BDS (mostly)
5944  *                       equalling the given one
5945  *  - filename: If exact_filename is set, it is copied here. Otherwise,
5946  *              full_open_options is converted to a JSON object, prefixed with
5947  *              "json:" (for use through the JSON pseudo protocol) and put here.
5948  */
5949 void bdrv_refresh_filename(BlockDriverState *bs)
5950 {
5951     BlockDriver *drv = bs->drv;
5952     QDict *opts;
5953
5954     if (!drv) {
5955         return;
5956     }
5957
5958     /* This BDS's file name will most probably depend on its file's name, so
5959      * refresh that first */
5960     if (bs->file) {
5961         bdrv_refresh_filename(bs->file);
5962     }
5963
5964     if (drv->bdrv_refresh_filename) {
5965         /* Obsolete information is of no use here, so drop the old file name
5966          * information before refreshing it */
5967         bs->exact_filename[0] = '\0';
5968         if (bs->full_open_options) {
5969             QDECREF(bs->full_open_options);
5970             bs->full_open_options = NULL;
5971         }
5972
5973         drv->bdrv_refresh_filename(bs);
5974     } else if (bs->file) {
5975         /* Try to reconstruct valid information from the underlying file */
5976         bool has_open_options;
5977
5978         bs->exact_filename[0] = '\0';
5979         if (bs->full_open_options) {
5980             QDECREF(bs->full_open_options);
5981             bs->full_open_options = NULL;
5982         }
5983
5984         opts = qdict_new();
5985         has_open_options = append_open_options(opts, bs);
5986
5987         /* If no specific options have been given for this BDS, the filename of
5988          * the underlying file should suffice for this one as well */
5989         if (bs->file->exact_filename[0] && !has_open_options) {
5990             strcpy(bs->exact_filename, bs->file->exact_filename);
5991         }
5992         /* Reconstructing the full options QDict is simple for most format block
5993          * drivers, as long as the full options are known for the underlying
5994          * file BDS. The full options QDict of that file BDS should somehow
5995          * contain a representation of the filename, therefore the following
5996          * suffices without querying the (exact_)filename of this BDS. */
5997         if (bs->file->full_open_options) {
5998             qdict_put_obj(opts, "driver",
5999                           QOBJECT(qstring_from_str(drv->format_name)));
6000             QINCREF(bs->file->full_open_options);
6001             qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
6002
6003             bs->full_open_options = opts;
6004         } else {
6005             QDECREF(opts);
6006         }
6007     } else if (!bs->full_open_options && qdict_size(bs->options)) {
6008         /* There is no underlying file BDS (at least referenced by BDS.file),
6009          * so the full options QDict should be equal to the options given
6010          * specifically for this block device when it was opened (plus the
6011          * driver specification).
6012          * Because those options don't change, there is no need to update
6013          * full_open_options when it's already set. */
6014
6015         opts = qdict_new();
6016         append_open_options(opts, bs);
6017         qdict_put_obj(opts, "driver",
6018                       QOBJECT(qstring_from_str(drv->format_name)));
6019
6020         if (bs->exact_filename[0]) {
6021             /* This may not work for all block protocol drivers (some may
6022              * require this filename to be parsed), but we have to find some
6023              * default solution here, so just include it. If some block driver
6024              * does not support pure options without any filename at all or
6025              * needs some special format of the options QDict, it needs to
6026              * implement the driver-specific bdrv_refresh_filename() function.
6027              */
6028             qdict_put_obj(opts, "filename",
6029                           QOBJECT(qstring_from_str(bs->exact_filename)));
6030         }
6031
6032         bs->full_open_options = opts;
6033     }
6034
6035     if (bs->exact_filename[0]) {
6036         pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
6037     } else if (bs->full_open_options) {
6038         QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
6039         snprintf(bs->filename, sizeof(bs->filename), "json:%s",
6040                  qstring_get_str(json));
6041         QDECREF(json);
6042     }
6043 }
This page took 0.361678 seconds and 4 git commands to generate.