blob: 7cccb84dab96e2eca562cc1ad1f06ba878db60e8 [file] [log] [blame]
bellardfc01f7e2003-06-30 10:03:06 +00001/*
2 * QEMU System Emulator block driver
ths5fafdf22007-09-16 21:08:06 +00003 *
bellardfc01f7e2003-06-30 10:03:06 +00004 * Copyright (c) 2003 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellardfc01f7e2003-06-30 10:03:06 +00006 * 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 */
blueswir13990d092008-12-05 17:53:21 +000024#include "config-host.h"
pbrookfaf07962007-11-11 02:51:17 +000025#include "qemu-common.h"
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +010026#include "trace.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010027#include "monitor/monitor.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010028#include "block/block_int.h"
29#include "block/blockjob.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010030#include "qemu/module.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010031#include "qapi/qmp/qjson.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010032#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010033#include "qemu/notify.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010034#include "block/coroutine.h"
Benoît Canetc13163f2014-01-23 21:31:34 +010035#include "block/qapi.h"
Luiz Capitulinob2023812011-09-21 17:16:47 -030036#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010037#include "qemu/timer.h"
bellardfc01f7e2003-06-30 10:03:06 +000038
Juan Quintela71e72a12009-07-27 16:12:56 +020039#ifdef CONFIG_BSD
bellard7674e7b2005-04-26 21:59:26 +000040#include <sys/types.h>
41#include <sys/stat.h>
42#include <sys/ioctl.h>
Blue Swirl72cf2d42009-09-12 07:36:22 +000043#include <sys/queue.h>
blueswir1c5e97232009-03-07 20:06:23 +000044#ifndef __DragonFly__
bellard7674e7b2005-04-26 21:59:26 +000045#include <sys/disk.h>
46#endif
blueswir1c5e97232009-03-07 20:06:23 +000047#endif
bellard7674e7b2005-04-26 21:59:26 +000048
aliguori49dc7682009-03-08 16:26:59 +000049#ifdef _WIN32
50#include <windows.h>
51#endif
52
Fam Zhenge4654d22013-11-13 18:29:43 +080053struct BdrvDirtyBitmap {
54 HBitmap *bitmap;
55 QLIST_ENTRY(BdrvDirtyBitmap) list;
56};
57
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +010058#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
59
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +020060static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
aliguorif141eaf2009-04-07 18:43:24 +000061static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
62 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
aliguoric87c0672009-04-07 18:43:20 +000063 BlockDriverCompletionFunc *cb, void *opaque);
aliguorif141eaf2009-04-07 18:43:24 +000064static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
65 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +000066 BlockDriverCompletionFunc *cb, void *opaque);
Kevin Wolff9f05dc2011-07-15 13:50:26 +020067static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
68 int64_t sector_num, int nb_sectors,
69 QEMUIOVector *iov);
70static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
71 int64_t sector_num, int nb_sectors,
72 QEMUIOVector *iov);
Kevin Wolf775aa8b2013-12-05 12:09:38 +010073static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
74 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Stefan Hajnoczi470c0502012-01-18 14:40:42 +000075 BdrvRequestFlags flags);
Kevin Wolf775aa8b2013-12-05 12:09:38 +010076static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
77 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +000078 BdrvRequestFlags flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010079static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
80 int64_t sector_num,
81 QEMUIOVector *qiov,
82 int nb_sectors,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +010083 BdrvRequestFlags flags,
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010084 BlockDriverCompletionFunc *cb,
85 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +010086 bool is_write);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +010087static void coroutine_fn bdrv_co_do_rw(void *opaque);
Kevin Wolf621f0582012-03-20 15:12:58 +010088static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +020089 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
bellardec530c82006-04-25 22:36:06 +000090
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +010091static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
92 QTAILQ_HEAD_INITIALIZER(bdrv_states);
blueswir17ee930d2008-09-17 19:04:14 +000093
Benoît Canetdc364f42014-01-23 21:31:32 +010094static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
96
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +010097static QLIST_HEAD(, BlockDriver) bdrv_drivers =
98 QLIST_HEAD_INITIALIZER(bdrv_drivers);
bellardea2384d2004-08-01 21:59:26 +000099
Markus Armbrustereb852012009-10-27 18:41:44 +0100100/* If non-zero, use only whitelisted block drivers */
101static int use_bdrv_whitelist;
102
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000103#ifdef _WIN32
104static int is_windows_drive_prefix(const char *filename)
105{
106 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
107 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
108 filename[1] == ':');
109}
110
111int is_windows_drive(const char *filename)
112{
113 if (is_windows_drive_prefix(filename) &&
114 filename[2] == '\0')
115 return 1;
116 if (strstart(filename, "\\\\.\\", NULL) ||
117 strstart(filename, "//./", NULL))
118 return 1;
119 return 0;
120}
121#endif
122
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800123/* throttling disk I/O limits */
Benoît Canetcc0681c2013-09-02 14:14:39 +0200124void bdrv_set_io_limits(BlockDriverState *bs,
125 ThrottleConfig *cfg)
126{
127 int i;
128
129 throttle_config(&bs->throttle_state, cfg);
130
131 for (i = 0; i < 2; i++) {
132 qemu_co_enter_next(&bs->throttled_reqs[i]);
133 }
134}
135
136/* this function drain all the throttled IOs */
137static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
138{
139 bool drained = false;
140 bool enabled = bs->io_limits_enabled;
141 int i;
142
143 bs->io_limits_enabled = false;
144
145 for (i = 0; i < 2; i++) {
146 while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
147 drained = true;
148 }
149 }
150
151 bs->io_limits_enabled = enabled;
152
153 return drained;
154}
155
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800156void bdrv_io_limits_disable(BlockDriverState *bs)
157{
158 bs->io_limits_enabled = false;
159
Benoît Canetcc0681c2013-09-02 14:14:39 +0200160 bdrv_start_throttled_reqs(bs);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800161
Benoît Canetcc0681c2013-09-02 14:14:39 +0200162 throttle_destroy(&bs->throttle_state);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800163}
164
Benoît Canetcc0681c2013-09-02 14:14:39 +0200165static void bdrv_throttle_read_timer_cb(void *opaque)
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800166{
167 BlockDriverState *bs = opaque;
Benoît Canetcc0681c2013-09-02 14:14:39 +0200168 qemu_co_enter_next(&bs->throttled_reqs[0]);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800169}
170
Benoît Canetcc0681c2013-09-02 14:14:39 +0200171static void bdrv_throttle_write_timer_cb(void *opaque)
172{
173 BlockDriverState *bs = opaque;
174 qemu_co_enter_next(&bs->throttled_reqs[1]);
175}
176
177/* should be called before bdrv_set_io_limits if a limit is set */
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800178void bdrv_io_limits_enable(BlockDriverState *bs)
179{
Benoît Canetcc0681c2013-09-02 14:14:39 +0200180 assert(!bs->io_limits_enabled);
181 throttle_init(&bs->throttle_state,
182 QEMU_CLOCK_VIRTUAL,
183 bdrv_throttle_read_timer_cb,
184 bdrv_throttle_write_timer_cb,
185 bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800186 bs->io_limits_enabled = true;
187}
188
Benoît Canetcc0681c2013-09-02 14:14:39 +0200189/* This function makes an IO wait if needed
190 *
191 * @nb_sectors: the number of sectors of the IO
192 * @is_write: is the IO a write
193 */
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800194static void bdrv_io_limits_intercept(BlockDriverState *bs,
Kevin Wolfd5103582014-01-16 13:29:10 +0100195 unsigned int bytes,
Benoît Canetcc0681c2013-09-02 14:14:39 +0200196 bool is_write)
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800197{
Benoît Canetcc0681c2013-09-02 14:14:39 +0200198 /* does this io must wait */
199 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800200
Benoît Canetcc0681c2013-09-02 14:14:39 +0200201 /* if must wait or any request of this type throttled queue the IO */
202 if (must_wait ||
203 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
204 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800205 }
206
Benoît Canetcc0681c2013-09-02 14:14:39 +0200207 /* the IO will be executed, do the accounting */
Kevin Wolfd5103582014-01-16 13:29:10 +0100208 throttle_account(&bs->throttle_state, is_write, bytes);
209
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800210
Benoît Canetcc0681c2013-09-02 14:14:39 +0200211 /* if the next request must wait -> do nothing */
212 if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
213 return;
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800214 }
215
Benoît Canetcc0681c2013-09-02 14:14:39 +0200216 /* else queue next request for execution */
217 qemu_co_queue_next(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800218}
219
Kevin Wolf339064d2013-11-28 10:23:32 +0100220size_t bdrv_opt_mem_align(BlockDriverState *bs)
221{
222 if (!bs || !bs->drv) {
223 /* 4k should be on the safe side */
224 return 4096;
225 }
226
227 return bs->bl.opt_mem_alignment;
228}
229
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000230/* check if the path starts with "<protocol>:" */
231static int path_has_protocol(const char *path)
232{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200233 const char *p;
234
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000235#ifdef _WIN32
236 if (is_windows_drive(path) ||
237 is_windows_drive_prefix(path)) {
238 return 0;
239 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200240 p = path + strcspn(path, ":/\\");
241#else
242 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000243#endif
244
Paolo Bonzini947995c2012-05-08 16:51:48 +0200245 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000246}
247
bellard83f64092006-08-01 16:21:11 +0000248int path_is_absolute(const char *path)
249{
bellard21664422007-01-07 18:22:37 +0000250#ifdef _WIN32
251 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200252 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000253 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200254 }
255 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000256#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200257 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000258#endif
bellard83f64092006-08-01 16:21:11 +0000259}
260
261/* if filename is absolute, just copy it to dest. Otherwise, build a
262 path to it by considering it is relative to base_path. URL are
263 supported. */
264void path_combine(char *dest, int dest_size,
265 const char *base_path,
266 const char *filename)
267{
268 const char *p, *p1;
269 int len;
270
271 if (dest_size <= 0)
272 return;
273 if (path_is_absolute(filename)) {
274 pstrcpy(dest, dest_size, filename);
275 } else {
276 p = strchr(base_path, ':');
277 if (p)
278 p++;
279 else
280 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000281 p1 = strrchr(base_path, '/');
282#ifdef _WIN32
283 {
284 const char *p2;
285 p2 = strrchr(base_path, '\\');
286 if (!p1 || p2 > p1)
287 p1 = p2;
288 }
289#endif
bellard83f64092006-08-01 16:21:11 +0000290 if (p1)
291 p1++;
292 else
293 p1 = base_path;
294 if (p1 > p)
295 p = p1;
296 len = p - base_path;
297 if (len > dest_size - 1)
298 len = dest_size - 1;
299 memcpy(dest, base_path, len);
300 dest[len] = '\0';
301 pstrcat(dest, dest_size, filename);
302 }
303}
304
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200305void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
306{
307 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
308 pstrcpy(dest, sz, bs->backing_file);
309 } else {
310 path_combine(dest, sz, bs->filename, bs->backing_file);
311 }
312}
313
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500314void bdrv_register(BlockDriver *bdrv)
bellardea2384d2004-08-01 21:59:26 +0000315{
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +0100316 /* Block drivers without coroutine functions need emulation */
317 if (!bdrv->bdrv_co_readv) {
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200318 bdrv->bdrv_co_readv = bdrv_co_readv_em;
319 bdrv->bdrv_co_writev = bdrv_co_writev_em;
320
Stefan Hajnoczif8c35c12011-10-13 21:09:31 +0100321 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
322 * the block driver lacks aio we need to emulate that too.
323 */
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200324 if (!bdrv->bdrv_aio_readv) {
325 /* add AIO emulation layer */
326 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
327 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200328 }
bellard83f64092006-08-01 16:21:11 +0000329 }
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200330
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100331 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000332}
bellardb3380822004-03-14 21:38:54 +0000333
334/* create a new block device (by default it is empty) */
Kevin Wolf98522f62014-04-17 13:16:01 +0200335BlockDriverState *bdrv_new(const char *device_name, Error **errp)
bellardfc01f7e2003-06-30 10:03:06 +0000336{
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100337 BlockDriverState *bs;
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800338 int i;
bellardb3380822004-03-14 21:38:54 +0000339
Kevin Wolff2d953e2014-04-17 13:27:05 +0200340 if (bdrv_find(device_name)) {
341 error_setg(errp, "Device with id '%s' already exists",
342 device_name);
343 return NULL;
344 }
345 if (bdrv_find_node(device_name)) {
346 error_setg(errp, "Device with node-name '%s' already exists",
347 device_name);
348 return NULL;
349 }
350
Anthony Liguori7267c092011-08-20 22:09:37 -0500351 bs = g_malloc0(sizeof(BlockDriverState));
Fam Zhenge4654d22013-11-13 18:29:43 +0800352 QLIST_INIT(&bs->dirty_bitmaps);
bellardb3380822004-03-14 21:38:54 +0000353 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellardea2384d2004-08-01 21:59:26 +0000354 if (device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +0100355 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
bellardea2384d2004-08-01 21:59:26 +0000356 }
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800357 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
358 QLIST_INIT(&bs->op_blockers[i]);
359 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300360 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200361 notifier_list_init(&bs->close_notifiers);
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200362 notifier_with_return_list_init(&bs->before_write_notifiers);
Benoît Canetcc0681c2013-09-02 14:14:39 +0200363 qemu_co_queue_init(&bs->throttled_reqs[0]);
364 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800365 bs->refcnt = 1;
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200366
bellardb3380822004-03-14 21:38:54 +0000367 return bs;
368}
369
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200370void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
371{
372 notifier_list_add(&bs->close_notifiers, notify);
373}
374
bellardea2384d2004-08-01 21:59:26 +0000375BlockDriver *bdrv_find_format(const char *format_name)
376{
377 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100378 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
379 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000380 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100381 }
bellardea2384d2004-08-01 21:59:26 +0000382 }
383 return NULL;
384}
385
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800386static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100387{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800388 static const char *whitelist_rw[] = {
389 CONFIG_BDRV_RW_WHITELIST
390 };
391 static const char *whitelist_ro[] = {
392 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100393 };
394 const char **p;
395
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800396 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100397 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800398 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100399
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800400 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100401 if (!strcmp(drv->format_name, *p)) {
402 return 1;
403 }
404 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800405 if (read_only) {
406 for (p = whitelist_ro; *p; p++) {
407 if (!strcmp(drv->format_name, *p)) {
408 return 1;
409 }
410 }
411 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100412 return 0;
413}
414
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800415BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
416 bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100417{
418 BlockDriver *drv = bdrv_find_format(format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800419 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
Markus Armbrustereb852012009-10-27 18:41:44 +0100420}
421
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800422typedef struct CreateCo {
423 BlockDriver *drv;
424 char *filename;
425 QEMUOptionParameter *options;
426 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200427 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800428} CreateCo;
429
430static void coroutine_fn bdrv_create_co_entry(void *opaque)
431{
Max Reitzcc84d902013-09-06 17:14:26 +0200432 Error *local_err = NULL;
433 int ret;
434
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800435 CreateCo *cco = opaque;
436 assert(cco->drv);
437
Max Reitzcc84d902013-09-06 17:14:26 +0200438 ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100439 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200440 error_propagate(&cco->err, local_err);
441 }
442 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800443}
444
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200445int bdrv_create(BlockDriver *drv, const char* filename,
Max Reitzcc84d902013-09-06 17:14:26 +0200446 QEMUOptionParameter *options, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000447{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800448 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200449
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800450 Coroutine *co;
451 CreateCo cco = {
452 .drv = drv,
453 .filename = g_strdup(filename),
454 .options = options,
455 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200456 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800457 };
458
459 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200460 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300461 ret = -ENOTSUP;
462 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800463 }
464
465 if (qemu_in_coroutine()) {
466 /* Fast-path if already in coroutine context */
467 bdrv_create_co_entry(&cco);
468 } else {
469 co = qemu_coroutine_create(bdrv_create_co_entry);
470 qemu_coroutine_enter(co, &cco);
471 while (cco.ret == NOT_DONE) {
472 qemu_aio_wait();
473 }
474 }
475
476 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200477 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100478 if (cco.err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200479 error_propagate(errp, cco.err);
480 } else {
481 error_setg_errno(errp, -ret, "Could not create image");
482 }
483 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800484
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300485out:
486 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800487 return ret;
bellardea2384d2004-08-01 21:59:26 +0000488}
489
Max Reitzcc84d902013-09-06 17:14:26 +0200490int bdrv_create_file(const char* filename, QEMUOptionParameter *options,
491 Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200492{
493 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200494 Error *local_err = NULL;
495 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200496
Kevin Wolf98289622013-07-10 15:47:39 +0200497 drv = bdrv_find_protocol(filename, true);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200498 if (drv == NULL) {
Max Reitzcc84d902013-09-06 17:14:26 +0200499 error_setg(errp, "Could not find protocol for file '%s'", filename);
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000500 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200501 }
502
Max Reitzcc84d902013-09-06 17:14:26 +0200503 ret = bdrv_create(drv, filename, options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100504 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200505 error_propagate(errp, local_err);
506 }
507 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200508}
509
Kevin Wolf355ef4a2013-12-11 20:14:09 +0100510int bdrv_refresh_limits(BlockDriverState *bs)
Kevin Wolfd34682c2013-12-11 19:26:16 +0100511{
512 BlockDriver *drv = bs->drv;
513
514 memset(&bs->bl, 0, sizeof(bs->bl));
515
Kevin Wolf466ad822013-12-11 19:50:32 +0100516 if (!drv) {
517 return 0;
518 }
519
520 /* Take some limits from the children as a default */
521 if (bs->file) {
522 bdrv_refresh_limits(bs->file);
523 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
Kevin Wolf339064d2013-11-28 10:23:32 +0100524 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
525 } else {
526 bs->bl.opt_mem_alignment = 512;
Kevin Wolf466ad822013-12-11 19:50:32 +0100527 }
528
529 if (bs->backing_hd) {
530 bdrv_refresh_limits(bs->backing_hd);
531 bs->bl.opt_transfer_length =
532 MAX(bs->bl.opt_transfer_length,
533 bs->backing_hd->bl.opt_transfer_length);
Kevin Wolf339064d2013-11-28 10:23:32 +0100534 bs->bl.opt_mem_alignment =
535 MAX(bs->bl.opt_mem_alignment,
536 bs->backing_hd->bl.opt_mem_alignment);
Kevin Wolf466ad822013-12-11 19:50:32 +0100537 }
538
539 /* Then let the driver override it */
540 if (drv->bdrv_refresh_limits) {
Kevin Wolfd34682c2013-12-11 19:26:16 +0100541 return drv->bdrv_refresh_limits(bs);
542 }
543
544 return 0;
545}
546
Jim Meyeringeba25052012-05-28 09:27:54 +0200547/*
548 * Create a uniquely-named empty temporary file.
549 * Return 0 upon success, otherwise a negative errno value.
550 */
551int get_tmp_filename(char *filename, int size)
552{
bellardd5249392004-08-03 21:14:23 +0000553#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000554 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200555 /* GetTempFileName requires that its output buffer (4th param)
556 have length MAX_PATH or greater. */
557 assert(size >= MAX_PATH);
558 return (GetTempPath(MAX_PATH, temp_dir)
559 && GetTempFileName(temp_dir, "qem", 0, filename)
560 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000561#else
bellardea2384d2004-08-01 21:59:26 +0000562 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000563 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000564 tmpdir = getenv("TMPDIR");
Amit Shah69bef792014-02-26 15:12:37 +0530565 if (!tmpdir) {
566 tmpdir = "/var/tmp";
567 }
Jim Meyeringeba25052012-05-28 09:27:54 +0200568 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
569 return -EOVERFLOW;
570 }
bellardea2384d2004-08-01 21:59:26 +0000571 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800572 if (fd < 0) {
573 return -errno;
574 }
575 if (close(fd) != 0) {
576 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200577 return -errno;
578 }
579 return 0;
bellardd5249392004-08-03 21:14:23 +0000580#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200581}
bellardea2384d2004-08-01 21:59:26 +0000582
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200583/*
584 * Detect host devices. By convention, /dev/cdrom[N] is always
585 * recognized as a host CDROM.
586 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200587static BlockDriver *find_hdev_driver(const char *filename)
588{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200589 int score_max = 0, score;
590 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200591
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100592 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200593 if (d->bdrv_probe_device) {
594 score = d->bdrv_probe_device(filename);
595 if (score > score_max) {
596 score_max = score;
597 drv = d;
598 }
599 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200600 }
601
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200602 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200603}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200604
Kevin Wolf98289622013-07-10 15:47:39 +0200605BlockDriver *bdrv_find_protocol(const char *filename,
606 bool allow_protocol_prefix)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200607{
608 BlockDriver *drv1;
609 char protocol[128];
610 int len;
611 const char *p;
612
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200613 /* TODO Drivers without bdrv_file_open must be specified explicitly */
614
Christoph Hellwig39508e72010-06-23 12:25:17 +0200615 /*
616 * XXX(hch): we really should not let host device detection
617 * override an explicit protocol specification, but moving this
618 * later breaks access to device names with colons in them.
619 * Thanks to the brain-dead persistent naming schemes on udev-
620 * based Linux systems those actually are quite common.
621 */
622 drv1 = find_hdev_driver(filename);
623 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200624 return drv1;
625 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200626
Kevin Wolf98289622013-07-10 15:47:39 +0200627 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Christoph Hellwig39508e72010-06-23 12:25:17 +0200628 return bdrv_find_format("file");
629 }
Kevin Wolf98289622013-07-10 15:47:39 +0200630
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000631 p = strchr(filename, ':');
632 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200633 len = p - filename;
634 if (len > sizeof(protocol) - 1)
635 len = sizeof(protocol) - 1;
636 memcpy(protocol, filename, len);
637 protocol[len] = '\0';
638 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
639 if (drv1->protocol_name &&
640 !strcmp(drv1->protocol_name, protocol)) {
641 return drv1;
642 }
643 }
644 return NULL;
645}
646
Kevin Wolff500a6d2012-11-12 17:35:27 +0100647static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200648 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000649{
Kevin Wolff500a6d2012-11-12 17:35:27 +0100650 int score, score_max;
bellardea2384d2004-08-01 21:59:26 +0000651 BlockDriver *drv1, *drv;
bellard83f64092006-08-01 16:21:11 +0000652 uint8_t buf[2048];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100653 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700654
Kevin Wolf08a00552010-06-01 18:37:31 +0200655 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Paolo Bonzini8e895592013-01-10 15:39:27 +0100656 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200657 drv = bdrv_find_format("raw");
658 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200659 error_setg(errp, "Could not find raw image format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200660 ret = -ENOENT;
661 }
662 *pdrv = drv;
663 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700664 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700665
bellard83f64092006-08-01 16:21:11 +0000666 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000667 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200668 error_setg_errno(errp, -ret, "Could not read image for determining its "
669 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200670 *pdrv = NULL;
671 return ret;
bellard83f64092006-08-01 16:21:11 +0000672 }
673
bellardea2384d2004-08-01 21:59:26 +0000674 score_max = 0;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200675 drv = NULL;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100676 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
bellard83f64092006-08-01 16:21:11 +0000677 if (drv1->bdrv_probe) {
678 score = drv1->bdrv_probe(buf, ret, filename);
679 if (score > score_max) {
680 score_max = score;
681 drv = drv1;
682 }
bellardea2384d2004-08-01 21:59:26 +0000683 }
684 }
Stefan Weilc98ac352010-07-21 21:51:51 +0200685 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200686 error_setg(errp, "Could not determine image format: No compatible "
687 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200688 ret = -ENOENT;
689 }
690 *pdrv = drv;
691 return ret;
bellardea2384d2004-08-01 21:59:26 +0000692}
693
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100694/**
695 * Set the current 'total_sectors' value
696 */
697static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
698{
699 BlockDriver *drv = bs->drv;
700
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700701 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
702 if (bs->sg)
703 return 0;
704
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100705 /* query actual device if possible, otherwise just trust the hint */
706 if (drv->bdrv_getlength) {
707 int64_t length = drv->bdrv_getlength(bs);
708 if (length < 0) {
709 return length;
710 }
Fam Zheng7e382002013-11-06 19:48:06 +0800711 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100712 }
713
714 bs->total_sectors = hint;
715 return 0;
716}
717
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100718/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100719 * Set open flags for a given discard mode
720 *
721 * Return 0 on success, -1 if the discard mode was invalid.
722 */
723int bdrv_parse_discard_flags(const char *mode, int *flags)
724{
725 *flags &= ~BDRV_O_UNMAP;
726
727 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
728 /* do nothing */
729 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
730 *flags |= BDRV_O_UNMAP;
731 } else {
732 return -1;
733 }
734
735 return 0;
736}
737
738/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100739 * Set open flags for a given cache mode
740 *
741 * Return 0 on success, -1 if the cache mode was invalid.
742 */
743int bdrv_parse_cache_flags(const char *mode, int *flags)
744{
745 *flags &= ~BDRV_O_CACHE_MASK;
746
747 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
748 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100749 } else if (!strcmp(mode, "directsync")) {
750 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100751 } else if (!strcmp(mode, "writeback")) {
752 *flags |= BDRV_O_CACHE_WB;
753 } else if (!strcmp(mode, "unsafe")) {
754 *flags |= BDRV_O_CACHE_WB;
755 *flags |= BDRV_O_NO_FLUSH;
756 } else if (!strcmp(mode, "writethrough")) {
757 /* this is the default */
758 } else {
759 return -1;
760 }
761
762 return 0;
763}
764
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000765/**
766 * The copy-on-read flag is actually a reference count so multiple users may
767 * use the feature without worrying about clobbering its previous state.
768 * Copy-on-read stays enabled until all users have called to disable it.
769 */
770void bdrv_enable_copy_on_read(BlockDriverState *bs)
771{
772 bs->copy_on_read++;
773}
774
775void bdrv_disable_copy_on_read(BlockDriverState *bs)
776{
777 assert(bs->copy_on_read > 0);
778 bs->copy_on_read--;
779}
780
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200781/*
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200782 * Returns the flags that a temporary snapshot should get, based on the
783 * originally requested flags (the originally requested image will have flags
784 * like a backing file)
785 */
786static int bdrv_temp_snapshot_flags(int flags)
787{
788 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
789}
790
791/*
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200792 * Returns the flags that bs->file should get, based on the given flags for
793 * the parent BDS
794 */
795static int bdrv_inherited_flags(int flags)
796{
797 /* Enable protocol handling, disable format probing for bs->file */
798 flags |= BDRV_O_PROTOCOL;
799
800 /* Our block drivers take care to send flushes and respect unmap policy,
801 * so we can enable both unconditionally on lower layers. */
802 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
803
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200804 /* Clear flags that only apply to the top layer */
Kevin Wolf5669b442014-04-11 21:36:45 +0200805 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200806
807 return flags;
808}
809
Kevin Wolf317fc442014-04-25 13:27:34 +0200810/*
811 * Returns the flags that bs->backing_hd should get, based on the given flags
812 * for the parent BDS
813 */
814static int bdrv_backing_flags(int flags)
815{
816 /* backing files always opened read-only */
817 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
818
819 /* snapshot=on is handled on the top layer */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200820 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
Kevin Wolf317fc442014-04-25 13:27:34 +0200821
822 return flags;
823}
824
Kevin Wolf7b272452012-11-12 17:05:39 +0100825static int bdrv_open_flags(BlockDriverState *bs, int flags)
826{
827 int open_flags = flags | BDRV_O_CACHE_WB;
828
829 /*
830 * Clear flags that are internal to the block layer before opening the
831 * image.
832 */
833 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
834
835 /*
836 * Snapshots should be writable.
837 */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200838 if (flags & BDRV_O_TEMPORARY) {
Kevin Wolf7b272452012-11-12 17:05:39 +0100839 open_flags |= BDRV_O_RDWR;
840 }
841
842 return open_flags;
843}
844
Kevin Wolf636ea372014-01-24 14:11:52 +0100845static void bdrv_assign_node_name(BlockDriverState *bs,
846 const char *node_name,
847 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +0100848{
849 if (!node_name) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100850 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100851 }
852
853 /* empty string node name is invalid */
854 if (node_name[0] == '\0') {
855 error_setg(errp, "Empty node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100856 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100857 }
858
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100859 /* takes care of avoiding namespaces collisions */
860 if (bdrv_find(node_name)) {
861 error_setg(errp, "node-name=%s is conflicting with a device id",
862 node_name);
Kevin Wolf636ea372014-01-24 14:11:52 +0100863 return;
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100864 }
865
Benoît Canet6913c0c2014-01-23 21:31:33 +0100866 /* takes care of avoiding duplicates node names */
867 if (bdrv_find_node(node_name)) {
868 error_setg(errp, "Duplicate node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100869 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100870 }
871
872 /* copy node name into the bs and insert it into the graph list */
873 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
874 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Benoît Canet6913c0c2014-01-23 21:31:33 +0100875}
876
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200877/*
Kevin Wolf57915332010-04-14 15:24:50 +0200878 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100879 *
880 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200881 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100882static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200883 QDict *options, int flags, BlockDriver *drv, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200884{
885 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200886 const char *filename;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100887 const char *node_name = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200888 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200889
890 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200891 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100892 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200893
Kevin Wolf45673672013-04-22 17:48:40 +0200894 if (file != NULL) {
895 filename = file->filename;
896 } else {
897 filename = qdict_get_try_str(options, "filename");
898 }
899
Kevin Wolf765003d2014-02-03 14:49:42 +0100900 if (drv->bdrv_needs_filename && !filename) {
901 error_setg(errp, "The '%s' block driver requires a file name",
902 drv->format_name);
903 return -EINVAL;
904 }
905
Kevin Wolf45673672013-04-22 17:48:40 +0200906 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100907
Benoît Canet6913c0c2014-01-23 21:31:33 +0100908 node_name = qdict_get_try_str(options, "node-name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100909 bdrv_assign_node_name(bs, node_name, &local_err);
Markus Armbruster0fb63952014-04-25 16:50:31 +0200910 if (local_err) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100911 error_propagate(errp, local_err);
912 return -EINVAL;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100913 }
914 qdict_del(options, "node-name");
915
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100916 /* bdrv_open() with directly using a protocol as drv. This layer is already
917 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
918 * and return immediately. */
919 if (file != NULL && drv->bdrv_file_open) {
920 bdrv_swap(file, bs);
921 return 0;
922 }
923
Kevin Wolf57915332010-04-14 15:24:50 +0200924 bs->open_flags = flags;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +0100925 bs->guest_block_size = 512;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100926 bs->request_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800927 bs->zero_beyond_eof = true;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800928 open_flags = bdrv_open_flags(bs, flags);
929 bs->read_only = !(open_flags & BDRV_O_RDWR);
930
931 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200932 error_setg(errp,
933 !bs->read_only && bdrv_is_whitelisted(drv, true)
934 ? "Driver '%s' can only be used for read-only devices"
935 : "Driver '%s' is not whitelisted",
936 drv->format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800937 return -ENOTSUP;
938 }
Kevin Wolf57915332010-04-14 15:24:50 +0200939
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000940 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200941 if (flags & BDRV_O_COPY_ON_READ) {
942 if (!bs->read_only) {
943 bdrv_enable_copy_on_read(bs);
944 } else {
945 error_setg(errp, "Can't use copy-on-read on read-only device");
946 return -EINVAL;
947 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000948 }
949
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100950 if (filename != NULL) {
951 pstrcpy(bs->filename, sizeof(bs->filename), filename);
952 } else {
953 bs->filename[0] = '\0';
954 }
Kevin Wolf57915332010-04-14 15:24:50 +0200955
Kevin Wolf57915332010-04-14 15:24:50 +0200956 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500957 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200958
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100959 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100960
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200961 /* Open the image, either directly or using a protocol */
962 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100963 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +0200964 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200965 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100966 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200967 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200968 error_setg(errp, "Can't use '%s' as a block driver for the "
969 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200970 ret = -EINVAL;
971 goto free_and_fail;
972 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100973 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200974 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200975 }
976
Kevin Wolf57915332010-04-14 15:24:50 +0200977 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100978 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200979 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800980 } else if (bs->filename[0]) {
981 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200982 } else {
983 error_setg_errno(errp, -ret, "Could not open image");
984 }
Kevin Wolf57915332010-04-14 15:24:50 +0200985 goto free_and_fail;
986 }
987
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100988 ret = refresh_total_sectors(bs, bs->total_sectors);
989 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200990 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100991 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200992 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100993
Kevin Wolfd34682c2013-12-11 19:26:16 +0100994 bdrv_refresh_limits(bs);
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100995 assert(bdrv_opt_mem_align(bs) != 0);
Kevin Wolf47ea2de2014-03-05 15:49:55 +0100996 assert((bs->request_alignment != 0) || bs->sg);
Kevin Wolf57915332010-04-14 15:24:50 +0200997 return 0;
998
999free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001000 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -05001001 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +02001002 bs->opaque = NULL;
1003 bs->drv = NULL;
1004 return ret;
1005}
1006
1007/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001008 * Opens a file using a protocol (file, host_device, nbd, ...)
Kevin Wolf787e4a82013-03-06 11:52:48 +01001009 *
Max Reitz5acd9d82014-02-18 18:33:11 +01001010 * options is an indirect pointer to a QDict of options to pass to the block
1011 * drivers, or pointer to NULL for an empty set of options. If this function
1012 * takes ownership of the QDict reference, it will set *options to NULL;
1013 * otherwise, it will contain unused/unrecognized options after this function
1014 * returns. Then, the caller is responsible for freeing it. If it intends to
1015 * reuse the QDict, QINCREF() should be called beforehand.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001016 */
Max Reitzd4446ea2014-02-18 18:33:09 +01001017static int bdrv_file_open(BlockDriverState *bs, const char *filename,
Max Reitz5acd9d82014-02-18 18:33:11 +01001018 QDict **options, int flags, Error **errp)
bellardb3380822004-03-14 21:38:54 +00001019{
Christoph Hellwig6db95602010-04-05 16:53:57 +02001020 BlockDriver *drv;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001021 const char *drvname;
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001022 bool parse_filename = false;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001023 Error *local_err = NULL;
bellard83f64092006-08-01 16:21:11 +00001024 int ret;
1025
Kevin Wolf035fccd2013-04-09 14:34:19 +02001026 /* Fetch the file name from the options QDict if necessary */
1027 if (!filename) {
Max Reitz5acd9d82014-02-18 18:33:11 +01001028 filename = qdict_get_try_str(*options, "filename");
1029 } else if (filename && !qdict_haskey(*options, "filename")) {
1030 qdict_put(*options, "filename", qstring_from_str(filename));
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001031 parse_filename = true;
Kevin Wolf035fccd2013-04-09 14:34:19 +02001032 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001033 error_setg(errp, "Can't specify 'file' and 'filename' options at the "
1034 "same time");
Kevin Wolf035fccd2013-04-09 14:34:19 +02001035 ret = -EINVAL;
1036 goto fail;
1037 }
1038
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001039 /* Find the right block driver */
Max Reitz5acd9d82014-02-18 18:33:11 +01001040 drvname = qdict_get_try_str(*options, "driver");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001041 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001042 drv = bdrv_find_format(drvname);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001043 if (!drv) {
1044 error_setg(errp, "Unknown driver '%s'", drvname);
1045 }
Max Reitz5acd9d82014-02-18 18:33:11 +01001046 qdict_del(*options, "driver");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001047 } else if (filename) {
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001048 drv = bdrv_find_protocol(filename, parse_filename);
Kevin Wolf98289622013-07-10 15:47:39 +02001049 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001050 error_setg(errp, "Unknown protocol");
Kevin Wolf98289622013-07-10 15:47:39 +02001051 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001052 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001053 error_setg(errp, "Must specify either driver or file");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001054 drv = NULL;
1055 }
1056
1057 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001058 /* errp has been set already */
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001059 ret = -ENOENT;
1060 goto fail;
1061 }
1062
1063 /* Parse the filename and open it */
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001064 if (drv->bdrv_parse_filename && parse_filename) {
Max Reitz5acd9d82014-02-18 18:33:11 +01001065 drv->bdrv_parse_filename(filename, *options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001066 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001067 error_propagate(errp, local_err);
Kevin Wolf6963a302013-03-15 18:47:22 +01001068 ret = -EINVAL;
1069 goto fail;
1070 }
Max Reitzcd5d0312014-03-05 22:41:36 +01001071
1072 if (!drv->bdrv_needs_filename) {
1073 qdict_del(*options, "filename");
1074 } else {
1075 filename = qdict_get_str(*options, "filename");
1076 }
Kevin Wolf6963a302013-03-15 18:47:22 +01001077 }
1078
Max Reitz505d7582013-12-20 19:28:13 +01001079 if (!drv->bdrv_file_open) {
Max Reitz5acd9d82014-02-18 18:33:11 +01001080 ret = bdrv_open(&bs, filename, NULL, *options, flags, drv, &local_err);
1081 *options = NULL;
Max Reitz505d7582013-12-20 19:28:13 +01001082 } else {
Max Reitz5acd9d82014-02-18 18:33:11 +01001083 ret = bdrv_open_common(bs, NULL, *options, flags, drv, &local_err);
Max Reitz505d7582013-12-20 19:28:13 +01001084 }
Kevin Wolf707ff822013-03-06 12:20:31 +01001085 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001086 error_propagate(errp, local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +01001087 goto fail;
1088 }
1089
aliguori71d07702009-03-03 17:37:16 +00001090 bs->growable = 1;
bellard83f64092006-08-01 16:21:11 +00001091 return 0;
Kevin Wolf707ff822013-03-06 12:20:31 +01001092
1093fail:
Kevin Wolf707ff822013-03-06 12:20:31 +01001094 return ret;
bellardea2384d2004-08-01 21:59:26 +00001095}
bellardfc01f7e2003-06-30 10:03:06 +00001096
Fam Zheng8d24cce2014-05-23 21:29:45 +08001097void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1098{
1099
Fam Zheng826b6ca2014-05-23 21:29:47 +08001100 if (bs->backing_hd) {
1101 assert(bs->backing_blocker);
1102 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1103 } else if (backing_hd) {
1104 error_setg(&bs->backing_blocker,
1105 "device is used as backing hd of '%s'",
1106 bs->device_name);
1107 }
1108
Fam Zheng8d24cce2014-05-23 21:29:45 +08001109 bs->backing_hd = backing_hd;
1110 if (!backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001111 error_free(bs->backing_blocker);
1112 bs->backing_blocker = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001113 goto out;
1114 }
1115 bs->open_flags &= ~BDRV_O_NO_BACKING;
1116 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1117 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1118 backing_hd->drv ? backing_hd->drv->format_name : "");
Fam Zheng826b6ca2014-05-23 21:29:47 +08001119
1120 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1121 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1122 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1123 bs->backing_blocker);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001124out:
1125 bdrv_refresh_limits(bs);
1126}
1127
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001128/*
1129 * Opens the backing file for a BlockDriverState if not yet open
1130 *
1131 * options is a QDict of options to pass to the block drivers, or NULL for an
1132 * empty set of options. The reference to the QDict is transferred to this
1133 * function (even on failure), so if the caller intends to reuse the dictionary,
1134 * it needs to use QINCREF() before calling bdrv_file_open.
1135 */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001136int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001137{
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001138 char *backing_filename = g_malloc0(PATH_MAX);
Kevin Wolf317fc442014-04-25 13:27:34 +02001139 int ret = 0;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001140 BlockDriver *back_drv = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001141 BlockDriverState *backing_hd;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001142 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001143
1144 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001145 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001146 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001147 }
1148
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001149 /* NULL means an empty set of options */
1150 if (options == NULL) {
1151 options = qdict_new();
1152 }
1153
Paolo Bonzini9156df12012-10-18 16:49:17 +02001154 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001155 if (qdict_haskey(options, "file.filename")) {
1156 backing_filename[0] = '\0';
1157 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001158 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001159 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001160 } else {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001161 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001162 }
1163
Fam Zheng8d24cce2014-05-23 21:29:45 +08001164 backing_hd = bdrv_new("", errp);
1165
Paolo Bonzini9156df12012-10-18 16:49:17 +02001166 if (bs->backing_format[0] != '\0') {
1167 back_drv = bdrv_find_format(bs->backing_format);
1168 }
1169
Max Reitzf67503e2014-02-18 18:33:05 +01001170 assert(bs->backing_hd == NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001171 ret = bdrv_open(&backing_hd,
Max Reitzddf56362014-02-18 18:33:06 +01001172 *backing_filename ? backing_filename : NULL, NULL, options,
Kevin Wolf317fc442014-04-25 13:27:34 +02001173 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001174 if (ret < 0) {
Fam Zheng8d24cce2014-05-23 21:29:45 +08001175 bdrv_unref(backing_hd);
1176 backing_hd = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001177 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001178 error_setg(errp, "Could not open backing file: %s",
1179 error_get_pretty(local_err));
1180 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001181 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001182 }
Fam Zheng8d24cce2014-05-23 21:29:45 +08001183 bdrv_set_backing_hd(bs, backing_hd);
Peter Feinerd80ac652014-01-08 19:43:25 +00001184
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001185free_exit:
1186 g_free(backing_filename);
1187 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001188}
1189
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001190/*
Max Reitzda557aa2013-12-20 19:28:11 +01001191 * Opens a disk image whose options are given as BlockdevRef in another block
1192 * device's options.
1193 *
Max Reitzda557aa2013-12-20 19:28:11 +01001194 * If allow_none is true, no image will be opened if filename is false and no
1195 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1196 *
1197 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1198 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1199 * itself, all options starting with "${bdref_key}." are considered part of the
1200 * BlockdevRef.
1201 *
1202 * The BlockdevRef will be removed from the options QDict.
Max Reitzf67503e2014-02-18 18:33:05 +01001203 *
1204 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
Max Reitzda557aa2013-12-20 19:28:11 +01001205 */
1206int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1207 QDict *options, const char *bdref_key, int flags,
Max Reitzf7d9fd82014-02-18 18:33:12 +01001208 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01001209{
1210 QDict *image_options;
1211 int ret;
1212 char *bdref_key_dot;
1213 const char *reference;
1214
Max Reitzf67503e2014-02-18 18:33:05 +01001215 assert(pbs);
1216 assert(*pbs == NULL);
1217
Max Reitzda557aa2013-12-20 19:28:11 +01001218 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1219 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1220 g_free(bdref_key_dot);
1221
1222 reference = qdict_get_try_str(options, bdref_key);
1223 if (!filename && !reference && !qdict_size(image_options)) {
1224 if (allow_none) {
1225 ret = 0;
1226 } else {
1227 error_setg(errp, "A block device must be specified for \"%s\"",
1228 bdref_key);
1229 ret = -EINVAL;
1230 }
Markus Armbrusterb20e61e2014-05-28 11:16:57 +02001231 QDECREF(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01001232 goto done;
1233 }
1234
Max Reitzf7d9fd82014-02-18 18:33:12 +01001235 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
Max Reitzda557aa2013-12-20 19:28:11 +01001236
1237done:
1238 qdict_del(options, bdref_key);
1239 return ret;
1240}
1241
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001242void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02001243{
1244 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001245 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001246 int64_t total_size;
1247 BlockDriver *bdrv_qcow2;
1248 QEMUOptionParameter *create_options;
1249 QDict *snapshot_options;
1250 BlockDriverState *bs_snapshot;
1251 Error *local_err;
1252 int ret;
1253
1254 /* if snapshot, we create a temporary backing file and open it
1255 instead of opening 'filename' directly */
1256
1257 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02001258 total_size = bdrv_getlength(bs);
1259 if (total_size < 0) {
1260 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001261 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02001262 }
1263 total_size &= BDRV_SECTOR_MASK;
Kevin Wolfb9988752014-04-03 12:09:34 +02001264
1265 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001266 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001267 if (ret < 0) {
1268 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001269 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001270 }
1271
1272 bdrv_qcow2 = bdrv_find_format("qcow2");
1273 create_options = parse_option_parameters("", bdrv_qcow2->create_options,
1274 NULL);
1275
1276 set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);
1277
1278 ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);
1279 free_option_parameters(create_options);
1280 if (ret < 0) {
1281 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1282 "'%s': %s", tmp_filename,
1283 error_get_pretty(local_err));
1284 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001285 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001286 }
1287
1288 /* Prepare a new options QDict for the temporary file */
1289 snapshot_options = qdict_new();
1290 qdict_put(snapshot_options, "file.driver",
1291 qstring_from_str("file"));
1292 qdict_put(snapshot_options, "file.filename",
1293 qstring_from_str(tmp_filename));
1294
Kevin Wolf98522f62014-04-17 13:16:01 +02001295 bs_snapshot = bdrv_new("", &error_abort);
Kevin Wolfb9988752014-04-03 12:09:34 +02001296
1297 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001298 flags, bdrv_qcow2, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001299 if (ret < 0) {
1300 error_propagate(errp, local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001301 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001302 }
1303
1304 bdrv_append(bs_snapshot, bs);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001305
1306out:
1307 g_free(tmp_filename);
Kevin Wolfb9988752014-04-03 12:09:34 +02001308}
1309
Max Reitz4993f7e2014-05-08 20:12:41 +02001310static QDict *parse_json_filename(const char *filename, Error **errp)
1311{
1312 QObject *options_obj;
1313 QDict *options;
1314 int ret;
1315
1316 ret = strstart(filename, "json:", &filename);
1317 assert(ret);
1318
1319 options_obj = qobject_from_json(filename);
1320 if (!options_obj) {
1321 error_setg(errp, "Could not parse the JSON options");
1322 return NULL;
1323 }
1324
1325 if (qobject_type(options_obj) != QTYPE_QDICT) {
1326 qobject_decref(options_obj);
1327 error_setg(errp, "Invalid JSON object given");
1328 return NULL;
1329 }
1330
1331 options = qobject_to_qdict(options_obj);
1332 qdict_flatten(options);
1333
1334 return options;
1335}
1336
Max Reitzda557aa2013-12-20 19:28:11 +01001337/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001338 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001339 *
1340 * options is a QDict of options to pass to the block drivers, or NULL for an
1341 * empty set of options. The reference to the QDict belongs to the block layer
1342 * after the call (even on failure), so if the caller intends to reuse the
1343 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01001344 *
1345 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1346 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01001347 *
1348 * The reference parameter may be used to specify an existing block device which
1349 * should be opened. If specified, neither options nor a filename may be given,
1350 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001351 */
Max Reitzddf56362014-02-18 18:33:06 +01001352int bdrv_open(BlockDriverState **pbs, const char *filename,
1353 const char *reference, QDict *options, int flags,
1354 BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001355{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001356 int ret;
Max Reitzf67503e2014-02-18 18:33:05 +01001357 BlockDriverState *file = NULL, *bs;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001358 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001359 Error *local_err = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001360 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00001361
Max Reitzf67503e2014-02-18 18:33:05 +01001362 assert(pbs);
1363
Max Reitzddf56362014-02-18 18:33:06 +01001364 if (reference) {
1365 bool options_non_empty = options ? qdict_size(options) : false;
1366 QDECREF(options);
1367
1368 if (*pbs) {
1369 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1370 "another block device");
1371 return -EINVAL;
1372 }
1373
1374 if (filename || options_non_empty) {
1375 error_setg(errp, "Cannot reference an existing block device with "
1376 "additional options or a new filename");
1377 return -EINVAL;
1378 }
1379
1380 bs = bdrv_lookup_bs(reference, reference, errp);
1381 if (!bs) {
1382 return -ENODEV;
1383 }
1384 bdrv_ref(bs);
1385 *pbs = bs;
1386 return 0;
1387 }
1388
Max Reitzf67503e2014-02-18 18:33:05 +01001389 if (*pbs) {
1390 bs = *pbs;
1391 } else {
Kevin Wolf98522f62014-04-17 13:16:01 +02001392 bs = bdrv_new("", &error_abort);
Max Reitzf67503e2014-02-18 18:33:05 +01001393 }
1394
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001395 /* NULL means an empty set of options */
1396 if (options == NULL) {
1397 options = qdict_new();
1398 }
1399
Max Reitz4993f7e2014-05-08 20:12:41 +02001400 if (filename && g_str_has_prefix(filename, "json:")) {
1401 QDict *json_options = parse_json_filename(filename, &local_err);
1402 if (local_err) {
1403 ret = -EINVAL;
1404 goto fail;
1405 }
1406
1407 /* Options given in the filename have lower priority than options
1408 * specified directly */
1409 qdict_join(options, json_options, false);
1410 QDECREF(json_options);
1411 filename = NULL;
1412 }
1413
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001414 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001415 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001416
Max Reitz5469a2a2014-02-18 18:33:10 +01001417 if (flags & BDRV_O_PROTOCOL) {
1418 assert(!drv);
Max Reitz5acd9d82014-02-18 18:33:11 +01001419 ret = bdrv_file_open(bs, filename, &options, flags & ~BDRV_O_PROTOCOL,
Max Reitz5469a2a2014-02-18 18:33:10 +01001420 &local_err);
Max Reitz5469a2a2014-02-18 18:33:10 +01001421 if (!ret) {
Kevin Wolfeb909c72014-03-06 16:34:46 +01001422 drv = bs->drv;
Max Reitz5acd9d82014-02-18 18:33:11 +01001423 goto done;
Max Reitz5469a2a2014-02-18 18:33:10 +01001424 } else if (bs->drv) {
1425 goto close_and_fail;
1426 } else {
1427 goto fail;
1428 }
1429 }
1430
Kevin Wolff500a6d2012-11-12 17:35:27 +01001431 /* Open image file without format layer */
Jeff Codybe028ad2012-09-20 15:13:17 -04001432 if (flags & BDRV_O_RDWR) {
1433 flags |= BDRV_O_ALLOW_RDWR;
1434 }
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001435 if (flags & BDRV_O_SNAPSHOT) {
1436 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1437 flags = bdrv_backing_flags(flags);
1438 }
Jeff Codybe028ad2012-09-20 15:13:17 -04001439
Max Reitzf67503e2014-02-18 18:33:05 +01001440 assert(file == NULL);
Max Reitz054963f2013-12-20 19:28:12 +01001441 ret = bdrv_open_image(&file, filename, options, "file",
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001442 bdrv_inherited_flags(flags),
1443 true, &local_err);
Max Reitz054963f2013-12-20 19:28:12 +01001444 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001445 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001446 }
1447
1448 /* Find the right image format driver */
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001449 drvname = qdict_get_try_str(options, "driver");
1450 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001451 drv = bdrv_find_format(drvname);
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001452 qdict_del(options, "driver");
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001453 if (!drv) {
1454 error_setg(errp, "Invalid driver: '%s'", drvname);
1455 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001456 goto fail;
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001457 }
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001458 }
1459
Kevin Wolff500a6d2012-11-12 17:35:27 +01001460 if (!drv) {
Max Reitz2a05cbe2013-12-20 19:28:10 +01001461 if (file) {
1462 ret = find_image_format(file, filename, &drv, &local_err);
1463 } else {
1464 error_setg(errp, "Must specify either driver or file");
1465 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001466 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01001467 }
Kevin Wolff500a6d2012-11-12 17:35:27 +01001468 }
1469
1470 if (!drv) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001471 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001472 }
1473
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001474 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001475 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001476 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001477 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01001478 }
1479
Max Reitz2a05cbe2013-12-20 19:28:10 +01001480 if (file && (bs->file != file)) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001481 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001482 file = NULL;
1483 }
1484
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001485 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001486 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001487 QDict *backing_options;
1488
Benoît Canet5726d872013-09-25 13:30:01 +02001489 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001490 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001491 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001492 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001493 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001494 }
1495
Kevin Wolfb9988752014-04-03 12:09:34 +02001496 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1497 * temporary snapshot afterwards. */
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001498 if (snapshot_flags) {
1499 bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001500 if (local_err) {
1501 error_propagate(errp, local_err);
1502 goto close_and_fail;
1503 }
1504 }
1505
1506
Max Reitz5acd9d82014-02-18 18:33:11 +01001507done:
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001508 /* Check if any unknown options were used */
Max Reitz5acd9d82014-02-18 18:33:11 +01001509 if (options && (qdict_size(options) != 0)) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001510 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01001511 if (flags & BDRV_O_PROTOCOL) {
1512 error_setg(errp, "Block protocol '%s' doesn't support the option "
1513 "'%s'", drv->format_name, entry->key);
1514 } else {
1515 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1516 "support the option '%s'", drv->format_name,
1517 bs->device_name, entry->key);
1518 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001519
1520 ret = -EINVAL;
1521 goto close_and_fail;
1522 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001523
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001524 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001525 bdrv_dev_change_media_cb(bs, true);
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001526 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1527 && !runstate_check(RUN_STATE_INMIGRATE)
1528 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1529 error_setg(errp,
1530 "Guest must be stopped for opening of encrypted image");
1531 ret = -EBUSY;
1532 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001533 }
1534
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001535 QDECREF(options);
Max Reitzf67503e2014-02-18 18:33:05 +01001536 *pbs = bs;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001537 return 0;
1538
Kevin Wolf8bfea152014-04-11 19:16:36 +02001539fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001540 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001541 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001542 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001543 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001544 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001545 bs->options = NULL;
Max Reitzf67503e2014-02-18 18:33:05 +01001546 if (!*pbs) {
1547 /* If *pbs is NULL, a new BDS has been created in this function and
1548 needs to be freed now. Otherwise, it does not need to be closed,
1549 since it has not really been opened yet. */
1550 bdrv_unref(bs);
1551 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001552 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001553 error_propagate(errp, local_err);
1554 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001555 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001556
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001557close_and_fail:
Max Reitzf67503e2014-02-18 18:33:05 +01001558 /* See fail path, but now the BDS has to be always closed */
1559 if (*pbs) {
1560 bdrv_close(bs);
1561 } else {
1562 bdrv_unref(bs);
1563 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001564 QDECREF(options);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001565 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001566 error_propagate(errp, local_err);
1567 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001568 return ret;
1569}
1570
Jeff Codye971aa12012-09-20 15:13:19 -04001571typedef struct BlockReopenQueueEntry {
1572 bool prepared;
1573 BDRVReopenState state;
1574 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1575} BlockReopenQueueEntry;
1576
1577/*
1578 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1579 * reopen of multiple devices.
1580 *
1581 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1582 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1583 * be created and initialized. This newly created BlockReopenQueue should be
1584 * passed back in for subsequent calls that are intended to be of the same
1585 * atomic 'set'.
1586 *
1587 * bs is the BlockDriverState to add to the reopen queue.
1588 *
1589 * flags contains the open flags for the associated bs
1590 *
1591 * returns a pointer to bs_queue, which is either the newly allocated
1592 * bs_queue, or the existing bs_queue being used.
1593 *
1594 */
1595BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1596 BlockDriverState *bs, int flags)
1597{
1598 assert(bs != NULL);
1599
1600 BlockReopenQueueEntry *bs_entry;
1601 if (bs_queue == NULL) {
1602 bs_queue = g_new0(BlockReopenQueue, 1);
1603 QSIMPLEQ_INIT(bs_queue);
1604 }
1605
Kevin Wolff1f25a22014-04-25 19:04:55 +02001606 /* bdrv_open() masks this flag out */
1607 flags &= ~BDRV_O_PROTOCOL;
1608
Jeff Codye971aa12012-09-20 15:13:19 -04001609 if (bs->file) {
Kevin Wolff1f25a22014-04-25 19:04:55 +02001610 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
Jeff Codye971aa12012-09-20 15:13:19 -04001611 }
1612
1613 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1614 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1615
1616 bs_entry->state.bs = bs;
1617 bs_entry->state.flags = flags;
1618
1619 return bs_queue;
1620}
1621
1622/*
1623 * Reopen multiple BlockDriverStates atomically & transactionally.
1624 *
1625 * The queue passed in (bs_queue) must have been built up previous
1626 * via bdrv_reopen_queue().
1627 *
1628 * Reopens all BDS specified in the queue, with the appropriate
1629 * flags. All devices are prepared for reopen, and failure of any
1630 * device will cause all device changes to be abandonded, and intermediate
1631 * data cleaned up.
1632 *
1633 * If all devices prepare successfully, then the changes are committed
1634 * to all devices.
1635 *
1636 */
1637int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1638{
1639 int ret = -1;
1640 BlockReopenQueueEntry *bs_entry, *next;
1641 Error *local_err = NULL;
1642
1643 assert(bs_queue != NULL);
1644
1645 bdrv_drain_all();
1646
1647 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1648 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1649 error_propagate(errp, local_err);
1650 goto cleanup;
1651 }
1652 bs_entry->prepared = true;
1653 }
1654
1655 /* If we reach this point, we have success and just need to apply the
1656 * changes
1657 */
1658 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1659 bdrv_reopen_commit(&bs_entry->state);
1660 }
1661
1662 ret = 0;
1663
1664cleanup:
1665 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1666 if (ret && bs_entry->prepared) {
1667 bdrv_reopen_abort(&bs_entry->state);
1668 }
1669 g_free(bs_entry);
1670 }
1671 g_free(bs_queue);
1672 return ret;
1673}
1674
1675
1676/* Reopen a single BlockDriverState with the specified flags. */
1677int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1678{
1679 int ret = -1;
1680 Error *local_err = NULL;
1681 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1682
1683 ret = bdrv_reopen_multiple(queue, &local_err);
1684 if (local_err != NULL) {
1685 error_propagate(errp, local_err);
1686 }
1687 return ret;
1688}
1689
1690
1691/*
1692 * Prepares a BlockDriverState for reopen. All changes are staged in the
1693 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1694 * the block driver layer .bdrv_reopen_prepare()
1695 *
1696 * bs is the BlockDriverState to reopen
1697 * flags are the new open flags
1698 * queue is the reopen queue
1699 *
1700 * Returns 0 on success, non-zero on error. On error errp will be set
1701 * as well.
1702 *
1703 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1704 * It is the responsibility of the caller to then call the abort() or
1705 * commit() for any other BDS that have been left in a prepare() state
1706 *
1707 */
1708int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1709 Error **errp)
1710{
1711 int ret = -1;
1712 Error *local_err = NULL;
1713 BlockDriver *drv;
1714
1715 assert(reopen_state != NULL);
1716 assert(reopen_state->bs->drv != NULL);
1717 drv = reopen_state->bs->drv;
1718
1719 /* if we are to stay read-only, do not allow permission change
1720 * to r/w */
1721 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1722 reopen_state->flags & BDRV_O_RDWR) {
1723 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1724 reopen_state->bs->device_name);
1725 goto error;
1726 }
1727
1728
1729 ret = bdrv_flush(reopen_state->bs);
1730 if (ret) {
1731 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1732 strerror(-ret));
1733 goto error;
1734 }
1735
1736 if (drv->bdrv_reopen_prepare) {
1737 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1738 if (ret) {
1739 if (local_err != NULL) {
1740 error_propagate(errp, local_err);
1741 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001742 error_setg(errp, "failed while preparing to reopen image '%s'",
1743 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001744 }
1745 goto error;
1746 }
1747 } else {
1748 /* It is currently mandatory to have a bdrv_reopen_prepare()
1749 * handler for each supported drv. */
1750 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1751 drv->format_name, reopen_state->bs->device_name,
1752 "reopening of file");
1753 ret = -1;
1754 goto error;
1755 }
1756
1757 ret = 0;
1758
1759error:
1760 return ret;
1761}
1762
1763/*
1764 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1765 * makes them final by swapping the staging BlockDriverState contents into
1766 * the active BlockDriverState contents.
1767 */
1768void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1769{
1770 BlockDriver *drv;
1771
1772 assert(reopen_state != NULL);
1773 drv = reopen_state->bs->drv;
1774 assert(drv != NULL);
1775
1776 /* If there are any driver level actions to take */
1777 if (drv->bdrv_reopen_commit) {
1778 drv->bdrv_reopen_commit(reopen_state);
1779 }
1780
1781 /* set BDS specific flags now */
1782 reopen_state->bs->open_flags = reopen_state->flags;
1783 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1784 BDRV_O_CACHE_WB);
1785 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01001786
1787 bdrv_refresh_limits(reopen_state->bs);
Jeff Codye971aa12012-09-20 15:13:19 -04001788}
1789
1790/*
1791 * Abort the reopen, and delete and free the staged changes in
1792 * reopen_state
1793 */
1794void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1795{
1796 BlockDriver *drv;
1797
1798 assert(reopen_state != NULL);
1799 drv = reopen_state->bs->drv;
1800 assert(drv != NULL);
1801
1802 if (drv->bdrv_reopen_abort) {
1803 drv->bdrv_reopen_abort(reopen_state);
1804 }
1805}
1806
1807
bellardfc01f7e2003-06-30 10:03:06 +00001808void bdrv_close(BlockDriverState *bs)
1809{
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001810 if (bs->job) {
1811 block_job_cancel_sync(bs->job);
1812 }
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001813 bdrv_drain_all(); /* complete I/O */
1814 bdrv_flush(bs);
1815 bdrv_drain_all(); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001816 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001817
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001818 if (bs->drv) {
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001819 if (bs->backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001820 BlockDriverState *backing_hd = bs->backing_hd;
1821 bdrv_set_backing_hd(bs, NULL);
1822 bdrv_unref(backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001823 }
bellardea2384d2004-08-01 21:59:26 +00001824 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001825 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001826 bs->opaque = NULL;
1827 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001828 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001829 bs->backing_file[0] = '\0';
1830 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001831 bs->total_sectors = 0;
1832 bs->encrypted = 0;
1833 bs->valid_key = 0;
1834 bs->sg = 0;
1835 bs->growable = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001836 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001837 QDECREF(bs->options);
1838 bs->options = NULL;
bellardb3380822004-03-14 21:38:54 +00001839
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001840 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001841 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001842 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001843 }
bellardb3380822004-03-14 21:38:54 +00001844 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001845
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001846 bdrv_dev_change_media_cb(bs, false);
1847
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001848 /*throttling disk I/O limits*/
1849 if (bs->io_limits_enabled) {
1850 bdrv_io_limits_disable(bs);
1851 }
bellardb3380822004-03-14 21:38:54 +00001852}
1853
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001854void bdrv_close_all(void)
1855{
1856 BlockDriverState *bs;
1857
Benoît Canetdc364f42014-01-23 21:31:32 +01001858 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001859 AioContext *aio_context = bdrv_get_aio_context(bs);
1860
1861 aio_context_acquire(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001862 bdrv_close(bs);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001863 aio_context_release(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001864 }
1865}
1866
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001867/* Check if any requests are in-flight (including throttled requests) */
1868static bool bdrv_requests_pending(BlockDriverState *bs)
1869{
1870 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1871 return true;
1872 }
Benoît Canetcc0681c2013-09-02 14:14:39 +02001873 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1874 return true;
1875 }
1876 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001877 return true;
1878 }
1879 if (bs->file && bdrv_requests_pending(bs->file)) {
1880 return true;
1881 }
1882 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1883 return true;
1884 }
1885 return false;
1886}
1887
1888static bool bdrv_requests_pending_all(void)
1889{
1890 BlockDriverState *bs;
Benoît Canetdc364f42014-01-23 21:31:32 +01001891 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001892 if (bdrv_requests_pending(bs)) {
1893 return true;
1894 }
1895 }
1896 return false;
1897}
1898
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001899/*
1900 * Wait for pending requests to complete across all BlockDriverStates
1901 *
1902 * This function does not flush data to disk, use bdrv_flush_all() for that
1903 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001904 *
1905 * Note that completion of an asynchronous I/O operation can trigger any
1906 * number of other I/O operations on other devices---for example a coroutine
1907 * can be arbitrarily complex and a constant flow of I/O can come until the
1908 * coroutine is complete. Because of this, it is not possible to have a
1909 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001910 */
1911void bdrv_drain_all(void)
1912{
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001913 /* Always run first iteration so any pending completion BHs run */
1914 bool busy = true;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001915 BlockDriverState *bs;
1916
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001917 while (busy) {
Benoît Canetdc364f42014-01-23 21:31:32 +01001918 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi0b06ef32013-11-26 16:18:00 +01001919 bdrv_start_throttled_reqs(bs);
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001920 }
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001921
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001922 busy = bdrv_requests_pending_all();
1923 busy |= aio_poll(qemu_get_aio_context(), busy);
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001924 }
1925}
1926
Benoît Canetdc364f42014-01-23 21:31:32 +01001927/* make a BlockDriverState anonymous by removing from bdrv_state and
1928 * graph_bdrv_state list.
Ryan Harperd22b2f42011-03-29 20:51:47 -05001929 Also, NULL terminate the device_name to prevent double remove */
1930void bdrv_make_anon(BlockDriverState *bs)
1931{
1932 if (bs->device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +01001933 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
Ryan Harperd22b2f42011-03-29 20:51:47 -05001934 }
1935 bs->device_name[0] = '\0';
Benoît Canetdc364f42014-01-23 21:31:32 +01001936 if (bs->node_name[0] != '\0') {
1937 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1938 }
1939 bs->node_name[0] = '\0';
Ryan Harperd22b2f42011-03-29 20:51:47 -05001940}
1941
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001942static void bdrv_rebind(BlockDriverState *bs)
1943{
1944 if (bs->drv && bs->drv->bdrv_rebind) {
1945 bs->drv->bdrv_rebind(bs);
1946 }
1947}
1948
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001949static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1950 BlockDriverState *bs_src)
1951{
1952 /* move some fields that need to stay attached to the device */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001953
1954 /* dev info */
1955 bs_dest->dev_ops = bs_src->dev_ops;
1956 bs_dest->dev_opaque = bs_src->dev_opaque;
1957 bs_dest->dev = bs_src->dev;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01001958 bs_dest->guest_block_size = bs_src->guest_block_size;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001959 bs_dest->copy_on_read = bs_src->copy_on_read;
1960
1961 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1962
Benoît Canetcc0681c2013-09-02 14:14:39 +02001963 /* i/o throttled req */
1964 memcpy(&bs_dest->throttle_state,
1965 &bs_src->throttle_state,
1966 sizeof(ThrottleState));
1967 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1968 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001969 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1970
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001971 /* r/w error */
1972 bs_dest->on_read_error = bs_src->on_read_error;
1973 bs_dest->on_write_error = bs_src->on_write_error;
1974
1975 /* i/o status */
1976 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1977 bs_dest->iostatus = bs_src->iostatus;
1978
1979 /* dirty bitmap */
Fam Zhenge4654d22013-11-13 18:29:43 +08001980 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001981
Fam Zheng9fcb0252013-08-23 09:14:46 +08001982 /* reference count */
1983 bs_dest->refcnt = bs_src->refcnt;
1984
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001985 /* job */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001986 bs_dest->job = bs_src->job;
1987
1988 /* keep the same entry in bdrv_states */
1989 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1990 bs_src->device_name);
Benoît Canetdc364f42014-01-23 21:31:32 +01001991 bs_dest->device_list = bs_src->device_list;
Fam Zhengfbe40ff2014-05-23 21:29:42 +08001992 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1993 sizeof(bs_dest->op_blockers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001994}
1995
1996/*
1997 * Swap bs contents for two image chains while they are live,
1998 * while keeping required fields on the BlockDriverState that is
1999 * actually attached to a device.
2000 *
2001 * This will modify the BlockDriverState fields, and swap contents
2002 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2003 *
2004 * bs_new is required to be anonymous.
2005 *
2006 * This function does not create any image files.
2007 */
2008void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2009{
2010 BlockDriverState tmp;
2011
Benoît Canet90ce8a02014-03-05 23:48:29 +01002012 /* The code needs to swap the node_name but simply swapping node_list won't
2013 * work so first remove the nodes from the graph list, do the swap then
2014 * insert them back if needed.
2015 */
2016 if (bs_new->node_name[0] != '\0') {
2017 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2018 }
2019 if (bs_old->node_name[0] != '\0') {
2020 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2021 }
2022
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002023 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2024 assert(bs_new->device_name[0] == '\0');
Fam Zhenge4654d22013-11-13 18:29:43 +08002025 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002026 assert(bs_new->job == NULL);
2027 assert(bs_new->dev == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002028 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02002029 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002030
2031 tmp = *bs_new;
2032 *bs_new = *bs_old;
2033 *bs_old = tmp;
2034
2035 /* there are some fields that should not be swapped, move them back */
2036 bdrv_move_feature_fields(&tmp, bs_old);
2037 bdrv_move_feature_fields(bs_old, bs_new);
2038 bdrv_move_feature_fields(bs_new, &tmp);
2039
2040 /* bs_new shouldn't be in bdrv_states even after the swap! */
2041 assert(bs_new->device_name[0] == '\0');
2042
2043 /* Check a few fields that should remain attached to the device */
2044 assert(bs_new->dev == NULL);
2045 assert(bs_new->job == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002046 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02002047 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002048
Benoît Canet90ce8a02014-03-05 23:48:29 +01002049 /* insert the nodes back into the graph node list if needed */
2050 if (bs_new->node_name[0] != '\0') {
2051 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2052 }
2053 if (bs_old->node_name[0] != '\0') {
2054 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2055 }
2056
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002057 bdrv_rebind(bs_new);
2058 bdrv_rebind(bs_old);
2059}
2060
Jeff Cody8802d1f2012-02-28 15:54:06 -05002061/*
2062 * Add new bs contents at the top of an image chain while the chain is
2063 * live, while keeping required fields on the top layer.
2064 *
2065 * This will modify the BlockDriverState fields, and swap contents
2066 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2067 *
Jeff Codyf6801b82012-03-27 16:30:19 -04002068 * bs_new is required to be anonymous.
2069 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05002070 * This function does not create any image files.
2071 */
2072void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2073{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002074 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002075
2076 /* The contents of 'tmp' will become bs_top, as we are
2077 * swapping bs_new and bs_top contents. */
Fam Zheng8d24cce2014-05-23 21:29:45 +08002078 bdrv_set_backing_hd(bs_top, bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002079}
2080
Fam Zheng4f6fd342013-08-23 09:14:47 +08002081static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00002082{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002083 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02002084 assert(!bs->job);
Fam Zheng3718d8a2014-05-23 21:29:43 +08002085 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08002086 assert(!bs->refcnt);
Fam Zhenge4654d22013-11-13 18:29:43 +08002087 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Markus Armbruster18846de2010-06-29 16:58:30 +02002088
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02002089 bdrv_close(bs);
2090
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002091 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05002092 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00002093
Anthony Liguori7267c092011-08-20 22:09:37 -05002094 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00002095}
2096
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002097int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2098/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02002099{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002100 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02002101 return -EBUSY;
2102 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002103 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03002104 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02002105 return 0;
2106}
2107
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002108/* TODO qdevified devices don't use this, remove when devices are qdevified */
2109void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02002110{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002111 if (bdrv_attach_dev(bs, dev) < 0) {
2112 abort();
2113 }
2114}
2115
2116void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2117/* TODO change to DeviceState *dev when all users are qdevified */
2118{
2119 assert(bs->dev == dev);
2120 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02002121 bs->dev_ops = NULL;
2122 bs->dev_opaque = NULL;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01002123 bs->guest_block_size = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02002124}
2125
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002126/* TODO change to return DeviceState * when all users are qdevified */
2127void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02002128{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002129 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02002130}
2131
Markus Armbruster0e49de52011-08-03 15:07:41 +02002132void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2133 void *opaque)
2134{
2135 bs->dev_ops = ops;
2136 bs->dev_opaque = opaque;
2137}
2138
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002139void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
2140 enum MonitorEvent ev,
2141 BlockErrorAction action, bool is_read)
Luiz Capitulino329c0a42012-01-25 16:59:43 -02002142{
2143 QObject *data;
2144 const char *action_str;
2145
2146 switch (action) {
2147 case BDRV_ACTION_REPORT:
2148 action_str = "report";
2149 break;
2150 case BDRV_ACTION_IGNORE:
2151 action_str = "ignore";
2152 break;
2153 case BDRV_ACTION_STOP:
2154 action_str = "stop";
2155 break;
2156 default:
2157 abort();
2158 }
2159
2160 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
2161 bdrv->device_name,
2162 action_str,
2163 is_read ? "read" : "write");
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002164 monitor_protocol_event(ev, data);
Luiz Capitulino329c0a42012-01-25 16:59:43 -02002165
2166 qobject_decref(data);
2167}
2168
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002169static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
2170{
2171 QObject *data;
2172
2173 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
2174 bdrv_get_device_name(bs), ejected);
2175 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
2176
2177 qobject_decref(data);
2178}
2179
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002180static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02002181{
Markus Armbruster145feb12011-08-03 15:07:42 +02002182 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002183 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002184 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002185 if (tray_was_closed) {
2186 /* tray open */
2187 bdrv_emit_qmp_eject_event(bs, true);
2188 }
2189 if (load) {
2190 /* tray close */
2191 bdrv_emit_qmp_eject_event(bs, false);
2192 }
Markus Armbruster145feb12011-08-03 15:07:42 +02002193 }
2194}
2195
Markus Armbruster2c6942f2011-09-06 18:58:51 +02002196bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2197{
2198 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2199}
2200
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01002201void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2202{
2203 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2204 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2205 }
2206}
2207
Markus Armbrustere4def802011-09-06 18:58:53 +02002208bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2209{
2210 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2211 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2212 }
2213 return false;
2214}
2215
Markus Armbruster145feb12011-08-03 15:07:42 +02002216static void bdrv_dev_resize_cb(BlockDriverState *bs)
2217{
2218 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2219 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02002220 }
2221}
2222
Markus Armbrusterf1076392011-09-06 18:58:46 +02002223bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2224{
2225 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2226 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2227 }
2228 return false;
2229}
2230
aliguorie97fc192009-04-21 23:11:50 +00002231/*
2232 * Run consistency checks on an image
2233 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002234 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002235 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002236 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002237 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002238int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002239{
2240 if (bs->drv->bdrv_check == NULL) {
2241 return -ENOTSUP;
2242 }
2243
Kevin Wolfe076f332010-06-29 11:43:13 +02002244 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002245 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002246}
2247
Kevin Wolf8a426612010-07-16 17:17:01 +02002248#define COMMIT_BUF_SECTORS 2048
2249
bellard33e39632003-07-06 17:15:21 +00002250/* commit COW file into the raw image */
2251int bdrv_commit(BlockDriverState *bs)
2252{
bellard19cb3732006-08-19 11:45:59 +00002253 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002254 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002255 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002256 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002257 uint8_t *buf = NULL;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002258 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00002259
bellard19cb3732006-08-19 11:45:59 +00002260 if (!drv)
2261 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002262
2263 if (!bs->backing_hd) {
2264 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002265 }
2266
Fam Zheng3718d8a2014-05-23 21:29:43 +08002267 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2268 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002269 return -EBUSY;
2270 }
2271
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002272 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002273 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2274 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002275 open_flags = bs->backing_hd->open_flags;
2276
2277 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002278 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2279 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002280 }
bellard33e39632003-07-06 17:15:21 +00002281 }
bellardea2384d2004-08-01 21:59:26 +00002282
Jeff Cody72706ea2014-01-24 09:02:35 -05002283 length = bdrv_getlength(bs);
2284 if (length < 0) {
2285 ret = length;
2286 goto ro_cleanup;
2287 }
2288
2289 backing_length = bdrv_getlength(bs->backing_hd);
2290 if (backing_length < 0) {
2291 ret = backing_length;
2292 goto ro_cleanup;
2293 }
2294
2295 /* If our top snapshot is larger than the backing file image,
2296 * grow the backing file image if possible. If not possible,
2297 * we must return an error */
2298 if (length > backing_length) {
2299 ret = bdrv_truncate(bs->backing_hd, length);
2300 if (ret < 0) {
2301 goto ro_cleanup;
2302 }
2303 }
2304
2305 total_sectors = length >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05002306 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00002307
Kevin Wolf8a426612010-07-16 17:17:01 +02002308 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002309 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2310 if (ret < 0) {
2311 goto ro_cleanup;
2312 }
2313 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002314 ret = bdrv_read(bs, sector, buf, n);
2315 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002316 goto ro_cleanup;
2317 }
2318
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002319 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2320 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002321 goto ro_cleanup;
2322 }
bellardea2384d2004-08-01 21:59:26 +00002323 }
2324 }
bellard95389c82005-12-18 18:28:15 +00002325
Christoph Hellwig1d449522010-01-17 12:32:30 +01002326 if (drv->bdrv_make_empty) {
2327 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002328 if (ret < 0) {
2329 goto ro_cleanup;
2330 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002331 bdrv_flush(bs);
2332 }
bellard95389c82005-12-18 18:28:15 +00002333
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002334 /*
2335 * Make sure all data we wrote to the backing device is actually
2336 * stable on disk.
2337 */
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002338 if (bs->backing_hd) {
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002339 bdrv_flush(bs->backing_hd);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002340 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002341
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002342 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002343ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05002344 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002345
2346 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002347 /* ignoring error return here */
2348 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002349 }
2350
Christoph Hellwig1d449522010-01-17 12:32:30 +01002351 return ret;
bellard33e39632003-07-06 17:15:21 +00002352}
2353
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002354int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002355{
2356 BlockDriverState *bs;
2357
Benoît Canetdc364f42014-01-23 21:31:32 +01002358 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002359 AioContext *aio_context = bdrv_get_aio_context(bs);
2360
2361 aio_context_acquire(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002362 if (bs->drv && bs->backing_hd) {
2363 int ret = bdrv_commit(bs);
2364 if (ret < 0) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002365 aio_context_release(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002366 return ret;
2367 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002368 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002369 aio_context_release(aio_context);
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002370 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002371 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002372}
2373
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002374/**
2375 * Remove an active request from the tracked requests list
2376 *
2377 * This function should be called when a tracked request is completing.
2378 */
2379static void tracked_request_end(BdrvTrackedRequest *req)
2380{
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002381 if (req->serialising) {
2382 req->bs->serialising_in_flight--;
2383 }
2384
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002385 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002386 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002387}
2388
2389/**
2390 * Add an active request to the tracked requests list
2391 */
2392static void tracked_request_begin(BdrvTrackedRequest *req,
2393 BlockDriverState *bs,
Kevin Wolf793ed472013-12-03 15:31:25 +01002394 int64_t offset,
2395 unsigned int bytes, bool is_write)
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002396{
2397 *req = (BdrvTrackedRequest){
2398 .bs = bs,
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002399 .offset = offset,
2400 .bytes = bytes,
2401 .is_write = is_write,
2402 .co = qemu_coroutine_self(),
2403 .serialising = false,
Kevin Wolf73271452013-12-04 17:08:50 +01002404 .overlap_offset = offset,
2405 .overlap_bytes = bytes,
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002406 };
2407
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002408 qemu_co_queue_init(&req->wait_queue);
2409
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002410 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2411}
2412
Kevin Wolfe96126f2014-02-08 10:42:18 +01002413static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002414{
Kevin Wolf73271452013-12-04 17:08:50 +01002415 int64_t overlap_offset = req->offset & ~(align - 1);
Kevin Wolfe96126f2014-02-08 10:42:18 +01002416 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2417 - overlap_offset;
Kevin Wolf73271452013-12-04 17:08:50 +01002418
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002419 if (!req->serialising) {
2420 req->bs->serialising_in_flight++;
2421 req->serialising = true;
2422 }
Kevin Wolf73271452013-12-04 17:08:50 +01002423
2424 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2425 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002426}
2427
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002428/**
2429 * Round a region to cluster boundaries
2430 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002431void bdrv_round_to_clusters(BlockDriverState *bs,
2432 int64_t sector_num, int nb_sectors,
2433 int64_t *cluster_sector_num,
2434 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002435{
2436 BlockDriverInfo bdi;
2437
2438 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2439 *cluster_sector_num = sector_num;
2440 *cluster_nb_sectors = nb_sectors;
2441 } else {
2442 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2443 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2444 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2445 nb_sectors, c);
2446 }
2447}
2448
Kevin Wolf73271452013-12-04 17:08:50 +01002449static int bdrv_get_cluster_size(BlockDriverState *bs)
Kevin Wolf793ed472013-12-03 15:31:25 +01002450{
2451 BlockDriverInfo bdi;
Kevin Wolf73271452013-12-04 17:08:50 +01002452 int ret;
Kevin Wolf793ed472013-12-03 15:31:25 +01002453
Kevin Wolf73271452013-12-04 17:08:50 +01002454 ret = bdrv_get_info(bs, &bdi);
2455 if (ret < 0 || bdi.cluster_size == 0) {
2456 return bs->request_alignment;
Kevin Wolf793ed472013-12-03 15:31:25 +01002457 } else {
Kevin Wolf73271452013-12-04 17:08:50 +01002458 return bdi.cluster_size;
Kevin Wolf793ed472013-12-03 15:31:25 +01002459 }
2460}
2461
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002462static bool tracked_request_overlaps(BdrvTrackedRequest *req,
Kevin Wolf793ed472013-12-03 15:31:25 +01002463 int64_t offset, unsigned int bytes)
2464{
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002465 /* aaaa bbbb */
Kevin Wolf73271452013-12-04 17:08:50 +01002466 if (offset >= req->overlap_offset + req->overlap_bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002467 return false;
2468 }
2469 /* bbbb aaaa */
Kevin Wolf73271452013-12-04 17:08:50 +01002470 if (req->overlap_offset >= offset + bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002471 return false;
2472 }
2473 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002474}
2475
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002476static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002477{
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002478 BlockDriverState *bs = self->bs;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002479 BdrvTrackedRequest *req;
2480 bool retry;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002481 bool waited = false;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002482
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002483 if (!bs->serialising_in_flight) {
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002484 return false;
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002485 }
2486
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002487 do {
2488 retry = false;
2489 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002490 if (req == self || (!req->serialising && !self->serialising)) {
Kevin Wolf65afd212013-12-03 14:55:55 +01002491 continue;
2492 }
Kevin Wolf73271452013-12-04 17:08:50 +01002493 if (tracked_request_overlaps(req, self->overlap_offset,
2494 self->overlap_bytes))
2495 {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002496 /* Hitting this means there was a reentrant request, for
2497 * example, a block driver issuing nested requests. This must
2498 * never happen since it means deadlock.
2499 */
2500 assert(qemu_coroutine_self() != req->co);
2501
Kevin Wolf64604402013-12-13 13:04:35 +01002502 /* If the request is already (indirectly) waiting for us, or
2503 * will wait for us as soon as it wakes up, then just go on
2504 * (instead of producing a deadlock in the former case). */
2505 if (!req->waiting_for) {
2506 self->waiting_for = req;
2507 qemu_co_queue_wait(&req->wait_queue);
2508 self->waiting_for = NULL;
2509 retry = true;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002510 waited = true;
Kevin Wolf64604402013-12-13 13:04:35 +01002511 break;
2512 }
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002513 }
2514 }
2515 } while (retry);
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002516
2517 return waited;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002518}
2519
Kevin Wolf756e6732010-01-12 12:55:17 +01002520/*
2521 * Return values:
2522 * 0 - success
2523 * -EINVAL - backing format specified, but no file
2524 * -ENOSPC - can't update the backing file because no space is left in the
2525 * image file header
2526 * -ENOTSUP - format driver doesn't support changing the backing file
2527 */
2528int bdrv_change_backing_file(BlockDriverState *bs,
2529 const char *backing_file, const char *backing_fmt)
2530{
2531 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002532 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002533
Paolo Bonzini5f377792012-04-12 14:01:01 +02002534 /* Backing file format doesn't make sense without a backing file */
2535 if (backing_fmt && !backing_file) {
2536 return -EINVAL;
2537 }
2538
Kevin Wolf756e6732010-01-12 12:55:17 +01002539 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002540 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002541 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002542 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002543 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002544
2545 if (ret == 0) {
2546 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2547 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2548 }
2549 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002550}
2551
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002552/*
2553 * Finds the image layer in the chain that has 'bs' as its backing file.
2554 *
2555 * active is the current topmost image.
2556 *
2557 * Returns NULL if bs is not found in active's image chain,
2558 * or if active == bs.
2559 */
2560BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2561 BlockDriverState *bs)
2562{
2563 BlockDriverState *overlay = NULL;
2564 BlockDriverState *intermediate;
2565
2566 assert(active != NULL);
2567 assert(bs != NULL);
2568
2569 /* if bs is the same as active, then by definition it has no overlay
2570 */
2571 if (active == bs) {
2572 return NULL;
2573 }
2574
2575 intermediate = active;
2576 while (intermediate->backing_hd) {
2577 if (intermediate->backing_hd == bs) {
2578 overlay = intermediate;
2579 break;
2580 }
2581 intermediate = intermediate->backing_hd;
2582 }
2583
2584 return overlay;
2585}
2586
2587typedef struct BlkIntermediateStates {
2588 BlockDriverState *bs;
2589 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2590} BlkIntermediateStates;
2591
2592
2593/*
2594 * Drops images above 'base' up to and including 'top', and sets the image
2595 * above 'top' to have base as its backing file.
2596 *
2597 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2598 * information in 'bs' can be properly updated.
2599 *
2600 * E.g., this will convert the following chain:
2601 * bottom <- base <- intermediate <- top <- active
2602 *
2603 * to
2604 *
2605 * bottom <- base <- active
2606 *
2607 * It is allowed for bottom==base, in which case it converts:
2608 *
2609 * base <- intermediate <- top <- active
2610 *
2611 * to
2612 *
2613 * base <- active
2614 *
2615 * Error conditions:
2616 * if active == top, that is considered an error
2617 *
2618 */
2619int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2620 BlockDriverState *base)
2621{
2622 BlockDriverState *intermediate;
2623 BlockDriverState *base_bs = NULL;
2624 BlockDriverState *new_top_bs = NULL;
2625 BlkIntermediateStates *intermediate_state, *next;
2626 int ret = -EIO;
2627
2628 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2629 QSIMPLEQ_INIT(&states_to_delete);
2630
2631 if (!top->drv || !base->drv) {
2632 goto exit;
2633 }
2634
2635 new_top_bs = bdrv_find_overlay(active, top);
2636
2637 if (new_top_bs == NULL) {
2638 /* we could not find the image above 'top', this is an error */
2639 goto exit;
2640 }
2641
2642 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2643 * to do, no intermediate images */
2644 if (new_top_bs->backing_hd == base) {
2645 ret = 0;
2646 goto exit;
2647 }
2648
2649 intermediate = top;
2650
2651 /* now we will go down through the list, and add each BDS we find
2652 * into our deletion queue, until we hit the 'base'
2653 */
2654 while (intermediate) {
2655 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2656 intermediate_state->bs = intermediate;
2657 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2658
2659 if (intermediate->backing_hd == base) {
2660 base_bs = intermediate->backing_hd;
2661 break;
2662 }
2663 intermediate = intermediate->backing_hd;
2664 }
2665 if (base_bs == NULL) {
2666 /* something went wrong, we did not end at the base. safely
2667 * unravel everything, and exit with error */
2668 goto exit;
2669 }
2670
2671 /* success - we can delete the intermediate states, and link top->base */
2672 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2673 base_bs->drv ? base_bs->drv->format_name : "");
2674 if (ret) {
2675 goto exit;
2676 }
Fam Zheng920beae2014-05-23 21:29:46 +08002677 bdrv_set_backing_hd(new_top_bs, base_bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002678
2679 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2680 /* so that bdrv_close() does not recursively close the chain */
Fam Zheng920beae2014-05-23 21:29:46 +08002681 bdrv_set_backing_hd(intermediate_state->bs, NULL);
Fam Zheng4f6fd342013-08-23 09:14:47 +08002682 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002683 }
2684 ret = 0;
2685
2686exit:
2687 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2688 g_free(intermediate_state);
2689 }
2690 return ret;
2691}
2692
2693
aliguori71d07702009-03-03 17:37:16 +00002694static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2695 size_t size)
2696{
2697 int64_t len;
2698
Kevin Wolf1dd3a442014-04-14 14:48:16 +02002699 if (size > INT_MAX) {
2700 return -EIO;
2701 }
2702
aliguori71d07702009-03-03 17:37:16 +00002703 if (!bdrv_is_inserted(bs))
2704 return -ENOMEDIUM;
2705
2706 if (bs->growable)
2707 return 0;
2708
2709 len = bdrv_getlength(bs);
2710
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02002711 if (offset < 0)
2712 return -EIO;
2713
2714 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00002715 return -EIO;
2716
2717 return 0;
2718}
2719
2720static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2721 int nb_sectors)
2722{
Kevin Wolf54db38a2014-04-14 14:47:14 +02002723 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
Kevin Wolf8f4754e2014-03-26 13:06:02 +01002724 return -EIO;
2725 }
2726
Jes Sorenseneb5a3162010-05-27 16:20:31 +02002727 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2728 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00002729}
2730
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002731typedef struct RwCo {
2732 BlockDriverState *bs;
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002733 int64_t offset;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002734 QEMUIOVector *qiov;
2735 bool is_write;
2736 int ret;
Peter Lieven4105eaa2013-07-11 14:16:22 +02002737 BdrvRequestFlags flags;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002738} RwCo;
2739
2740static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2741{
2742 RwCo *rwco = opaque;
2743
2744 if (!rwco->is_write) {
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002745 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2746 rwco->qiov->size, rwco->qiov,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002747 rwco->flags);
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002748 } else {
2749 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2750 rwco->qiov->size, rwco->qiov,
2751 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002752 }
2753}
2754
2755/*
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002756 * Process a vectored synchronous request using coroutines
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002757 */
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002758static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2759 QEMUIOVector *qiov, bool is_write,
2760 BdrvRequestFlags flags)
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002761{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002762 Coroutine *co;
2763 RwCo rwco = {
2764 .bs = bs,
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002765 .offset = offset,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002766 .qiov = qiov,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002767 .is_write = is_write,
2768 .ret = NOT_DONE,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002769 .flags = flags,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002770 };
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002771
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002772 /**
2773 * In sync call context, when the vcpu is blocked, this throttling timer
2774 * will not fire; so the I/O throttling function has to be disabled here
2775 * if it has been enabled.
2776 */
2777 if (bs->io_limits_enabled) {
2778 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2779 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2780 bdrv_io_limits_disable(bs);
2781 }
2782
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002783 if (qemu_in_coroutine()) {
2784 /* Fast-path if already in coroutine context */
2785 bdrv_rw_co_entry(&rwco);
2786 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02002787 AioContext *aio_context = bdrv_get_aio_context(bs);
2788
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002789 co = qemu_coroutine_create(bdrv_rw_co_entry);
2790 qemu_coroutine_enter(co, &rwco);
2791 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02002792 aio_poll(aio_context, true);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002793 }
2794 }
2795 return rwco.ret;
2796}
2797
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002798/*
2799 * Process a synchronous request using coroutines
2800 */
2801static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002802 int nb_sectors, bool is_write, BdrvRequestFlags flags)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002803{
2804 QEMUIOVector qiov;
2805 struct iovec iov = {
2806 .iov_base = (void *)buf,
2807 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2808 };
2809
Kevin Wolfda15ee52014-04-14 15:39:36 +02002810 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2811 return -EINVAL;
2812 }
2813
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002814 qemu_iovec_init_external(&qiov, &iov, 1);
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002815 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2816 &qiov, is_write, flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002817}
2818
bellard19cb3732006-08-19 11:45:59 +00002819/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002820int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002821 uint8_t *buf, int nb_sectors)
2822{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002823 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
bellardfc01f7e2003-06-30 10:03:06 +00002824}
2825
Markus Armbruster07d27a42012-06-29 17:34:29 +02002826/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2827int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2828 uint8_t *buf, int nb_sectors)
2829{
2830 bool enabled;
2831 int ret;
2832
2833 enabled = bs->io_limits_enabled;
2834 bs->io_limits_enabled = false;
Peter Lieven4e7395e2013-07-18 10:37:32 +02002835 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +02002836 bs->io_limits_enabled = enabled;
2837 return ret;
2838}
2839
ths5fafdf22007-09-16 21:08:06 +00002840/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002841 -EIO generic I/O error (may happen for all errors)
2842 -ENOMEDIUM No media inserted.
2843 -EINVAL Invalid sector number or nb_sectors
2844 -EACCES Trying to write a read-only device
2845*/
ths5fafdf22007-09-16 21:08:06 +00002846int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002847 const uint8_t *buf, int nb_sectors)
2848{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002849 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
bellard83f64092006-08-01 16:21:11 +00002850}
2851
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002852int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2853 int nb_sectors, BdrvRequestFlags flags)
Peter Lieven4105eaa2013-07-11 14:16:22 +02002854{
2855 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002856 BDRV_REQ_ZERO_WRITE | flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002857}
2858
Peter Lievend75cbb52013-10-24 12:07:03 +02002859/*
2860 * Completely zero out a block device with the help of bdrv_write_zeroes.
2861 * The operation is sped up by checking the block status and only writing
2862 * zeroes to the device if they currently do not return zeroes. Optional
2863 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2864 *
2865 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2866 */
2867int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2868{
Kevin Wolf9ce10c02014-04-14 17:03:34 +02002869 int64_t target_size;
Peter Lievend75cbb52013-10-24 12:07:03 +02002870 int64_t ret, nb_sectors, sector_num = 0;
2871 int n;
2872
Kevin Wolf9ce10c02014-04-14 17:03:34 +02002873 target_size = bdrv_getlength(bs);
2874 if (target_size < 0) {
2875 return target_size;
2876 }
2877 target_size /= BDRV_SECTOR_SIZE;
2878
Peter Lievend75cbb52013-10-24 12:07:03 +02002879 for (;;) {
2880 nb_sectors = target_size - sector_num;
2881 if (nb_sectors <= 0) {
2882 return 0;
2883 }
2884 if (nb_sectors > INT_MAX) {
2885 nb_sectors = INT_MAX;
2886 }
2887 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
Peter Lieven3d94ce62013-12-12 13:57:05 +01002888 if (ret < 0) {
2889 error_report("error getting block status at sector %" PRId64 ": %s",
2890 sector_num, strerror(-ret));
2891 return ret;
2892 }
Peter Lievend75cbb52013-10-24 12:07:03 +02002893 if (ret & BDRV_BLOCK_ZERO) {
2894 sector_num += n;
2895 continue;
2896 }
2897 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2898 if (ret < 0) {
2899 error_report("error writing zeroes at sector %" PRId64 ": %s",
2900 sector_num, strerror(-ret));
2901 return ret;
2902 }
2903 sector_num += n;
2904 }
2905}
2906
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002907int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
bellard83f64092006-08-01 16:21:11 +00002908{
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002909 QEMUIOVector qiov;
2910 struct iovec iov = {
2911 .iov_base = (void *)buf,
2912 .iov_len = bytes,
2913 };
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002914 int ret;
bellard83f64092006-08-01 16:21:11 +00002915
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002916 if (bytes < 0) {
2917 return -EINVAL;
bellard83f64092006-08-01 16:21:11 +00002918 }
2919
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002920 qemu_iovec_init_external(&qiov, &iov, 1);
2921 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2922 if (ret < 0) {
2923 return ret;
bellard83f64092006-08-01 16:21:11 +00002924 }
2925
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002926 return bytes;
bellard83f64092006-08-01 16:21:11 +00002927}
2928
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002929int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +00002930{
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002931 int ret;
bellard83f64092006-08-01 16:21:11 +00002932
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002933 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2934 if (ret < 0) {
2935 return ret;
bellard83f64092006-08-01 16:21:11 +00002936 }
2937
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002938 return qiov->size;
2939}
2940
2941int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002942 const void *buf, int bytes)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002943{
2944 QEMUIOVector qiov;
2945 struct iovec iov = {
2946 .iov_base = (void *) buf,
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002947 .iov_len = bytes,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002948 };
2949
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002950 if (bytes < 0) {
2951 return -EINVAL;
2952 }
2953
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002954 qemu_iovec_init_external(&qiov, &iov, 1);
2955 return bdrv_pwritev(bs, offset, &qiov);
bellard83f64092006-08-01 16:21:11 +00002956}
bellard83f64092006-08-01 16:21:11 +00002957
Kevin Wolff08145f2010-06-16 16:38:15 +02002958/*
2959 * Writes to the file and ensures that no writes are reordered across this
2960 * request (acts as a barrier)
2961 *
2962 * Returns 0 on success, -errno in error cases.
2963 */
2964int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2965 const void *buf, int count)
2966{
2967 int ret;
2968
2969 ret = bdrv_pwrite(bs, offset, buf, count);
2970 if (ret < 0) {
2971 return ret;
2972 }
2973
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002974 /* No flush needed for cache modes that already do it */
2975 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002976 bdrv_flush(bs);
2977 }
2978
2979 return 0;
2980}
2981
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002982static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002983 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2984{
2985 /* Perform I/O through a temporary buffer so that users who scribble over
2986 * their read buffer while the operation is in progress do not end up
2987 * modifying the image file. This is critical for zero-copy guest I/O
2988 * where anything might happen inside guest memory.
2989 */
2990 void *bounce_buffer;
2991
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002992 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002993 struct iovec iov;
2994 QEMUIOVector bounce_qiov;
2995 int64_t cluster_sector_num;
2996 int cluster_nb_sectors;
2997 size_t skip_bytes;
2998 int ret;
2999
3000 /* Cover entire cluster so no additional backing file I/O is required when
3001 * allocating cluster in the image file.
3002 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01003003 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
3004 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003005
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003006 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
3007 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003008
3009 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
3010 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
3011 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
3012
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003013 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
3014 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003015 if (ret < 0) {
3016 goto err;
3017 }
3018
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003019 if (drv->bdrv_co_write_zeroes &&
3020 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01003021 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003022 cluster_nb_sectors, 0);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003023 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02003024 /* This does not change the data on the disk, it is not necessary
3025 * to flush even in cache=writethrough mode.
3026 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003027 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00003028 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003029 }
3030
Stefan Hajnocziab185922011-11-17 13:40:31 +00003031 if (ret < 0) {
3032 /* It might be okay to ignore write errors for guest requests. If this
3033 * is a deliberate copy-on-read then we don't want to ignore the error.
3034 * Simply report it in all cases.
3035 */
3036 goto err;
3037 }
3038
3039 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04003040 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3041 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003042
3043err:
3044 qemu_vfree(bounce_buffer);
3045 return ret;
3046}
3047
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003048/*
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003049 * Forwards an already correctly aligned request to the BlockDriver. This
3050 * handles copy on read and zeroing after EOF; any other features must be
3051 * implemented by the caller.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003052 */
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003053static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003054 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
Kevin Wolfec746e12013-12-04 12:13:10 +01003055 int64_t align, QEMUIOVector *qiov, int flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02003056{
3057 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00003058 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003059
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003060 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3061 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003062
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003063 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3064 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3065
3066 /* Handle Copy on Read and associated serialisation */
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003067 if (flags & BDRV_REQ_COPY_ON_READ) {
Kevin Wolf73271452013-12-04 17:08:50 +01003068 /* If we touch the same cluster it counts as an overlap. This
3069 * guarantees that allocating writes will be serialized and not race
3070 * with each other for the same cluster. For example, in copy-on-read
3071 * it ensures that the CoR read and write operations are atomic and
3072 * guest writes cannot interleave between them. */
3073 mark_request_serialising(req, bdrv_get_cluster_size(bs));
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003074 }
3075
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01003076 wait_serialising_requests(req);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00003077
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003078 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00003079 int pnum;
3080
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003081 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003082 if (ret < 0) {
3083 goto out;
3084 }
3085
3086 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003087 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003088 goto out;
3089 }
3090 }
3091
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003092 /* Forward the request to the BlockDriver */
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08003093 if (!(bs->zero_beyond_eof && bs->growable)) {
3094 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3095 } else {
3096 /* Read zeros after EOF of growable BDSes */
3097 int64_t len, total_sectors, max_nb_sectors;
3098
3099 len = bdrv_getlength(bs);
3100 if (len < 0) {
3101 ret = len;
3102 goto out;
3103 }
3104
Fam Zhengd055a1f2013-09-26 19:55:33 +08003105 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
Kevin Wolf5f5bcd82014-02-07 16:00:09 +01003106 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3107 align >> BDRV_SECTOR_BITS);
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08003108 if (max_nb_sectors > 0) {
3109 ret = drv->bdrv_co_readv(bs, sector_num,
3110 MIN(nb_sectors, max_nb_sectors), qiov);
3111 } else {
3112 ret = 0;
3113 }
3114
3115 /* Reading beyond end of file is supposed to produce zeroes */
3116 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3117 uint64_t offset = MAX(0, total_sectors - sector_num);
3118 uint64_t bytes = (sector_num + nb_sectors - offset) *
3119 BDRV_SECTOR_SIZE;
3120 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3121 }
3122 }
Stefan Hajnocziab185922011-11-17 13:40:31 +00003123
3124out:
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00003125 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003126}
3127
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003128/*
3129 * Handle a read request in coroutine context
3130 */
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003131static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3132 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003133 BdrvRequestFlags flags)
3134{
3135 BlockDriver *drv = bs->drv;
Kevin Wolf65afd212013-12-03 14:55:55 +01003136 BdrvTrackedRequest req;
3137
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003138 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3139 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3140 uint8_t *head_buf = NULL;
3141 uint8_t *tail_buf = NULL;
3142 QEMUIOVector local_qiov;
3143 bool use_local_qiov = false;
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003144 int ret;
3145
3146 if (!drv) {
3147 return -ENOMEDIUM;
3148 }
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003149 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003150 return -EIO;
3151 }
3152
3153 if (bs->copy_on_read) {
3154 flags |= BDRV_REQ_COPY_ON_READ;
3155 }
3156
3157 /* throttling disk I/O */
3158 if (bs->io_limits_enabled) {
Kevin Wolfd5103582014-01-16 13:29:10 +01003159 bdrv_io_limits_intercept(bs, bytes, false);
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003160 }
3161
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003162 /* Align read if necessary by padding qiov */
3163 if (offset & (align - 1)) {
3164 head_buf = qemu_blockalign(bs, align);
3165 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3166 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3167 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3168 use_local_qiov = true;
3169
3170 bytes += offset & (align - 1);
3171 offset = offset & ~(align - 1);
3172 }
3173
3174 if ((offset + bytes) & (align - 1)) {
3175 if (!use_local_qiov) {
3176 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3177 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3178 use_local_qiov = true;
3179 }
3180 tail_buf = qemu_blockalign(bs, align);
3181 qemu_iovec_add(&local_qiov, tail_buf,
3182 align - ((offset + bytes) & (align - 1)));
3183
3184 bytes = ROUND_UP(bytes, align);
3185 }
3186
Kevin Wolf65afd212013-12-03 14:55:55 +01003187 tracked_request_begin(&req, bs, offset, bytes, false);
Kevin Wolfec746e12013-12-04 12:13:10 +01003188 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003189 use_local_qiov ? &local_qiov : qiov,
3190 flags);
Kevin Wolf65afd212013-12-03 14:55:55 +01003191 tracked_request_end(&req);
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003192
3193 if (use_local_qiov) {
3194 qemu_iovec_destroy(&local_qiov);
3195 qemu_vfree(head_buf);
3196 qemu_vfree(tail_buf);
3197 }
3198
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003199 return ret;
3200}
3201
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003202static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3203 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3204 BdrvRequestFlags flags)
3205{
3206 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3207 return -EINVAL;
3208 }
3209
3210 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3211 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3212}
3213
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003214int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02003215 int nb_sectors, QEMUIOVector *qiov)
3216{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003217 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003218
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003219 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3220}
3221
3222int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3223 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3224{
3225 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3226
3227 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3228 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003229}
3230
Peter Lievenc31cb702013-10-24 12:06:58 +02003231/* if no limit is specified in the BlockLimits use a default
3232 * of 32768 512-byte sectors (16 MiB) per request.
3233 */
3234#define MAX_WRITE_ZEROES_DEFAULT 32768
3235
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003236static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003237 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003238{
3239 BlockDriver *drv = bs->drv;
3240 QEMUIOVector qiov;
Peter Lievenc31cb702013-10-24 12:06:58 +02003241 struct iovec iov = {0};
3242 int ret = 0;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003243
Peter Lievenc31cb702013-10-24 12:06:58 +02003244 int max_write_zeroes = bs->bl.max_write_zeroes ?
3245 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
Kevin Wolf621f0582012-03-20 15:12:58 +01003246
Peter Lievenc31cb702013-10-24 12:06:58 +02003247 while (nb_sectors > 0 && !ret) {
3248 int num = nb_sectors;
3249
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003250 /* Align request. Block drivers can expect the "bulk" of the request
3251 * to be aligned.
3252 */
3253 if (bs->bl.write_zeroes_alignment
3254 && num > bs->bl.write_zeroes_alignment) {
3255 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3256 /* Make a small request up to the first aligned sector. */
Peter Lievenc31cb702013-10-24 12:06:58 +02003257 num = bs->bl.write_zeroes_alignment;
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003258 num -= sector_num % bs->bl.write_zeroes_alignment;
3259 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3260 /* Shorten the request to the last aligned sector. num cannot
3261 * underflow because num > bs->bl.write_zeroes_alignment.
3262 */
3263 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
Peter Lievenc31cb702013-10-24 12:06:58 +02003264 }
Kevin Wolf621f0582012-03-20 15:12:58 +01003265 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003266
3267 /* limit request size */
3268 if (num > max_write_zeroes) {
3269 num = max_write_zeroes;
3270 }
3271
3272 ret = -ENOTSUP;
3273 /* First try the efficient write zeroes operation */
3274 if (drv->bdrv_co_write_zeroes) {
3275 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3276 }
3277
3278 if (ret == -ENOTSUP) {
3279 /* Fall back to bounce buffer if write zeroes is unsupported */
3280 iov.iov_len = num * BDRV_SECTOR_SIZE;
3281 if (iov.iov_base == NULL) {
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003282 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
3283 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
Peter Lievenc31cb702013-10-24 12:06:58 +02003284 }
3285 qemu_iovec_init_external(&qiov, &iov, 1);
3286
3287 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003288
3289 /* Keep bounce buffer around if it is big enough for all
3290 * all future requests.
3291 */
3292 if (num < max_write_zeroes) {
3293 qemu_vfree(iov.iov_base);
3294 iov.iov_base = NULL;
3295 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003296 }
3297
3298 sector_num += num;
3299 nb_sectors -= num;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003300 }
3301
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003302 qemu_vfree(iov.iov_base);
3303 return ret;
3304}
3305
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003306/*
Kevin Wolfb404f722013-12-03 14:02:23 +01003307 * Forwards an already correctly aligned write request to the BlockDriver.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003308 */
Kevin Wolfb404f722013-12-03 14:02:23 +01003309static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003310 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3311 QEMUIOVector *qiov, int flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003312{
3313 BlockDriver *drv = bs->drv;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003314 bool waited;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003315 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003316
Kevin Wolfb404f722013-12-03 14:02:23 +01003317 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3318 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003319
Kevin Wolfb404f722013-12-03 14:02:23 +01003320 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3321 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
Benoît Canetcc0681c2013-09-02 14:14:39 +02003322
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003323 waited = wait_serialising_requests(req);
3324 assert(!waited || !req->serialising);
Kevin Wolfaf91f9a2014-02-07 15:35:56 +01003325 assert(req->overlap_offset <= offset);
3326 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
Kevin Wolf244eade2013-12-03 14:30:44 +01003327
Kevin Wolf65afd212013-12-03 14:55:55 +01003328 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003329
Peter Lieven465bee12014-05-18 00:58:19 +02003330 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3331 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3332 qemu_iovec_is_zero(qiov)) {
3333 flags |= BDRV_REQ_ZERO_WRITE;
3334 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3335 flags |= BDRV_REQ_MAY_UNMAP;
3336 }
3337 }
3338
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003339 if (ret < 0) {
3340 /* Do nothing, write notifier decided to fail this request */
3341 } else if (flags & BDRV_REQ_ZERO_WRITE) {
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003342 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003343 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003344 } else {
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003345 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003346 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3347 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003348 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003349
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02003350 if (ret == 0 && !bs->enable_write_cache) {
3351 ret = bdrv_co_flush(bs);
3352 }
3353
Fam Zhenge4654d22013-11-13 18:29:43 +08003354 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003355
3356 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3357 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3358 }
Paolo Bonzinidf2a6f22013-09-04 19:00:21 +02003359 if (bs->growable && ret >= 0) {
3360 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3361 }
Kevin Wolfda1fa912011-07-14 17:27:13 +02003362
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003363 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003364}
3365
Kevin Wolfb404f722013-12-03 14:02:23 +01003366/*
3367 * Handle a write request in coroutine context
3368 */
Kevin Wolf66015532013-12-03 14:40:18 +01003369static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3370 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfb404f722013-12-03 14:02:23 +01003371 BdrvRequestFlags flags)
3372{
Kevin Wolf65afd212013-12-03 14:55:55 +01003373 BdrvTrackedRequest req;
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003374 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3375 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3376 uint8_t *head_buf = NULL;
3377 uint8_t *tail_buf = NULL;
3378 QEMUIOVector local_qiov;
3379 bool use_local_qiov = false;
Kevin Wolfb404f722013-12-03 14:02:23 +01003380 int ret;
3381
3382 if (!bs->drv) {
3383 return -ENOMEDIUM;
3384 }
3385 if (bs->read_only) {
3386 return -EACCES;
3387 }
Kevin Wolf66015532013-12-03 14:40:18 +01003388 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfb404f722013-12-03 14:02:23 +01003389 return -EIO;
3390 }
3391
Kevin Wolfb404f722013-12-03 14:02:23 +01003392 /* throttling disk I/O */
3393 if (bs->io_limits_enabled) {
Kevin Wolfd5103582014-01-16 13:29:10 +01003394 bdrv_io_limits_intercept(bs, bytes, true);
Kevin Wolfb404f722013-12-03 14:02:23 +01003395 }
3396
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003397 /*
3398 * Align write if necessary by performing a read-modify-write cycle.
3399 * Pad qiov with the read parts and be sure to have a tracked request not
3400 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3401 */
Kevin Wolf65afd212013-12-03 14:55:55 +01003402 tracked_request_begin(&req, bs, offset, bytes, true);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003403
3404 if (offset & (align - 1)) {
3405 QEMUIOVector head_qiov;
3406 struct iovec head_iov;
3407
3408 mark_request_serialising(&req, align);
3409 wait_serialising_requests(&req);
3410
3411 head_buf = qemu_blockalign(bs, align);
3412 head_iov = (struct iovec) {
3413 .iov_base = head_buf,
3414 .iov_len = align,
3415 };
3416 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3417
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003418 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003419 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3420 align, &head_qiov, 0);
3421 if (ret < 0) {
3422 goto fail;
3423 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003424 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003425
3426 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3427 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3428 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3429 use_local_qiov = true;
3430
3431 bytes += offset & (align - 1);
3432 offset = offset & ~(align - 1);
3433 }
3434
3435 if ((offset + bytes) & (align - 1)) {
3436 QEMUIOVector tail_qiov;
3437 struct iovec tail_iov;
3438 size_t tail_bytes;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003439 bool waited;
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003440
3441 mark_request_serialising(&req, align);
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003442 waited = wait_serialising_requests(&req);
3443 assert(!waited || !use_local_qiov);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003444
3445 tail_buf = qemu_blockalign(bs, align);
3446 tail_iov = (struct iovec) {
3447 .iov_base = tail_buf,
3448 .iov_len = align,
3449 };
3450 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3451
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003452 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003453 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3454 align, &tail_qiov, 0);
3455 if (ret < 0) {
3456 goto fail;
3457 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003458 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003459
3460 if (!use_local_qiov) {
3461 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3462 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3463 use_local_qiov = true;
3464 }
3465
3466 tail_bytes = (offset + bytes) & (align - 1);
3467 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3468
3469 bytes = ROUND_UP(bytes, align);
3470 }
3471
3472 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3473 use_local_qiov ? &local_qiov : qiov,
3474 flags);
3475
3476fail:
Kevin Wolf65afd212013-12-03 14:55:55 +01003477 tracked_request_end(&req);
Kevin Wolfb404f722013-12-03 14:02:23 +01003478
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003479 if (use_local_qiov) {
3480 qemu_iovec_destroy(&local_qiov);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003481 }
Kevin Wolf99c4a852014-02-07 15:29:00 +01003482 qemu_vfree(head_buf);
3483 qemu_vfree(tail_buf);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003484
Kevin Wolfb404f722013-12-03 14:02:23 +01003485 return ret;
3486}
3487
Kevin Wolf66015532013-12-03 14:40:18 +01003488static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3489 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3490 BdrvRequestFlags flags)
3491{
3492 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3493 return -EINVAL;
3494 }
3495
3496 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3497 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3498}
3499
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003500int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3501 int nb_sectors, QEMUIOVector *qiov)
3502{
3503 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3504
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003505 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3506}
3507
3508int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003509 int64_t sector_num, int nb_sectors,
3510 BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003511{
Paolo Bonzini94d6ff22013-11-22 13:39:45 +01003512 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003513
Peter Lievend32f35c2013-10-24 12:06:52 +02003514 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3515 flags &= ~BDRV_REQ_MAY_UNMAP;
3516 }
3517
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003518 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003519 BDRV_REQ_ZERO_WRITE | flags);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003520}
3521
bellard83f64092006-08-01 16:21:11 +00003522/**
bellard83f64092006-08-01 16:21:11 +00003523 * Truncate file to 'offset' bytes (needed only for file protocols)
3524 */
3525int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3526{
3527 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003528 int ret;
bellard83f64092006-08-01 16:21:11 +00003529 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003530 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00003531 if (!drv->bdrv_truncate)
3532 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02003533 if (bs->read_only)
3534 return -EACCES;
Fam Zheng3718d8a2014-05-23 21:29:43 +08003535 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
Marcelo Tosatti85916752011-01-26 12:12:35 -02003536 return -EBUSY;
Fam Zheng3718d8a2014-05-23 21:29:43 +08003537 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003538 ret = drv->bdrv_truncate(bs, offset);
3539 if (ret == 0) {
3540 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02003541 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003542 }
3543 return ret;
bellard83f64092006-08-01 16:21:11 +00003544}
3545
3546/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003547 * Length of a allocated file in bytes. Sparse files are counted by actual
3548 * allocated space. Return < 0 if error or unknown.
3549 */
3550int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3551{
3552 BlockDriver *drv = bs->drv;
3553 if (!drv) {
3554 return -ENOMEDIUM;
3555 }
3556 if (drv->bdrv_get_allocated_file_size) {
3557 return drv->bdrv_get_allocated_file_size(bs);
3558 }
3559 if (bs->file) {
3560 return bdrv_get_allocated_file_size(bs->file);
3561 }
3562 return -ENOTSUP;
3563}
3564
3565/**
bellard83f64092006-08-01 16:21:11 +00003566 * Length of a file in bytes. Return < 0 if error or unknown.
3567 */
3568int64_t bdrv_getlength(BlockDriverState *bs)
3569{
3570 BlockDriver *drv = bs->drv;
3571 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003572 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003573
Kevin Wolfb94a2612013-10-29 12:18:58 +01003574 if (drv->has_variable_length) {
3575 int ret = refresh_total_sectors(bs, bs->total_sectors);
3576 if (ret < 0) {
3577 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003578 }
bellard83f64092006-08-01 16:21:11 +00003579 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003580 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00003581}
3582
bellard19cb3732006-08-19 11:45:59 +00003583/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00003584void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00003585{
bellard19cb3732006-08-19 11:45:59 +00003586 int64_t length;
3587 length = bdrv_getlength(bs);
3588 if (length < 0)
3589 length = 0;
3590 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01003591 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00003592 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00003593}
bellardcf989512004-02-16 21:56:36 +00003594
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02003595void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3596 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003597{
3598 bs->on_read_error = on_read_error;
3599 bs->on_write_error = on_write_error;
3600}
3601
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02003602BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003603{
3604 return is_read ? bs->on_read_error : bs->on_write_error;
3605}
3606
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003607BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3608{
3609 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3610
3611 switch (on_err) {
3612 case BLOCKDEV_ON_ERROR_ENOSPC:
3613 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
3614 case BLOCKDEV_ON_ERROR_STOP:
3615 return BDRV_ACTION_STOP;
3616 case BLOCKDEV_ON_ERROR_REPORT:
3617 return BDRV_ACTION_REPORT;
3618 case BLOCKDEV_ON_ERROR_IGNORE:
3619 return BDRV_ACTION_IGNORE;
3620 default:
3621 abort();
3622 }
3623}
3624
3625/* This is done by device models because, while the block layer knows
3626 * about the error, it does not know whether an operation comes from
3627 * the device or the block layer (from a job, for example).
3628 */
3629void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3630 bool is_read, int error)
3631{
3632 assert(error >= 0);
Paolo Bonzini32c81a42012-09-28 17:22:58 +02003633 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003634 if (action == BDRV_ACTION_STOP) {
3635 vm_stop(RUN_STATE_IO_ERROR);
3636 bdrv_iostatus_set_err(bs, error);
3637 }
3638}
3639
bellardb3380822004-03-14 21:38:54 +00003640int bdrv_is_read_only(BlockDriverState *bs)
3641{
3642 return bs->read_only;
3643}
3644
ths985a03b2007-12-24 16:10:43 +00003645int bdrv_is_sg(BlockDriverState *bs)
3646{
3647 return bs->sg;
3648}
3649
Christoph Hellwige900a7b2009-09-04 19:01:15 +02003650int bdrv_enable_write_cache(BlockDriverState *bs)
3651{
3652 return bs->enable_write_cache;
3653}
3654
Paolo Bonzini425b0142012-06-06 00:04:52 +02003655void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3656{
3657 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04003658
3659 /* so a reopen() will preserve wce */
3660 if (wce) {
3661 bs->open_flags |= BDRV_O_CACHE_WB;
3662 } else {
3663 bs->open_flags &= ~BDRV_O_CACHE_WB;
3664 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02003665}
3666
bellardea2384d2004-08-01 21:59:26 +00003667int bdrv_is_encrypted(BlockDriverState *bs)
3668{
3669 if (bs->backing_hd && bs->backing_hd->encrypted)
3670 return 1;
3671 return bs->encrypted;
3672}
3673
aliguoric0f4ce72009-03-05 23:01:01 +00003674int bdrv_key_required(BlockDriverState *bs)
3675{
3676 BlockDriverState *backing_hd = bs->backing_hd;
3677
3678 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3679 return 1;
3680 return (bs->encrypted && !bs->valid_key);
3681}
3682
bellardea2384d2004-08-01 21:59:26 +00003683int bdrv_set_key(BlockDriverState *bs, const char *key)
3684{
3685 int ret;
3686 if (bs->backing_hd && bs->backing_hd->encrypted) {
3687 ret = bdrv_set_key(bs->backing_hd, key);
3688 if (ret < 0)
3689 return ret;
3690 if (!bs->encrypted)
3691 return 0;
3692 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02003693 if (!bs->encrypted) {
3694 return -EINVAL;
3695 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3696 return -ENOMEDIUM;
3697 }
aliguoric0f4ce72009-03-05 23:01:01 +00003698 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00003699 if (ret < 0) {
3700 bs->valid_key = 0;
3701 } else if (!bs->valid_key) {
3702 bs->valid_key = 1;
3703 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02003704 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00003705 }
aliguoric0f4ce72009-03-05 23:01:01 +00003706 return ret;
bellardea2384d2004-08-01 21:59:26 +00003707}
3708
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003709const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003710{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003711 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00003712}
3713
ths5fafdf22007-09-16 21:08:06 +00003714void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00003715 void *opaque)
3716{
3717 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04003718 int count = 0;
3719 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00003720
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01003721 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04003722 if (drv->format_name) {
3723 bool found = false;
3724 int i = count;
3725 while (formats && i && !found) {
3726 found = !strcmp(formats[--i], drv->format_name);
3727 }
3728
3729 if (!found) {
3730 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3731 formats[count++] = drv->format_name;
3732 it(opaque, drv->format_name);
3733 }
3734 }
bellardea2384d2004-08-01 21:59:26 +00003735 }
Jeff Codye855e4f2014-04-28 18:29:54 -04003736 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00003737}
3738
Benoît Canetdc364f42014-01-23 21:31:32 +01003739/* This function is to find block backend bs */
bellardb3380822004-03-14 21:38:54 +00003740BlockDriverState *bdrv_find(const char *name)
3741{
3742 BlockDriverState *bs;
3743
Benoît Canetdc364f42014-01-23 21:31:32 +01003744 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003745 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00003746 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003747 }
bellardb3380822004-03-14 21:38:54 +00003748 }
3749 return NULL;
3750}
3751
Benoît Canetdc364f42014-01-23 21:31:32 +01003752/* This function is to find a node in the bs graph */
3753BlockDriverState *bdrv_find_node(const char *node_name)
3754{
3755 BlockDriverState *bs;
3756
3757 assert(node_name);
3758
3759 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3760 if (!strcmp(node_name, bs->node_name)) {
3761 return bs;
3762 }
3763 }
3764 return NULL;
3765}
3766
Benoît Canetc13163f2014-01-23 21:31:34 +01003767/* Put this QMP function here so it can access the static graph_bdrv_states. */
3768BlockDeviceInfoList *bdrv_named_nodes_list(void)
3769{
3770 BlockDeviceInfoList *list, *entry;
3771 BlockDriverState *bs;
3772
3773 list = NULL;
3774 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3775 entry = g_malloc0(sizeof(*entry));
3776 entry->value = bdrv_block_device_info(bs);
3777 entry->next = list;
3778 list = entry;
3779 }
3780
3781 return list;
3782}
3783
Benoît Canet12d3ba82014-01-23 21:31:35 +01003784BlockDriverState *bdrv_lookup_bs(const char *device,
3785 const char *node_name,
3786 Error **errp)
3787{
3788 BlockDriverState *bs = NULL;
3789
Benoît Canet12d3ba82014-01-23 21:31:35 +01003790 if (device) {
3791 bs = bdrv_find(device);
3792
Benoît Canetdd67fa52014-02-12 17:15:06 +01003793 if (bs) {
3794 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01003795 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01003796 }
3797
Benoît Canetdd67fa52014-02-12 17:15:06 +01003798 if (node_name) {
3799 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01003800
Benoît Canetdd67fa52014-02-12 17:15:06 +01003801 if (bs) {
3802 return bs;
3803 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01003804 }
3805
Benoît Canetdd67fa52014-02-12 17:15:06 +01003806 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3807 device ? device : "",
3808 node_name ? node_name : "");
3809 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01003810}
3811
Markus Armbruster2f399b02010-06-02 18:55:20 +02003812BlockDriverState *bdrv_next(BlockDriverState *bs)
3813{
3814 if (!bs) {
3815 return QTAILQ_FIRST(&bdrv_states);
3816 }
Benoît Canetdc364f42014-01-23 21:31:32 +01003817 return QTAILQ_NEXT(bs, device_list);
Markus Armbruster2f399b02010-06-02 18:55:20 +02003818}
3819
aliguori51de9762009-03-05 23:00:43 +00003820void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00003821{
3822 BlockDriverState *bs;
3823
Benoît Canetdc364f42014-01-23 21:31:32 +01003824 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
aliguori51de9762009-03-05 23:00:43 +00003825 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00003826 }
3827}
3828
bellardea2384d2004-08-01 21:59:26 +00003829const char *bdrv_get_device_name(BlockDriverState *bs)
3830{
3831 return bs->device_name;
3832}
3833
Markus Armbrusterc8433282012-06-05 16:49:24 +02003834int bdrv_get_flags(BlockDriverState *bs)
3835{
3836 return bs->open_flags;
3837}
3838
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003839int bdrv_flush_all(void)
aliguoric6ca28d2008-10-06 13:55:43 +00003840{
3841 BlockDriverState *bs;
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003842 int result = 0;
aliguoric6ca28d2008-10-06 13:55:43 +00003843
Benoît Canetdc364f42014-01-23 21:31:32 +01003844 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003845 AioContext *aio_context = bdrv_get_aio_context(bs);
3846 int ret;
3847
3848 aio_context_acquire(aio_context);
3849 ret = bdrv_flush(bs);
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003850 if (ret < 0 && !result) {
3851 result = ret;
3852 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003853 aio_context_release(aio_context);
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003854 }
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003855
3856 return result;
aliguoric6ca28d2008-10-06 13:55:43 +00003857}
3858
Peter Lieven3ac21622013-06-28 12:47:42 +02003859int bdrv_has_zero_init_1(BlockDriverState *bs)
3860{
3861 return 1;
3862}
3863
Kevin Wolff2feebb2010-04-14 17:30:35 +02003864int bdrv_has_zero_init(BlockDriverState *bs)
3865{
3866 assert(bs->drv);
3867
Paolo Bonzini11212d82013-09-04 19:00:27 +02003868 /* If BS is a copy on write image, it is initialized to
3869 the contents of the base image, which may not be zeroes. */
3870 if (bs->backing_hd) {
3871 return 0;
3872 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003873 if (bs->drv->bdrv_has_zero_init) {
3874 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003875 }
3876
Peter Lieven3ac21622013-06-28 12:47:42 +02003877 /* safe default */
3878 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003879}
3880
Peter Lieven4ce78692013-10-24 12:06:54 +02003881bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3882{
3883 BlockDriverInfo bdi;
3884
3885 if (bs->backing_hd) {
3886 return false;
3887 }
3888
3889 if (bdrv_get_info(bs, &bdi) == 0) {
3890 return bdi.unallocated_blocks_are_zero;
3891 }
3892
3893 return false;
3894}
3895
3896bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3897{
3898 BlockDriverInfo bdi;
3899
3900 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3901 return false;
3902 }
3903
3904 if (bdrv_get_info(bs, &bdi) == 0) {
3905 return bdi.can_write_zeroes_with_unmap;
3906 }
3907
3908 return false;
3909}
3910
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003911typedef struct BdrvCoGetBlockStatusData {
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003912 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01003913 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003914 int64_t sector_num;
3915 int nb_sectors;
3916 int *pnum;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003917 int64_t ret;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003918 bool done;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003919} BdrvCoGetBlockStatusData;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003920
thsf58c7b32008-06-05 21:53:49 +00003921/*
3922 * Returns true iff the specified sector is present in the disk image. Drivers
3923 * not implementing the functionality are assumed to not support backing files,
3924 * hence all their sectors are reported as allocated.
3925 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003926 * If 'sector_num' is beyond the end of the disk image the return value is 0
3927 * and 'pnum' is set to 0.
3928 *
thsf58c7b32008-06-05 21:53:49 +00003929 * 'pnum' is set to the number of sectors (including and immediately following
3930 * the specified sector) that are known to be in the same
3931 * allocated/unallocated state.
3932 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003933 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3934 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00003935 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003936static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3937 int64_t sector_num,
3938 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00003939{
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003940 int64_t length;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003941 int64_t n;
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003942 int64_t ret, ret2;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003943
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003944 length = bdrv_getlength(bs);
3945 if (length < 0) {
3946 return length;
3947 }
3948
3949 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003950 *pnum = 0;
3951 return 0;
3952 }
3953
3954 n = bs->total_sectors - sector_num;
3955 if (n < nb_sectors) {
3956 nb_sectors = n;
3957 }
3958
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003959 if (!bs->drv->bdrv_co_get_block_status) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003960 *pnum = nb_sectors;
Kevin Wolfe88ae222014-05-06 15:25:36 +02003961 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
Paolo Bonzini918e92d2013-09-04 19:00:37 +02003962 if (bs->drv->protocol_name) {
3963 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3964 }
3965 return ret;
thsf58c7b32008-06-05 21:53:49 +00003966 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003967
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003968 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3969 if (ret < 0) {
Peter Lieven3e0a2332013-09-24 15:35:08 +02003970 *pnum = 0;
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003971 return ret;
3972 }
3973
Peter Lieven92bc50a2013-10-08 14:43:14 +02003974 if (ret & BDRV_BLOCK_RAW) {
3975 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3976 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3977 *pnum, pnum);
3978 }
3979
Kevin Wolfe88ae222014-05-06 15:25:36 +02003980 if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
3981 ret |= BDRV_BLOCK_ALLOCATED;
3982 }
3983
Peter Lievenc3d86882013-10-24 12:07:04 +02003984 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3985 if (bdrv_unallocated_blocks_are_zero(bs)) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003986 ret |= BDRV_BLOCK_ZERO;
Peter Lieven1f9db222013-09-24 15:35:09 +02003987 } else if (bs->backing_hd) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003988 BlockDriverState *bs2 = bs->backing_hd;
3989 int64_t length2 = bdrv_getlength(bs2);
3990 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3991 ret |= BDRV_BLOCK_ZERO;
3992 }
3993 }
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003994 }
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003995
3996 if (bs->file &&
3997 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3998 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3999 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4000 *pnum, pnum);
4001 if (ret2 >= 0) {
4002 /* Ignore errors. This is just providing extra information, it
4003 * is useful but not necessary.
4004 */
4005 ret |= (ret2 & BDRV_BLOCK_ZERO);
4006 }
4007 }
4008
Paolo Bonzini415b5b02013-09-04 19:00:31 +02004009 return ret;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004010}
4011
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004012/* Coroutine wrapper for bdrv_get_block_status() */
4013static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004014{
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004015 BdrvCoGetBlockStatusData *data = opaque;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004016 BlockDriverState *bs = data->bs;
4017
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004018 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4019 data->pnum);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004020 data->done = true;
4021}
4022
4023/*
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004024 * Synchronous wrapper around bdrv_co_get_block_status().
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004025 *
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004026 * See bdrv_co_get_block_status() for details.
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004027 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004028int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4029 int nb_sectors, int *pnum)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004030{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004031 Coroutine *co;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004032 BdrvCoGetBlockStatusData data = {
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004033 .bs = bs,
4034 .sector_num = sector_num,
4035 .nb_sectors = nb_sectors,
4036 .pnum = pnum,
4037 .done = false,
4038 };
4039
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004040 if (qemu_in_coroutine()) {
4041 /* Fast-path if already in coroutine context */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004042 bdrv_get_block_status_co_entry(&data);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004043 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004044 AioContext *aio_context = bdrv_get_aio_context(bs);
4045
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004046 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004047 qemu_coroutine_enter(co, &data);
4048 while (!data.done) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004049 aio_poll(aio_context, true);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004050 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004051 }
4052 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00004053}
4054
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004055int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4056 int nb_sectors, int *pnum)
4057{
Paolo Bonzini4333bb72013-09-04 19:00:29 +02004058 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4059 if (ret < 0) {
4060 return ret;
4061 }
Kevin Wolfe88ae222014-05-06 15:25:36 +02004062 return (ret & BDRV_BLOCK_ALLOCATED);
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004063}
4064
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004065/*
4066 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4067 *
4068 * Return true if the given sector is allocated in any image between
4069 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4070 * sector is allocated in any image of the chain. Return false otherwise.
4071 *
4072 * 'pnum' is set to the number of sectors (including and immediately following
4073 * the specified sector) that are known to be in the same
4074 * allocated/unallocated state.
4075 *
4076 */
Paolo Bonzini4f578632013-09-04 19:00:24 +02004077int bdrv_is_allocated_above(BlockDriverState *top,
4078 BlockDriverState *base,
4079 int64_t sector_num,
4080 int nb_sectors, int *pnum)
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004081{
4082 BlockDriverState *intermediate;
4083 int ret, n = nb_sectors;
4084
4085 intermediate = top;
4086 while (intermediate && intermediate != base) {
4087 int pnum_inter;
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004088 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4089 &pnum_inter);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004090 if (ret < 0) {
4091 return ret;
4092 } else if (ret) {
4093 *pnum = pnum_inter;
4094 return 1;
4095 }
4096
4097 /*
4098 * [sector_num, nb_sectors] is unallocated on top but intermediate
4099 * might have
4100 *
4101 * [sector_num+x, nr_sectors] allocated.
4102 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08004103 if (n > pnum_inter &&
4104 (intermediate == top ||
4105 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004106 n = pnum_inter;
4107 }
4108
4109 intermediate = intermediate->backing_hd;
4110 }
4111
4112 *pnum = n;
4113 return 0;
4114}
4115
aliguori045df332009-03-05 23:00:48 +00004116const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4117{
4118 if (bs->backing_hd && bs->backing_hd->encrypted)
4119 return bs->backing_file;
4120 else if (bs->encrypted)
4121 return bs->filename;
4122 else
4123 return NULL;
4124}
4125
ths5fafdf22007-09-16 21:08:06 +00004126void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00004127 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00004128{
Kevin Wolf3574c602011-10-26 11:02:11 +02004129 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00004130}
4131
ths5fafdf22007-09-16 21:08:06 +00004132int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00004133 const uint8_t *buf, int nb_sectors)
4134{
4135 BlockDriver *drv = bs->drv;
4136 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004137 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00004138 if (!drv->bdrv_write_compressed)
4139 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02004140 if (bdrv_check_request(bs, sector_num, nb_sectors))
4141 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004142
Fam Zhenge4654d22013-11-13 18:29:43 +08004143 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004144
bellardfaea38e2006-08-05 21:31:00 +00004145 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4146}
ths3b46e622007-09-17 08:09:54 +00004147
bellardfaea38e2006-08-05 21:31:00 +00004148int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4149{
4150 BlockDriver *drv = bs->drv;
4151 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004152 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00004153 if (!drv->bdrv_get_info)
4154 return -ENOTSUP;
4155 memset(bdi, 0, sizeof(*bdi));
4156 return drv->bdrv_get_info(bs, bdi);
4157}
4158
Max Reitzeae041f2013-10-09 10:46:16 +02004159ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4160{
4161 BlockDriver *drv = bs->drv;
4162 if (drv && drv->bdrv_get_specific_info) {
4163 return drv->bdrv_get_specific_info(bs);
4164 }
4165 return NULL;
4166}
4167
Christoph Hellwig45566e92009-07-10 23:11:57 +02004168int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4169 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00004170{
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004171 QEMUIOVector qiov;
4172 struct iovec iov = {
4173 .iov_base = (void *) buf,
4174 .iov_len = size,
4175 };
4176
4177 qemu_iovec_init_external(&qiov, &iov, 1);
4178 return bdrv_writev_vmstate(bs, &qiov, pos);
4179}
4180
4181int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4182{
aliguori178e08a2009-04-05 19:10:55 +00004183 BlockDriver *drv = bs->drv;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004184
4185 if (!drv) {
aliguori178e08a2009-04-05 19:10:55 +00004186 return -ENOMEDIUM;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004187 } else if (drv->bdrv_save_vmstate) {
4188 return drv->bdrv_save_vmstate(bs, qiov, pos);
4189 } else if (bs->file) {
4190 return bdrv_writev_vmstate(bs->file, qiov, pos);
4191 }
4192
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09004193 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00004194}
4195
Christoph Hellwig45566e92009-07-10 23:11:57 +02004196int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4197 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00004198{
4199 BlockDriver *drv = bs->drv;
4200 if (!drv)
4201 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09004202 if (drv->bdrv_load_vmstate)
4203 return drv->bdrv_load_vmstate(bs, buf, pos, size);
4204 if (bs->file)
4205 return bdrv_load_vmstate(bs->file, buf, pos, size);
4206 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00004207}
4208
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004209void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4210{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004211 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004212 return;
4213 }
4214
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004215 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01004216}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004217
Kevin Wolf41c695c2012-12-06 14:32:58 +01004218int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4219 const char *tag)
4220{
4221 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4222 bs = bs->file;
4223 }
4224
4225 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4226 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4227 }
4228
4229 return -ENOTSUP;
4230}
4231
Fam Zheng4cc70e92013-11-20 10:01:54 +08004232int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4233{
4234 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4235 bs = bs->file;
4236 }
4237
4238 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4239 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4240 }
4241
4242 return -ENOTSUP;
4243}
4244
Kevin Wolf41c695c2012-12-06 14:32:58 +01004245int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4246{
Max Reitz938789e2014-03-10 23:44:08 +01004247 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf41c695c2012-12-06 14:32:58 +01004248 bs = bs->file;
4249 }
4250
4251 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4252 return bs->drv->bdrv_debug_resume(bs, tag);
4253 }
4254
4255 return -ENOTSUP;
4256}
4257
4258bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4259{
4260 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4261 bs = bs->file;
4262 }
4263
4264 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4265 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4266 }
4267
4268 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004269}
4270
Blue Swirl199630b2010-07-25 20:49:34 +00004271int bdrv_is_snapshot(BlockDriverState *bs)
4272{
4273 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4274}
4275
Jeff Codyb1b1d782012-10-16 15:49:09 -04004276/* backing_file can either be relative, or absolute, or a protocol. If it is
4277 * relative, it must be relative to the chain. So, passing in bs->filename
4278 * from a BDS as backing_file should not be done, as that may be relative to
4279 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004280BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4281 const char *backing_file)
4282{
Jeff Codyb1b1d782012-10-16 15:49:09 -04004283 char *filename_full = NULL;
4284 char *backing_file_full = NULL;
4285 char *filename_tmp = NULL;
4286 int is_protocol = 0;
4287 BlockDriverState *curr_bs = NULL;
4288 BlockDriverState *retval = NULL;
4289
4290 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004291 return NULL;
4292 }
4293
Jeff Codyb1b1d782012-10-16 15:49:09 -04004294 filename_full = g_malloc(PATH_MAX);
4295 backing_file_full = g_malloc(PATH_MAX);
4296 filename_tmp = g_malloc(PATH_MAX);
4297
4298 is_protocol = path_has_protocol(backing_file);
4299
4300 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4301
4302 /* If either of the filename paths is actually a protocol, then
4303 * compare unmodified paths; otherwise make paths relative */
4304 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4305 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4306 retval = curr_bs->backing_hd;
4307 break;
4308 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004309 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04004310 /* If not an absolute filename path, make it relative to the current
4311 * image's filename path */
4312 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4313 backing_file);
4314
4315 /* We are going to compare absolute pathnames */
4316 if (!realpath(filename_tmp, filename_full)) {
4317 continue;
4318 }
4319
4320 /* We need to make sure the backing filename we are comparing against
4321 * is relative to the current image filename (or absolute) */
4322 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4323 curr_bs->backing_file);
4324
4325 if (!realpath(filename_tmp, backing_file_full)) {
4326 continue;
4327 }
4328
4329 if (strcmp(backing_file_full, filename_full) == 0) {
4330 retval = curr_bs->backing_hd;
4331 break;
4332 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004333 }
4334 }
4335
Jeff Codyb1b1d782012-10-16 15:49:09 -04004336 g_free(filename_full);
4337 g_free(backing_file_full);
4338 g_free(filename_tmp);
4339 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004340}
4341
Benoît Canetf198fd12012-08-02 10:22:47 +02004342int bdrv_get_backing_file_depth(BlockDriverState *bs)
4343{
4344 if (!bs->drv) {
4345 return 0;
4346 }
4347
4348 if (!bs->backing_hd) {
4349 return 0;
4350 }
4351
4352 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4353}
4354
Jeff Cody79fac562012-09-27 13:29:15 -04004355BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4356{
4357 BlockDriverState *curr_bs = NULL;
4358
4359 if (!bs) {
4360 return NULL;
4361 }
4362
4363 curr_bs = bs;
4364
4365 while (curr_bs->backing_hd) {
4366 curr_bs = curr_bs->backing_hd;
4367 }
4368 return curr_bs;
4369}
4370
bellard83f64092006-08-01 16:21:11 +00004371/**************************************************************/
4372/* async I/Os */
4373
aliguori3b69e4b2009-01-22 16:59:24 +00004374BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00004375 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00004376 BlockDriverCompletionFunc *cb, void *opaque)
4377{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004378 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4379
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004380 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004381 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00004382}
4383
aliguorif141eaf2009-04-07 18:43:24 +00004384BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4385 QEMUIOVector *qiov, int nb_sectors,
4386 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004387{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004388 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4389
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004390 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004391 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00004392}
4393
Paolo Bonzinid5ef94d2013-11-22 13:39:46 +01004394BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4395 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4396 BlockDriverCompletionFunc *cb, void *opaque)
4397{
4398 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4399
4400 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4401 BDRV_REQ_ZERO_WRITE | flags,
4402 cb, opaque, true);
4403}
4404
Kevin Wolf40b4f532009-09-09 17:53:37 +02004405
4406typedef struct MultiwriteCB {
4407 int error;
4408 int num_requests;
4409 int num_callbacks;
4410 struct {
4411 BlockDriverCompletionFunc *cb;
4412 void *opaque;
4413 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004414 } callbacks[];
4415} MultiwriteCB;
4416
4417static void multiwrite_user_cb(MultiwriteCB *mcb)
4418{
4419 int i;
4420
4421 for (i = 0; i < mcb->num_callbacks; i++) {
4422 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01004423 if (mcb->callbacks[i].free_qiov) {
4424 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4425 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004426 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004427 }
4428}
4429
4430static void multiwrite_cb(void *opaque, int ret)
4431{
4432 MultiwriteCB *mcb = opaque;
4433
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004434 trace_multiwrite_cb(mcb, ret);
4435
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02004436 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02004437 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004438 }
4439
4440 mcb->num_requests--;
4441 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02004442 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05004443 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004444 }
4445}
4446
4447static int multiwrite_req_compare(const void *a, const void *b)
4448{
Christoph Hellwig77be4362010-05-19 20:53:10 +02004449 const BlockRequest *req1 = a, *req2 = b;
4450
4451 /*
4452 * Note that we can't simply subtract req2->sector from req1->sector
4453 * here as that could overflow the return value.
4454 */
4455 if (req1->sector > req2->sector) {
4456 return 1;
4457 } else if (req1->sector < req2->sector) {
4458 return -1;
4459 } else {
4460 return 0;
4461 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02004462}
4463
4464/*
4465 * Takes a bunch of requests and tries to merge them. Returns the number of
4466 * requests that remain after merging.
4467 */
4468static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4469 int num_reqs, MultiwriteCB *mcb)
4470{
4471 int i, outidx;
4472
4473 // Sort requests by start sector
4474 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4475
4476 // Check if adjacent requests touch the same clusters. If so, combine them,
4477 // filling up gaps with zero sectors.
4478 outidx = 0;
4479 for (i = 1; i < num_reqs; i++) {
4480 int merge = 0;
4481 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4482
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004483 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02004484 if (reqs[i].sector <= oldreq_last) {
4485 merge = 1;
4486 }
4487
Christoph Hellwige2a305f2010-01-26 14:49:08 +01004488 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4489 merge = 0;
4490 }
4491
Kevin Wolf40b4f532009-09-09 17:53:37 +02004492 if (merge) {
4493 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05004494 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004495 qemu_iovec_init(qiov,
4496 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4497
4498 // Add the first request to the merged one. If the requests are
4499 // overlapping, drop the last sectors of the first request.
4500 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04004501 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004502
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004503 // We should need to add any zeros between the two requests
4504 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004505
4506 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04004507 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004508
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02004509 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004510 reqs[outidx].qiov = qiov;
4511
4512 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4513 } else {
4514 outidx++;
4515 reqs[outidx].sector = reqs[i].sector;
4516 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4517 reqs[outidx].qiov = reqs[i].qiov;
4518 }
4519 }
4520
4521 return outidx + 1;
4522}
4523
4524/*
4525 * Submit multiple AIO write requests at once.
4526 *
4527 * On success, the function returns 0 and all requests in the reqs array have
4528 * been submitted. In error case this function returns -1, and any of the
4529 * requests may or may not be submitted yet. In particular, this means that the
4530 * callback will be called for some of the requests, for others it won't. The
4531 * caller must check the error field of the BlockRequest to wait for the right
4532 * callbacks (if error != 0, no callback will be called).
4533 *
4534 * The implementation may modify the contents of the reqs array, e.g. to merge
4535 * requests. However, the fields opaque and error are left unmodified as they
4536 * are used to signal failure for a single request to the caller.
4537 */
4538int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4539{
Kevin Wolf40b4f532009-09-09 17:53:37 +02004540 MultiwriteCB *mcb;
4541 int i;
4542
Ryan Harper301db7c2011-03-07 10:01:04 -06004543 /* don't submit writes if we don't have a medium */
4544 if (bs->drv == NULL) {
4545 for (i = 0; i < num_reqs; i++) {
4546 reqs[i].error = -ENOMEDIUM;
4547 }
4548 return -1;
4549 }
4550
Kevin Wolf40b4f532009-09-09 17:53:37 +02004551 if (num_reqs == 0) {
4552 return 0;
4553 }
4554
4555 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05004556 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004557 mcb->num_requests = 0;
4558 mcb->num_callbacks = num_reqs;
4559
4560 for (i = 0; i < num_reqs; i++) {
4561 mcb->callbacks[i].cb = reqs[i].cb;
4562 mcb->callbacks[i].opaque = reqs[i].opaque;
4563 }
4564
4565 // Check for mergable requests
4566 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4567
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004568 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4569
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01004570 /* Run the aio requests. */
4571 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004572 for (i = 0; i < num_reqs; i++) {
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004573 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4574 reqs[i].nb_sectors, reqs[i].flags,
4575 multiwrite_cb, mcb,
4576 true);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004577 }
4578
4579 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004580}
4581
bellard83f64092006-08-01 16:21:11 +00004582void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00004583{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004584 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00004585}
4586
4587/**************************************************************/
4588/* async block device emulation */
4589
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004590typedef struct BlockDriverAIOCBSync {
4591 BlockDriverAIOCB common;
4592 QEMUBH *bh;
4593 int ret;
4594 /* vector translation state */
4595 QEMUIOVector *qiov;
4596 uint8_t *bounce;
4597 int is_write;
4598} BlockDriverAIOCBSync;
4599
4600static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4601{
Kevin Wolfb666d232010-05-05 11:44:39 +02004602 BlockDriverAIOCBSync *acb =
4603 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03004604 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004605 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004606 qemu_aio_release(acb);
4607}
4608
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004609static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004610 .aiocb_size = sizeof(BlockDriverAIOCBSync),
4611 .cancel = bdrv_aio_cancel_em,
4612};
4613
bellard83f64092006-08-01 16:21:11 +00004614static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00004615{
pbrookce1a14d2006-08-07 02:38:06 +00004616 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00004617
aliguorif141eaf2009-04-07 18:43:24 +00004618 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04004619 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00004620 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00004621 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03004622 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004623 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00004624 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00004625}
bellardbeac80c2006-06-26 20:08:57 +00004626
aliguorif141eaf2009-04-07 18:43:24 +00004627static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4628 int64_t sector_num,
4629 QEMUIOVector *qiov,
4630 int nb_sectors,
4631 BlockDriverCompletionFunc *cb,
4632 void *opaque,
4633 int is_write)
4634
bellardea2384d2004-08-01 21:59:26 +00004635{
pbrookce1a14d2006-08-07 02:38:06 +00004636 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00004637
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004638 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00004639 acb->is_write = is_write;
4640 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00004641 acb->bounce = qemu_blockalign(bs, qiov->size);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004642 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00004643
4644 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04004645 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004646 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004647 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004648 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004649 }
4650
pbrookce1a14d2006-08-07 02:38:06 +00004651 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00004652
pbrookce1a14d2006-08-07 02:38:06 +00004653 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00004654}
4655
aliguorif141eaf2009-04-07 18:43:24 +00004656static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4657 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00004658 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004659{
aliguorif141eaf2009-04-07 18:43:24 +00004660 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00004661}
4662
aliguorif141eaf2009-04-07 18:43:24 +00004663static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4664 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4665 BlockDriverCompletionFunc *cb, void *opaque)
4666{
4667 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4668}
4669
Kevin Wolf68485422011-06-30 10:05:46 +02004670
4671typedef struct BlockDriverAIOCBCoroutine {
4672 BlockDriverAIOCB common;
4673 BlockRequest req;
4674 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004675 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02004676 QEMUBH* bh;
4677} BlockDriverAIOCBCoroutine;
4678
4679static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4680{
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004681 AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004682 BlockDriverAIOCBCoroutine *acb =
4683 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4684 bool done = false;
4685
4686 acb->done = &done;
4687 while (!done) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004688 aio_poll(aio_context, true);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004689 }
Kevin Wolf68485422011-06-30 10:05:46 +02004690}
4691
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004692static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02004693 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4694 .cancel = bdrv_aio_co_cancel_em,
4695};
4696
Paolo Bonzini35246a62011-10-14 10:41:29 +02004697static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02004698{
4699 BlockDriverAIOCBCoroutine *acb = opaque;
4700
4701 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004702
4703 if (acb->done) {
4704 *acb->done = true;
4705 }
4706
Kevin Wolf68485422011-06-30 10:05:46 +02004707 qemu_bh_delete(acb->bh);
4708 qemu_aio_release(acb);
4709}
4710
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004711/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4712static void coroutine_fn bdrv_co_do_rw(void *opaque)
4713{
4714 BlockDriverAIOCBCoroutine *acb = opaque;
4715 BlockDriverState *bs = acb->common.bs;
4716
4717 if (!acb->is_write) {
4718 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004719 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004720 } else {
4721 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004722 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004723 }
4724
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004725 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004726 qemu_bh_schedule(acb->bh);
4727}
4728
Kevin Wolf68485422011-06-30 10:05:46 +02004729static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4730 int64_t sector_num,
4731 QEMUIOVector *qiov,
4732 int nb_sectors,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004733 BdrvRequestFlags flags,
Kevin Wolf68485422011-06-30 10:05:46 +02004734 BlockDriverCompletionFunc *cb,
4735 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004736 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02004737{
4738 Coroutine *co;
4739 BlockDriverAIOCBCoroutine *acb;
4740
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004741 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02004742 acb->req.sector = sector_num;
4743 acb->req.nb_sectors = nb_sectors;
4744 acb->req.qiov = qiov;
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004745 acb->req.flags = flags;
Kevin Wolf68485422011-06-30 10:05:46 +02004746 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004747 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02004748
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004749 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02004750 qemu_coroutine_enter(co, acb);
4751
4752 return &acb->common;
4753}
4754
Paolo Bonzini07f07612011-10-17 12:32:12 +02004755static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004756{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004757 BlockDriverAIOCBCoroutine *acb = opaque;
4758 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004759
Paolo Bonzini07f07612011-10-17 12:32:12 +02004760 acb->req.error = bdrv_co_flush(bs);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004761 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004762 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004763}
4764
Paolo Bonzini07f07612011-10-17 12:32:12 +02004765BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02004766 BlockDriverCompletionFunc *cb, void *opaque)
4767{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004768 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004769
Paolo Bonzini07f07612011-10-17 12:32:12 +02004770 Coroutine *co;
4771 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02004772
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004773 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004774 acb->done = NULL;
4775
Paolo Bonzini07f07612011-10-17 12:32:12 +02004776 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4777 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004778
Alexander Graf016f5cf2010-05-26 17:51:49 +02004779 return &acb->common;
4780}
4781
Paolo Bonzini4265d622011-10-17 12:32:14 +02004782static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4783{
4784 BlockDriverAIOCBCoroutine *acb = opaque;
4785 BlockDriverState *bs = acb->common.bs;
4786
4787 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004788 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004789 qemu_bh_schedule(acb->bh);
4790}
4791
4792BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4793 int64_t sector_num, int nb_sectors,
4794 BlockDriverCompletionFunc *cb, void *opaque)
4795{
4796 Coroutine *co;
4797 BlockDriverAIOCBCoroutine *acb;
4798
4799 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4800
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004801 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004802 acb->req.sector = sector_num;
4803 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004804 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004805 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4806 qemu_coroutine_enter(co, acb);
4807
4808 return &acb->common;
4809}
4810
bellardea2384d2004-08-01 21:59:26 +00004811void bdrv_init(void)
4812{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05004813 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00004814}
pbrookce1a14d2006-08-07 02:38:06 +00004815
Markus Armbrustereb852012009-10-27 18:41:44 +01004816void bdrv_init_with_whitelist(void)
4817{
4818 use_bdrv_whitelist = 1;
4819 bdrv_init();
4820}
4821
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004822void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004823 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00004824{
pbrookce1a14d2006-08-07 02:38:06 +00004825 BlockDriverAIOCB *acb;
4826
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004827 acb = g_slice_alloc(aiocb_info->aiocb_size);
4828 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00004829 acb->bs = bs;
4830 acb->cb = cb;
4831 acb->opaque = opaque;
4832 return acb;
4833}
4834
4835void qemu_aio_release(void *p)
4836{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01004837 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004838 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004839}
bellard19cb3732006-08-19 11:45:59 +00004840
4841/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004842/* Coroutine block device emulation */
4843
4844typedef struct CoroutineIOCompletion {
4845 Coroutine *coroutine;
4846 int ret;
4847} CoroutineIOCompletion;
4848
4849static void bdrv_co_io_em_complete(void *opaque, int ret)
4850{
4851 CoroutineIOCompletion *co = opaque;
4852
4853 co->ret = ret;
4854 qemu_coroutine_enter(co->coroutine, NULL);
4855}
4856
4857static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4858 int nb_sectors, QEMUIOVector *iov,
4859 bool is_write)
4860{
4861 CoroutineIOCompletion co = {
4862 .coroutine = qemu_coroutine_self(),
4863 };
4864 BlockDriverAIOCB *acb;
4865
4866 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004867 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4868 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004869 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004870 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4871 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004872 }
4873
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004874 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004875 if (!acb) {
4876 return -EIO;
4877 }
4878 qemu_coroutine_yield();
4879
4880 return co.ret;
4881}
4882
4883static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4884 int64_t sector_num, int nb_sectors,
4885 QEMUIOVector *iov)
4886{
4887 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4888}
4889
4890static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4891 int64_t sector_num, int nb_sectors,
4892 QEMUIOVector *iov)
4893{
4894 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4895}
4896
Paolo Bonzini07f07612011-10-17 12:32:12 +02004897static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004898{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004899 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004900
Paolo Bonzini07f07612011-10-17 12:32:12 +02004901 rwco->ret = bdrv_co_flush(rwco->bs);
4902}
4903
4904int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4905{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004906 int ret;
4907
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004908 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004909 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004910 }
4911
Kevin Wolfca716362011-11-10 18:13:59 +01004912 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004913 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004914 if (bs->drv->bdrv_co_flush_to_os) {
4915 ret = bs->drv->bdrv_co_flush_to_os(bs);
4916 if (ret < 0) {
4917 return ret;
4918 }
4919 }
4920
Kevin Wolfca716362011-11-10 18:13:59 +01004921 /* But don't actually force it to the disk with cache=unsafe */
4922 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004923 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004924 }
4925
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004926 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004927 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004928 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004929 } else if (bs->drv->bdrv_aio_flush) {
4930 BlockDriverAIOCB *acb;
4931 CoroutineIOCompletion co = {
4932 .coroutine = qemu_coroutine_self(),
4933 };
4934
4935 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4936 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004937 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004938 } else {
4939 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004940 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004941 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004942 } else {
4943 /*
4944 * Some block drivers always operate in either writethrough or unsafe
4945 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4946 * know how the server works (because the behaviour is hardcoded or
4947 * depends on server-side configuration), so we can't ensure that
4948 * everything is safe on disk. Returning an error doesn't work because
4949 * that would break guests even if the server operates in writethrough
4950 * mode.
4951 *
4952 * Let's hope the user knows what he's doing.
4953 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004954 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004955 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004956 if (ret < 0) {
4957 return ret;
4958 }
4959
4960 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4961 * in the case of cache=unsafe, so there are no useless flushes.
4962 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004963flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004964 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004965}
4966
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004967void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06004968{
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004969 Error *local_err = NULL;
4970 int ret;
4971
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004972 if (!bs->drv) {
4973 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06004974 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004975
4976 if (bs->drv->bdrv_invalidate_cache) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004977 bs->drv->bdrv_invalidate_cache(bs, &local_err);
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004978 } else if (bs->file) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004979 bdrv_invalidate_cache(bs->file, &local_err);
4980 }
4981 if (local_err) {
4982 error_propagate(errp, local_err);
4983 return;
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004984 }
4985
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004986 ret = refresh_total_sectors(bs, bs->total_sectors);
4987 if (ret < 0) {
4988 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4989 return;
4990 }
Anthony Liguori0f154232011-11-14 15:09:45 -06004991}
4992
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004993void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06004994{
4995 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004996 Error *local_err = NULL;
Anthony Liguori0f154232011-11-14 15:09:45 -06004997
Benoît Canetdc364f42014-01-23 21:31:32 +01004998 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004999 AioContext *aio_context = bdrv_get_aio_context(bs);
5000
5001 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005002 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005003 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005004 if (local_err) {
5005 error_propagate(errp, local_err);
5006 return;
5007 }
Anthony Liguori0f154232011-11-14 15:09:45 -06005008 }
5009}
5010
Benoît Canet07789262012-03-23 08:36:49 +01005011void bdrv_clear_incoming_migration_all(void)
5012{
5013 BlockDriverState *bs;
5014
Benoît Canetdc364f42014-01-23 21:31:32 +01005015 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005016 AioContext *aio_context = bdrv_get_aio_context(bs);
5017
5018 aio_context_acquire(aio_context);
Benoît Canet07789262012-03-23 08:36:49 +01005019 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005020 aio_context_release(aio_context);
Benoît Canet07789262012-03-23 08:36:49 +01005021 }
5022}
5023
Paolo Bonzini07f07612011-10-17 12:32:12 +02005024int bdrv_flush(BlockDriverState *bs)
5025{
5026 Coroutine *co;
5027 RwCo rwco = {
5028 .bs = bs,
5029 .ret = NOT_DONE,
5030 };
5031
5032 if (qemu_in_coroutine()) {
5033 /* Fast-path if already in coroutine context */
5034 bdrv_flush_co_entry(&rwco);
5035 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005036 AioContext *aio_context = bdrv_get_aio_context(bs);
5037
Paolo Bonzini07f07612011-10-17 12:32:12 +02005038 co = qemu_coroutine_create(bdrv_flush_co_entry);
5039 qemu_coroutine_enter(co, &rwco);
5040 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005041 aio_poll(aio_context, true);
Paolo Bonzini07f07612011-10-17 12:32:12 +02005042 }
5043 }
5044
5045 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02005046}
5047
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005048typedef struct DiscardCo {
5049 BlockDriverState *bs;
5050 int64_t sector_num;
5051 int nb_sectors;
5052 int ret;
5053} DiscardCo;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005054static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5055{
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005056 DiscardCo *rwco = opaque;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005057
5058 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5059}
5060
Peter Lieven6f14da52013-10-24 12:06:59 +02005061/* if no limit is specified in the BlockLimits use a default
5062 * of 32768 512-byte sectors (16 MiB) per request.
5063 */
5064#define MAX_DISCARD_DEFAULT 32768
5065
Paolo Bonzini4265d622011-10-17 12:32:14 +02005066int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5067 int nb_sectors)
5068{
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005069 int max_discard;
5070
Paolo Bonzini4265d622011-10-17 12:32:14 +02005071 if (!bs->drv) {
5072 return -ENOMEDIUM;
5073 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5074 return -EIO;
5075 } else if (bs->read_only) {
5076 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01005077 }
5078
Fam Zhenge4654d22013-11-13 18:29:43 +08005079 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01005080
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01005081 /* Do nothing if disabled. */
5082 if (!(bs->open_flags & BDRV_O_UNMAP)) {
5083 return 0;
5084 }
5085
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005086 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
Paolo Bonzini4265d622011-10-17 12:32:14 +02005087 return 0;
5088 }
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005089
5090 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5091 while (nb_sectors > 0) {
5092 int ret;
5093 int num = nb_sectors;
5094
5095 /* align request */
5096 if (bs->bl.discard_alignment &&
5097 num >= bs->bl.discard_alignment &&
5098 sector_num % bs->bl.discard_alignment) {
5099 if (num > bs->bl.discard_alignment) {
5100 num = bs->bl.discard_alignment;
5101 }
5102 num -= sector_num % bs->bl.discard_alignment;
5103 }
5104
5105 /* limit request size */
5106 if (num > max_discard) {
5107 num = max_discard;
5108 }
5109
5110 if (bs->drv->bdrv_co_discard) {
5111 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5112 } else {
5113 BlockDriverAIOCB *acb;
5114 CoroutineIOCompletion co = {
5115 .coroutine = qemu_coroutine_self(),
5116 };
5117
5118 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5119 bdrv_co_io_em_complete, &co);
5120 if (acb == NULL) {
5121 return -EIO;
5122 } else {
5123 qemu_coroutine_yield();
5124 ret = co.ret;
5125 }
5126 }
Paolo Bonzini7ce21012013-11-22 13:39:47 +01005127 if (ret && ret != -ENOTSUP) {
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005128 return ret;
5129 }
5130
5131 sector_num += num;
5132 nb_sectors -= num;
5133 }
5134 return 0;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005135}
5136
5137int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5138{
5139 Coroutine *co;
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005140 DiscardCo rwco = {
Paolo Bonzini4265d622011-10-17 12:32:14 +02005141 .bs = bs,
5142 .sector_num = sector_num,
5143 .nb_sectors = nb_sectors,
5144 .ret = NOT_DONE,
5145 };
5146
5147 if (qemu_in_coroutine()) {
5148 /* Fast-path if already in coroutine context */
5149 bdrv_discard_co_entry(&rwco);
5150 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005151 AioContext *aio_context = bdrv_get_aio_context(bs);
5152
Paolo Bonzini4265d622011-10-17 12:32:14 +02005153 co = qemu_coroutine_create(bdrv_discard_co_entry);
5154 qemu_coroutine_enter(co, &rwco);
5155 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005156 aio_poll(aio_context, true);
Paolo Bonzini4265d622011-10-17 12:32:14 +02005157 }
5158 }
5159
5160 return rwco.ret;
5161}
5162
Kevin Wolff9f05dc2011-07-15 13:50:26 +02005163/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00005164/* removable device support */
5165
5166/**
5167 * Return TRUE if the media is present
5168 */
5169int bdrv_is_inserted(BlockDriverState *bs)
5170{
5171 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005172
bellard19cb3732006-08-19 11:45:59 +00005173 if (!drv)
5174 return 0;
5175 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005176 return 1;
5177 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00005178}
5179
5180/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02005181 * Return whether the media changed since the last call to this
5182 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00005183 */
5184int bdrv_media_changed(BlockDriverState *bs)
5185{
5186 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005187
Markus Armbruster8e49ca42011-08-03 15:08:08 +02005188 if (drv && drv->bdrv_media_changed) {
5189 return drv->bdrv_media_changed(bs);
5190 }
5191 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00005192}
5193
5194/**
5195 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5196 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02005197void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00005198{
5199 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005200
Markus Armbruster822e1cd2011-07-20 18:23:42 +02005201 if (drv && drv->bdrv_eject) {
5202 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00005203 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02005204
5205 if (bs->device_name[0] != '\0') {
5206 bdrv_emit_qmp_eject_event(bs, eject_flag);
5207 }
bellard19cb3732006-08-19 11:45:59 +00005208}
5209
bellard19cb3732006-08-19 11:45:59 +00005210/**
5211 * Lock or unlock the media (if it is locked, the user won't be able
5212 * to eject it manually).
5213 */
Markus Armbruster025e8492011-09-06 18:58:47 +02005214void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00005215{
5216 BlockDriver *drv = bs->drv;
5217
Markus Armbruster025e8492011-09-06 18:58:47 +02005218 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01005219
Markus Armbruster025e8492011-09-06 18:58:47 +02005220 if (drv && drv->bdrv_lock_medium) {
5221 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00005222 }
5223}
ths985a03b2007-12-24 16:10:43 +00005224
5225/* needed for generic scsi interface */
5226
5227int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5228{
5229 BlockDriver *drv = bs->drv;
5230
5231 if (drv && drv->bdrv_ioctl)
5232 return drv->bdrv_ioctl(bs, req, buf);
5233 return -ENOTSUP;
5234}
aliguori7d780662009-03-12 19:57:08 +00005235
aliguori221f7152009-03-28 17:28:41 +00005236BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5237 unsigned long int req, void *buf,
5238 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00005239{
aliguori221f7152009-03-28 17:28:41 +00005240 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00005241
aliguori221f7152009-03-28 17:28:41 +00005242 if (drv && drv->bdrv_aio_ioctl)
5243 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5244 return NULL;
aliguori7d780662009-03-12 19:57:08 +00005245}
aliguorie268ca52009-04-22 20:20:00 +00005246
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01005247void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
Markus Armbruster7b6f9302011-09-06 18:58:56 +02005248{
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01005249 bs->guest_block_size = align;
Markus Armbruster7b6f9302011-09-06 18:58:56 +02005250}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005251
aliguorie268ca52009-04-22 20:20:00 +00005252void *qemu_blockalign(BlockDriverState *bs, size_t size)
5253{
Kevin Wolf339064d2013-11-28 10:23:32 +01005254 return qemu_memalign(bdrv_opt_mem_align(bs), size);
aliguorie268ca52009-04-22 20:20:00 +00005255}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005256
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005257/*
5258 * Check if all memory in this vector is sector aligned.
5259 */
5260bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5261{
5262 int i;
Kevin Wolf339064d2013-11-28 10:23:32 +01005263 size_t alignment = bdrv_opt_mem_align(bs);
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005264
5265 for (i = 0; i < qiov->niov; i++) {
Kevin Wolf339064d2013-11-28 10:23:32 +01005266 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005267 return false;
5268 }
Kevin Wolf339064d2013-11-28 10:23:32 +01005269 if (qiov->iov[i].iov_len % alignment) {
Kevin Wolf1ff735b2013-12-05 13:01:46 +01005270 return false;
5271 }
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005272 }
5273
5274 return true;
5275}
5276
Fam Zhengb8afb522014-04-16 09:34:30 +08005277BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5278 Error **errp)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005279{
5280 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08005281 BdrvDirtyBitmap *bitmap;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01005282
Paolo Bonzini50717e92013-01-21 17:09:45 +01005283 assert((granularity & (granularity - 1)) == 0);
5284
Fam Zhenge4654d22013-11-13 18:29:43 +08005285 granularity >>= BDRV_SECTOR_BITS;
5286 assert(granularity);
Fam Zhengb8afb522014-04-16 09:34:30 +08005287 bitmap_size = bdrv_getlength(bs);
5288 if (bitmap_size < 0) {
5289 error_setg_errno(errp, -bitmap_size, "could not get length of device");
5290 errno = -bitmap_size;
5291 return NULL;
5292 }
5293 bitmap_size >>= BDRV_SECTOR_BITS;
Fam Zhenge4654d22013-11-13 18:29:43 +08005294 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5295 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5296 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5297 return bitmap;
5298}
5299
5300void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5301{
5302 BdrvDirtyBitmap *bm, *next;
5303 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5304 if (bm == bitmap) {
5305 QLIST_REMOVE(bitmap, list);
5306 hbitmap_free(bitmap->bitmap);
5307 g_free(bitmap);
5308 return;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01005309 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005310 }
5311}
5312
Fam Zheng21b56832013-11-13 18:29:44 +08005313BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5314{
5315 BdrvDirtyBitmap *bm;
5316 BlockDirtyInfoList *list = NULL;
5317 BlockDirtyInfoList **plist = &list;
5318
5319 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5320 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5321 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5322 info->count = bdrv_get_dirty_count(bs, bm);
5323 info->granularity =
5324 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5325 entry->value = info;
5326 *plist = entry;
5327 plist = &entry->next;
5328 }
5329
5330 return list;
5331}
5332
Fam Zhenge4654d22013-11-13 18:29:43 +08005333int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005334{
Fam Zhenge4654d22013-11-13 18:29:43 +08005335 if (bitmap) {
5336 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005337 } else {
5338 return 0;
5339 }
5340}
5341
Fam Zhenge4654d22013-11-13 18:29:43 +08005342void bdrv_dirty_iter_init(BlockDriverState *bs,
5343 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02005344{
Fam Zhenge4654d22013-11-13 18:29:43 +08005345 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02005346}
5347
5348void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5349 int nr_sectors)
5350{
Fam Zhenge4654d22013-11-13 18:29:43 +08005351 BdrvDirtyBitmap *bitmap;
5352 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5353 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01005354 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02005355}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005356
Fam Zhenge4654d22013-11-13 18:29:43 +08005357void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5358{
5359 BdrvDirtyBitmap *bitmap;
5360 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5361 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5362 }
5363}
5364
5365int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5366{
5367 return hbitmap_count(bitmap->bitmap);
5368}
5369
Fam Zheng9fcb0252013-08-23 09:14:46 +08005370/* Get a reference to bs */
5371void bdrv_ref(BlockDriverState *bs)
5372{
5373 bs->refcnt++;
5374}
5375
5376/* Release a previously grabbed reference to bs.
5377 * If after releasing, reference count is zero, the BlockDriverState is
5378 * deleted. */
5379void bdrv_unref(BlockDriverState *bs)
5380{
5381 assert(bs->refcnt > 0);
5382 if (--bs->refcnt == 0) {
5383 bdrv_delete(bs);
5384 }
5385}
5386
Fam Zhengfbe40ff2014-05-23 21:29:42 +08005387struct BdrvOpBlocker {
5388 Error *reason;
5389 QLIST_ENTRY(BdrvOpBlocker) list;
5390};
5391
5392bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5393{
5394 BdrvOpBlocker *blocker;
5395 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5396 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5397 blocker = QLIST_FIRST(&bs->op_blockers[op]);
5398 if (errp) {
5399 error_setg(errp, "Device '%s' is busy: %s",
5400 bs->device_name, error_get_pretty(blocker->reason));
5401 }
5402 return true;
5403 }
5404 return false;
5405}
5406
5407void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5408{
5409 BdrvOpBlocker *blocker;
5410 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5411
5412 blocker = g_malloc0(sizeof(BdrvOpBlocker));
5413 blocker->reason = reason;
5414 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5415}
5416
5417void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5418{
5419 BdrvOpBlocker *blocker, *next;
5420 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5421 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5422 if (blocker->reason == reason) {
5423 QLIST_REMOVE(blocker, list);
5424 g_free(blocker);
5425 }
5426 }
5427}
5428
5429void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5430{
5431 int i;
5432 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5433 bdrv_op_block(bs, i, reason);
5434 }
5435}
5436
5437void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5438{
5439 int i;
5440 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5441 bdrv_op_unblock(bs, i, reason);
5442 }
5443}
5444
5445bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5446{
5447 int i;
5448
5449 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5450 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5451 return false;
5452 }
5453 }
5454 return true;
5455}
5456
Luiz Capitulino28a72822011-09-26 17:43:50 -03005457void bdrv_iostatus_enable(BlockDriverState *bs)
5458{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005459 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005460 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005461}
5462
5463/* The I/O status is only enabled if the drive explicitly
5464 * enables it _and_ the VM is configured to stop on errors */
5465bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5466{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005467 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02005468 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5469 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5470 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03005471}
5472
5473void bdrv_iostatus_disable(BlockDriverState *bs)
5474{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005475 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005476}
5477
5478void bdrv_iostatus_reset(BlockDriverState *bs)
5479{
5480 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005481 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02005482 if (bs->job) {
5483 block_job_iostatus_reset(bs->job);
5484 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03005485 }
5486}
5487
Luiz Capitulino28a72822011-09-26 17:43:50 -03005488void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5489{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02005490 assert(bdrv_iostatus_is_enabled(bs));
5491 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005492 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5493 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005494 }
5495}
5496
Christoph Hellwiga597e792011-08-25 08:26:01 +02005497void
5498bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5499 enum BlockAcctType type)
5500{
5501 assert(type < BDRV_MAX_IOTYPE);
5502
5503 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005504 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02005505 cookie->type = type;
5506}
5507
5508void
5509bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5510{
5511 assert(cookie->type < BDRV_MAX_IOTYPE);
5512
5513 bs->nr_bytes[cookie->type] += cookie->bytes;
5514 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005515 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02005516}
5517
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005518void bdrv_img_create(const char *filename, const char *fmt,
5519 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005520 char *options, uint64_t img_size, int flags,
5521 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005522{
5523 QEMUOptionParameter *param = NULL, *create_options = NULL;
Kevin Wolfd2208942011-06-01 14:03:31 +02005524 QEMUOptionParameter *backing_fmt, *backing_file, *size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005525 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005526 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02005527 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005528 int ret = 0;
5529
5530 /* Find driver and parse its options */
5531 drv = bdrv_find_format(fmt);
5532 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005533 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005534 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005535 }
5536
Kevin Wolf98289622013-07-10 15:47:39 +02005537 proto_drv = bdrv_find_protocol(filename, true);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005538 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005539 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005540 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005541 }
5542
5543 create_options = append_option_parameters(create_options,
5544 drv->create_options);
5545 create_options = append_option_parameters(create_options,
5546 proto_drv->create_options);
5547
5548 /* Create parameter list with default values */
5549 param = parse_option_parameters("", create_options, param);
5550
5551 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
5552
5553 /* Parse -o options */
5554 if (options) {
5555 param = parse_option_parameters(options, create_options, param);
5556 if (param == NULL) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005557 error_setg(errp, "Invalid options for file format '%s'.", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005558 goto out;
5559 }
5560 }
5561
5562 if (base_filename) {
5563 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
5564 base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005565 error_setg(errp, "Backing file not supported for file format '%s'",
5566 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005567 goto out;
5568 }
5569 }
5570
5571 if (base_fmt) {
5572 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005573 error_setg(errp, "Backing file format not supported for file "
5574 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005575 goto out;
5576 }
5577 }
5578
Jes Sorensen792da932010-12-16 13:52:17 +01005579 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
5580 if (backing_file && backing_file->value.s) {
5581 if (!strcmp(filename, backing_file->value.s)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005582 error_setg(errp, "Error: Trying to create an image with the "
5583 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01005584 goto out;
5585 }
5586 }
5587
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005588 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
5589 if (backing_fmt && backing_fmt->value.s) {
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005590 backing_drv = bdrv_find_format(backing_fmt->value.s);
5591 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005592 error_setg(errp, "Unknown backing file format '%s'",
5593 backing_fmt->value.s);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005594 goto out;
5595 }
5596 }
5597
5598 // The size for the image must always be specified, with one exception:
5599 // If we are using a backing file, we can obtain the size from there
Kevin Wolfd2208942011-06-01 14:03:31 +02005600 size = get_option_parameter(param, BLOCK_OPT_SIZE);
5601 if (size && size->value.n == -1) {
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005602 if (backing_file && backing_file->value.s) {
Max Reitz66f6b812013-12-03 14:57:52 +01005603 BlockDriverState *bs;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005604 uint64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005605 char buf[32];
Paolo Bonzini63090da2012-04-12 14:01:03 +02005606 int back_flags;
5607
5608 /* backing files always opened read-only */
5609 back_flags =
5610 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005611
Max Reitzf67503e2014-02-18 18:33:05 +01005612 bs = NULL;
Max Reitzddf56362014-02-18 18:33:06 +01005613 ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02005614 backing_drv, &local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005615 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02005616 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5617 backing_file->value.s,
5618 error_get_pretty(local_err));
5619 error_free(local_err);
5620 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005621 goto out;
5622 }
5623 bdrv_get_geometry(bs, &size);
5624 size *= 512;
5625
5626 snprintf(buf, sizeof(buf), "%" PRId64, size);
5627 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
Max Reitz66f6b812013-12-03 14:57:52 +01005628
5629 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005630 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005631 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005632 goto out;
5633 }
5634 }
5635
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005636 if (!quiet) {
5637 printf("Formatting '%s', fmt=%s ", filename, fmt);
5638 print_option_parameters(param);
5639 puts("");
5640 }
Max Reitzcc84d902013-09-06 17:14:26 +02005641 ret = bdrv_create(drv, filename, param, &local_err);
5642 if (ret == -EFBIG) {
5643 /* This is generally a better message than whatever the driver would
5644 * deliver (especially because of the cluster_size_hint), since that
5645 * is most probably not much different from "image too large". */
5646 const char *cluster_size_hint = "";
5647 if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {
5648 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005649 }
Max Reitzcc84d902013-09-06 17:14:26 +02005650 error_setg(errp, "The image size is too large for file format '%s'"
5651 "%s", fmt, cluster_size_hint);
5652 error_free(local_err);
5653 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005654 }
5655
5656out:
5657 free_option_parameters(create_options);
5658 free_option_parameters(param);
5659
Markus Armbruster84d18f02014-01-30 15:07:28 +01005660 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +02005661 error_propagate(errp, local_err);
5662 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005663}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01005664
5665AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5666{
5667 /* Currently BlockDriverState always uses the main loop AioContext */
5668 return qemu_get_aio_context();
5669}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02005670
5671void bdrv_add_before_write_notifier(BlockDriverState *bs,
5672 NotifierWithReturn *notifier)
5673{
5674 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5675}
Max Reitz6f176b42013-09-03 10:09:50 +02005676
5677int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)
5678{
5679 if (bs->drv->bdrv_amend_options == NULL) {
5680 return -ENOTSUP;
5681 }
5682 return bs->drv->bdrv_amend_options(bs, options);
5683}
Benoît Canetf6186f42013-10-02 14:33:48 +02005684
Benoît Canetb5042a32014-03-03 19:11:34 +01005685/* This function will be called by the bdrv_recurse_is_first_non_filter method
5686 * of block filter and by bdrv_is_first_non_filter.
5687 * It is used to test if the given bs is the candidate or recurse more in the
5688 * node graph.
Benoît Canet212a5a82014-01-23 21:31:36 +01005689 */
Benoît Canet212a5a82014-01-23 21:31:36 +01005690bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5691 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02005692{
Benoît Canetb5042a32014-03-03 19:11:34 +01005693 /* return false if basic checks fails */
5694 if (!bs || !bs->drv) {
5695 return false;
5696 }
5697
5698 /* the code reached a non block filter driver -> check if the bs is
5699 * the same as the candidate. It's the recursion termination condition.
5700 */
5701 if (!bs->drv->is_filter) {
5702 return bs == candidate;
5703 }
5704 /* Down this path the driver is a block filter driver */
5705
5706 /* If the block filter recursion method is defined use it to recurse down
5707 * the node graph.
5708 */
5709 if (bs->drv->bdrv_recurse_is_first_non_filter) {
Benoît Canet212a5a82014-01-23 21:31:36 +01005710 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5711 }
5712
Benoît Canetb5042a32014-03-03 19:11:34 +01005713 /* the driver is a block filter but don't allow to recurse -> return false
5714 */
5715 return false;
Benoît Canet212a5a82014-01-23 21:31:36 +01005716}
5717
5718/* This function checks if the candidate is the first non filter bs down it's
5719 * bs chain. Since we don't have pointers to parents it explore all bs chains
5720 * from the top. Some filters can choose not to pass down the recursion.
5721 */
5722bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5723{
5724 BlockDriverState *bs;
5725
5726 /* walk down the bs forest recursively */
5727 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5728 bool perm;
5729
Benoît Canetb5042a32014-03-03 19:11:34 +01005730 /* try to recurse in this top level bs */
Kevin Wolfe6dc8a12014-02-04 11:45:31 +01005731 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
Benoît Canet212a5a82014-01-23 21:31:36 +01005732
5733 /* candidate is the first non filter */
5734 if (perm) {
5735 return true;
5736 }
5737 }
5738
5739 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02005740}