blob: 43abe96db69e88648a991373fc453f679d238461 [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,
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +0200182 bdrv_get_aio_context(bs),
Benoît Canetcc0681c2013-09-02 14:14:39 +0200183 QEMU_CLOCK_VIRTUAL,
184 bdrv_throttle_read_timer_cb,
185 bdrv_throttle_write_timer_cb,
186 bs);
Zhi Yong Wu0563e192011-11-03 16:57:25 +0800187 bs->io_limits_enabled = true;
188}
189
Benoît Canetcc0681c2013-09-02 14:14:39 +0200190/* This function makes an IO wait if needed
191 *
192 * @nb_sectors: the number of sectors of the IO
193 * @is_write: is the IO a write
194 */
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800195static void bdrv_io_limits_intercept(BlockDriverState *bs,
Kevin Wolfd5103582014-01-16 13:29:10 +0100196 unsigned int bytes,
Benoît Canetcc0681c2013-09-02 14:14:39 +0200197 bool is_write)
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800198{
Benoît Canetcc0681c2013-09-02 14:14:39 +0200199 /* does this io must wait */
200 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800201
Benoît Canetcc0681c2013-09-02 14:14:39 +0200202 /* if must wait or any request of this type throttled queue the IO */
203 if (must_wait ||
204 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
205 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800206 }
207
Benoît Canetcc0681c2013-09-02 14:14:39 +0200208 /* the IO will be executed, do the accounting */
Kevin Wolfd5103582014-01-16 13:29:10 +0100209 throttle_account(&bs->throttle_state, is_write, bytes);
210
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800211
Benoît Canetcc0681c2013-09-02 14:14:39 +0200212 /* if the next request must wait -> do nothing */
213 if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
214 return;
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800215 }
216
Benoît Canetcc0681c2013-09-02 14:14:39 +0200217 /* else queue next request for execution */
218 qemu_co_queue_next(&bs->throttled_reqs[is_write]);
Zhi Yong Wu98f90db2011-11-08 13:00:14 +0800219}
220
Kevin Wolf339064d2013-11-28 10:23:32 +0100221size_t bdrv_opt_mem_align(BlockDriverState *bs)
222{
223 if (!bs || !bs->drv) {
224 /* 4k should be on the safe side */
225 return 4096;
226 }
227
228 return bs->bl.opt_mem_alignment;
229}
230
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000231/* check if the path starts with "<protocol>:" */
232static int path_has_protocol(const char *path)
233{
Paolo Bonzini947995c2012-05-08 16:51:48 +0200234 const char *p;
235
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000236#ifdef _WIN32
237 if (is_windows_drive(path) ||
238 is_windows_drive_prefix(path)) {
239 return 0;
240 }
Paolo Bonzini947995c2012-05-08 16:51:48 +0200241 p = path + strcspn(path, ":/\\");
242#else
243 p = path + strcspn(path, ":/");
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000244#endif
245
Paolo Bonzini947995c2012-05-08 16:51:48 +0200246 return *p == ':';
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000247}
248
bellard83f64092006-08-01 16:21:11 +0000249int path_is_absolute(const char *path)
250{
bellard21664422007-01-07 18:22:37 +0000251#ifdef _WIN32
252 /* specific case for names like: "\\.\d:" */
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200253 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
bellard21664422007-01-07 18:22:37 +0000254 return 1;
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200255 }
256 return (*path == '/' || *path == '\\');
bellard3b9f94e2007-01-07 17:27:07 +0000257#else
Paolo Bonzinif53f4da2012-05-08 16:51:47 +0200258 return (*path == '/');
bellard3b9f94e2007-01-07 17:27:07 +0000259#endif
bellard83f64092006-08-01 16:21:11 +0000260}
261
262/* if filename is absolute, just copy it to dest. Otherwise, build a
263 path to it by considering it is relative to base_path. URL are
264 supported. */
265void path_combine(char *dest, int dest_size,
266 const char *base_path,
267 const char *filename)
268{
269 const char *p, *p1;
270 int len;
271
272 if (dest_size <= 0)
273 return;
274 if (path_is_absolute(filename)) {
275 pstrcpy(dest, dest_size, filename);
276 } else {
277 p = strchr(base_path, ':');
278 if (p)
279 p++;
280 else
281 p = base_path;
bellard3b9f94e2007-01-07 17:27:07 +0000282 p1 = strrchr(base_path, '/');
283#ifdef _WIN32
284 {
285 const char *p2;
286 p2 = strrchr(base_path, '\\');
287 if (!p1 || p2 > p1)
288 p1 = p2;
289 }
290#endif
bellard83f64092006-08-01 16:21:11 +0000291 if (p1)
292 p1++;
293 else
294 p1 = base_path;
295 if (p1 > p)
296 p = p1;
297 len = p - base_path;
298 if (len > dest_size - 1)
299 len = dest_size - 1;
300 memcpy(dest, base_path, len);
301 dest[len] = '\0';
302 pstrcat(dest, dest_size, filename);
303 }
304}
305
Paolo Bonzinidc5a1372012-05-08 16:51:50 +0200306void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
307{
308 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
309 pstrcpy(dest, sz, bs->backing_file);
310 } else {
311 path_combine(dest, sz, bs->filename, bs->backing_file);
312 }
313}
314
Anthony Liguori5efa9d52009-05-09 17:03:42 -0500315void bdrv_register(BlockDriver *bdrv)
bellardea2384d2004-08-01 21:59:26 +0000316{
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +0100317 /* Block drivers without coroutine functions need emulation */
318 if (!bdrv->bdrv_co_readv) {
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200319 bdrv->bdrv_co_readv = bdrv_co_readv_em;
320 bdrv->bdrv_co_writev = bdrv_co_writev_em;
321
Stefan Hajnoczif8c35c12011-10-13 21:09:31 +0100322 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
323 * the block driver lacks aio we need to emulate that too.
324 */
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200325 if (!bdrv->bdrv_aio_readv) {
326 /* add AIO emulation layer */
327 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
328 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
Kevin Wolff9f05dc2011-07-15 13:50:26 +0200329 }
bellard83f64092006-08-01 16:21:11 +0000330 }
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +0200331
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100332 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
bellardea2384d2004-08-01 21:59:26 +0000333}
bellardb3380822004-03-14 21:38:54 +0000334
335/* create a new block device (by default it is empty) */
Kevin Wolf98522f62014-04-17 13:16:01 +0200336BlockDriverState *bdrv_new(const char *device_name, Error **errp)
bellardfc01f7e2003-06-30 10:03:06 +0000337{
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +0100338 BlockDriverState *bs;
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800339 int i;
bellardb3380822004-03-14 21:38:54 +0000340
Kevin Wolff2d953e2014-04-17 13:27:05 +0200341 if (bdrv_find(device_name)) {
342 error_setg(errp, "Device with id '%s' already exists",
343 device_name);
344 return NULL;
345 }
346 if (bdrv_find_node(device_name)) {
347 error_setg(errp, "Device with node-name '%s' already exists",
348 device_name);
349 return NULL;
350 }
351
Anthony Liguori7267c092011-08-20 22:09:37 -0500352 bs = g_malloc0(sizeof(BlockDriverState));
Fam Zhenge4654d22013-11-13 18:29:43 +0800353 QLIST_INIT(&bs->dirty_bitmaps);
bellardb3380822004-03-14 21:38:54 +0000354 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
bellardea2384d2004-08-01 21:59:26 +0000355 if (device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +0100356 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
bellardea2384d2004-08-01 21:59:26 +0000357 }
Fam Zhengfbe40ff2014-05-23 21:29:42 +0800358 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
359 QLIST_INIT(&bs->op_blockers[i]);
360 }
Luiz Capitulino28a72822011-09-26 17:43:50 -0300361 bdrv_iostatus_disable(bs);
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200362 notifier_list_init(&bs->close_notifiers);
Stefan Hajnoczid616b222013-06-24 17:13:10 +0200363 notifier_with_return_list_init(&bs->before_write_notifiers);
Benoît Canetcc0681c2013-09-02 14:14:39 +0200364 qemu_co_queue_init(&bs->throttled_reqs[0]);
365 qemu_co_queue_init(&bs->throttled_reqs[1]);
Fam Zheng9fcb0252013-08-23 09:14:46 +0800366 bs->refcnt = 1;
Stefan Hajnoczidcd04222014-05-08 16:34:37 +0200367 bs->aio_context = qemu_get_aio_context();
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200368
bellardb3380822004-03-14 21:38:54 +0000369 return bs;
370}
371
Paolo Bonzinid7d512f2012-08-23 11:20:36 +0200372void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
373{
374 notifier_list_add(&bs->close_notifiers, notify);
375}
376
bellardea2384d2004-08-01 21:59:26 +0000377BlockDriver *bdrv_find_format(const char *format_name)
378{
379 BlockDriver *drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100380 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
381 if (!strcmp(drv1->format_name, format_name)) {
bellardea2384d2004-08-01 21:59:26 +0000382 return drv1;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100383 }
bellardea2384d2004-08-01 21:59:26 +0000384 }
385 return NULL;
386}
387
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800388static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100389{
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800390 static const char *whitelist_rw[] = {
391 CONFIG_BDRV_RW_WHITELIST
392 };
393 static const char *whitelist_ro[] = {
394 CONFIG_BDRV_RO_WHITELIST
Markus Armbrustereb852012009-10-27 18:41:44 +0100395 };
396 const char **p;
397
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800398 if (!whitelist_rw[0] && !whitelist_ro[0]) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100399 return 1; /* no whitelist, anything goes */
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800400 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100401
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800402 for (p = whitelist_rw; *p; p++) {
Markus Armbrustereb852012009-10-27 18:41:44 +0100403 if (!strcmp(drv->format_name, *p)) {
404 return 1;
405 }
406 }
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800407 if (read_only) {
408 for (p = whitelist_ro; *p; p++) {
409 if (!strcmp(drv->format_name, *p)) {
410 return 1;
411 }
412 }
413 }
Markus Armbrustereb852012009-10-27 18:41:44 +0100414 return 0;
415}
416
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800417BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
418 bool read_only)
Markus Armbrustereb852012009-10-27 18:41:44 +0100419{
420 BlockDriver *drv = bdrv_find_format(format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800421 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
Markus Armbrustereb852012009-10-27 18:41:44 +0100422}
423
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800424typedef struct CreateCo {
425 BlockDriver *drv;
426 char *filename;
Chunyan Liu83d05212014-06-05 17:20:51 +0800427 QemuOpts *opts;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800428 int ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200429 Error *err;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800430} CreateCo;
431
432static void coroutine_fn bdrv_create_co_entry(void *opaque)
433{
Max Reitzcc84d902013-09-06 17:14:26 +0200434 Error *local_err = NULL;
435 int ret;
436
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800437 CreateCo *cco = opaque;
438 assert(cco->drv);
439
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800440 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100441 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200442 error_propagate(&cco->err, local_err);
443 }
444 cco->ret = ret;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800445}
446
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200447int bdrv_create(BlockDriver *drv, const char* filename,
Chunyan Liu83d05212014-06-05 17:20:51 +0800448 QemuOpts *opts, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000449{
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800450 int ret;
Kevin Wolf0e7e1982009-05-18 16:42:10 +0200451
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800452 Coroutine *co;
453 CreateCo cco = {
454 .drv = drv,
455 .filename = g_strdup(filename),
Chunyan Liu83d05212014-06-05 17:20:51 +0800456 .opts = opts,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800457 .ret = NOT_DONE,
Max Reitzcc84d902013-09-06 17:14:26 +0200458 .err = NULL,
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800459 };
460
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800461 if (!drv->bdrv_create) {
Max Reitzcc84d902013-09-06 17:14:26 +0200462 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300463 ret = -ENOTSUP;
464 goto out;
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800465 }
466
467 if (qemu_in_coroutine()) {
468 /* Fast-path if already in coroutine context */
469 bdrv_create_co_entry(&cco);
470 } else {
471 co = qemu_coroutine_create(bdrv_create_co_entry);
472 qemu_coroutine_enter(co, &cco);
473 while (cco.ret == NOT_DONE) {
474 qemu_aio_wait();
475 }
476 }
477
478 ret = cco.ret;
Max Reitzcc84d902013-09-06 17:14:26 +0200479 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100480 if (cco.err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200481 error_propagate(errp, cco.err);
482 } else {
483 error_setg_errno(errp, -ret, "Could not create image");
484 }
485 }
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800486
Luiz Capitulino80168bf2012-10-17 16:45:25 -0300487out:
488 g_free(cco.filename);
Zhi Yong Wu5b7e1542012-05-07 16:50:42 +0800489 return ret;
bellardea2384d2004-08-01 21:59:26 +0000490}
491
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800492int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200493{
494 BlockDriver *drv;
Max Reitzcc84d902013-09-06 17:14:26 +0200495 Error *local_err = NULL;
496 int ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200497
Kevin Wolf98289622013-07-10 15:47:39 +0200498 drv = bdrv_find_protocol(filename, true);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200499 if (drv == NULL) {
Max Reitzcc84d902013-09-06 17:14:26 +0200500 error_setg(errp, "Could not find protocol for file '%s'", filename);
Stefan Hajnoczi16905d72010-11-30 15:14:14 +0000501 return -ENOENT;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200502 }
503
Chunyan Liuc282e1f2014-06-05 17:21:11 +0800504 ret = bdrv_create(drv, filename, opts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100505 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +0200506 error_propagate(errp, local_err);
507 }
508 return ret;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200509}
510
Kevin Wolf355ef4a2013-12-11 20:14:09 +0100511int bdrv_refresh_limits(BlockDriverState *bs)
Kevin Wolfd34682c2013-12-11 19:26:16 +0100512{
513 BlockDriver *drv = bs->drv;
514
515 memset(&bs->bl, 0, sizeof(bs->bl));
516
Kevin Wolf466ad822013-12-11 19:50:32 +0100517 if (!drv) {
518 return 0;
519 }
520
521 /* Take some limits from the children as a default */
522 if (bs->file) {
523 bdrv_refresh_limits(bs->file);
524 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
Kevin Wolf339064d2013-11-28 10:23:32 +0100525 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
526 } else {
527 bs->bl.opt_mem_alignment = 512;
Kevin Wolf466ad822013-12-11 19:50:32 +0100528 }
529
530 if (bs->backing_hd) {
531 bdrv_refresh_limits(bs->backing_hd);
532 bs->bl.opt_transfer_length =
533 MAX(bs->bl.opt_transfer_length,
534 bs->backing_hd->bl.opt_transfer_length);
Kevin Wolf339064d2013-11-28 10:23:32 +0100535 bs->bl.opt_mem_alignment =
536 MAX(bs->bl.opt_mem_alignment,
537 bs->backing_hd->bl.opt_mem_alignment);
Kevin Wolf466ad822013-12-11 19:50:32 +0100538 }
539
540 /* Then let the driver override it */
541 if (drv->bdrv_refresh_limits) {
Kevin Wolfd34682c2013-12-11 19:26:16 +0100542 return drv->bdrv_refresh_limits(bs);
543 }
544
545 return 0;
546}
547
Jim Meyeringeba25052012-05-28 09:27:54 +0200548/*
549 * Create a uniquely-named empty temporary file.
550 * Return 0 upon success, otherwise a negative errno value.
551 */
552int get_tmp_filename(char *filename, int size)
553{
bellardd5249392004-08-03 21:14:23 +0000554#ifdef _WIN32
bellard3b9f94e2007-01-07 17:27:07 +0000555 char temp_dir[MAX_PATH];
Jim Meyeringeba25052012-05-28 09:27:54 +0200556 /* GetTempFileName requires that its output buffer (4th param)
557 have length MAX_PATH or greater. */
558 assert(size >= MAX_PATH);
559 return (GetTempPath(MAX_PATH, temp_dir)
560 && GetTempFileName(temp_dir, "qem", 0, filename)
561 ? 0 : -GetLastError());
bellardd5249392004-08-03 21:14:23 +0000562#else
bellardea2384d2004-08-01 21:59:26 +0000563 int fd;
blueswir17ccfb2e2008-09-14 06:45:34 +0000564 const char *tmpdir;
aurel320badc1e2008-03-10 00:05:34 +0000565 tmpdir = getenv("TMPDIR");
Amit Shah69bef792014-02-26 15:12:37 +0530566 if (!tmpdir) {
567 tmpdir = "/var/tmp";
568 }
Jim Meyeringeba25052012-05-28 09:27:54 +0200569 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
570 return -EOVERFLOW;
571 }
bellardea2384d2004-08-01 21:59:26 +0000572 fd = mkstemp(filename);
Dunrong Huangfe235a02012-09-05 21:26:22 +0800573 if (fd < 0) {
574 return -errno;
575 }
576 if (close(fd) != 0) {
577 unlink(filename);
Jim Meyeringeba25052012-05-28 09:27:54 +0200578 return -errno;
579 }
580 return 0;
bellardd5249392004-08-03 21:14:23 +0000581#endif
Jim Meyeringeba25052012-05-28 09:27:54 +0200582}
bellardea2384d2004-08-01 21:59:26 +0000583
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200584/*
585 * Detect host devices. By convention, /dev/cdrom[N] is always
586 * recognized as a host CDROM.
587 */
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200588static BlockDriver *find_hdev_driver(const char *filename)
589{
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200590 int score_max = 0, score;
591 BlockDriver *drv = NULL, *d;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200592
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100593 QLIST_FOREACH(d, &bdrv_drivers, list) {
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200594 if (d->bdrv_probe_device) {
595 score = d->bdrv_probe_device(filename);
596 if (score > score_max) {
597 score_max = score;
598 drv = d;
599 }
600 }
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200601 }
602
Christoph Hellwig508c7cb2009-06-15 14:04:22 +0200603 return drv;
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200604}
Christoph Hellwigf3a5d3f2009-06-15 13:55:19 +0200605
Kevin Wolf98289622013-07-10 15:47:39 +0200606BlockDriver *bdrv_find_protocol(const char *filename,
607 bool allow_protocol_prefix)
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200608{
609 BlockDriver *drv1;
610 char protocol[128];
611 int len;
612 const char *p;
613
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200614 /* TODO Drivers without bdrv_file_open must be specified explicitly */
615
Christoph Hellwig39508e72010-06-23 12:25:17 +0200616 /*
617 * XXX(hch): we really should not let host device detection
618 * override an explicit protocol specification, but moving this
619 * later breaks access to device names with colons in them.
620 * Thanks to the brain-dead persistent naming schemes on udev-
621 * based Linux systems those actually are quite common.
622 */
623 drv1 = find_hdev_driver(filename);
624 if (drv1) {
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200625 return drv1;
626 }
Christoph Hellwig39508e72010-06-23 12:25:17 +0200627
Kevin Wolf98289622013-07-10 15:47:39 +0200628 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
Christoph Hellwig39508e72010-06-23 12:25:17 +0200629 return bdrv_find_format("file");
630 }
Kevin Wolf98289622013-07-10 15:47:39 +0200631
Stefan Hajnoczi9e0b22f2010-12-09 11:53:00 +0000632 p = strchr(filename, ':');
633 assert(p != NULL);
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200634 len = p - filename;
635 if (len > sizeof(protocol) - 1)
636 len = sizeof(protocol) - 1;
637 memcpy(protocol, filename, len);
638 protocol[len] = '\0';
639 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
640 if (drv1->protocol_name &&
641 !strcmp(drv1->protocol_name, protocol)) {
642 return drv1;
643 }
644 }
645 return NULL;
646}
647
Kevin Wolff500a6d2012-11-12 17:35:27 +0100648static int find_image_format(BlockDriverState *bs, const char *filename,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200649 BlockDriver **pdrv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +0000650{
Kevin Wolff500a6d2012-11-12 17:35:27 +0100651 int score, score_max;
bellardea2384d2004-08-01 21:59:26 +0000652 BlockDriver *drv1, *drv;
bellard83f64092006-08-01 16:21:11 +0000653 uint8_t buf[2048];
Kevin Wolff500a6d2012-11-12 17:35:27 +0100654 int ret = 0;
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700655
Kevin Wolf08a00552010-06-01 18:37:31 +0200656 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
Paolo Bonzini8e895592013-01-10 15:39:27 +0100657 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
Stefan Weilc98ac352010-07-21 21:51:51 +0200658 drv = bdrv_find_format("raw");
659 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200660 error_setg(errp, "Could not find raw image format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200661 ret = -ENOENT;
662 }
663 *pdrv = drv;
664 return ret;
Nicholas A. Bellinger1a396852010-05-27 08:56:28 -0700665 }
Nicholas Bellingerf8ea0b02010-05-17 09:45:57 -0700666
bellard83f64092006-08-01 16:21:11 +0000667 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
bellard83f64092006-08-01 16:21:11 +0000668 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200669 error_setg_errno(errp, -ret, "Could not read image for determining its "
670 "format");
Stefan Weilc98ac352010-07-21 21:51:51 +0200671 *pdrv = NULL;
672 return ret;
bellard83f64092006-08-01 16:21:11 +0000673 }
674
bellardea2384d2004-08-01 21:59:26 +0000675 score_max = 0;
Christoph Hellwig84a12e62010-04-07 22:30:24 +0200676 drv = NULL;
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +0100677 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
bellard83f64092006-08-01 16:21:11 +0000678 if (drv1->bdrv_probe) {
679 score = drv1->bdrv_probe(buf, ret, filename);
680 if (score > score_max) {
681 score_max = score;
682 drv = drv1;
683 }
bellardea2384d2004-08-01 21:59:26 +0000684 }
685 }
Stefan Weilc98ac352010-07-21 21:51:51 +0200686 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200687 error_setg(errp, "Could not determine image format: No compatible "
688 "driver found");
Stefan Weilc98ac352010-07-21 21:51:51 +0200689 ret = -ENOENT;
690 }
691 *pdrv = drv;
692 return ret;
bellardea2384d2004-08-01 21:59:26 +0000693}
694
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100695/**
696 * Set the current 'total_sectors' value
697 */
698static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
699{
700 BlockDriver *drv = bs->drv;
701
Nicholas Bellinger396759a2010-05-17 09:46:04 -0700702 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
703 if (bs->sg)
704 return 0;
705
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100706 /* query actual device if possible, otherwise just trust the hint */
707 if (drv->bdrv_getlength) {
708 int64_t length = drv->bdrv_getlength(bs);
709 if (length < 0) {
710 return length;
711 }
Fam Zheng7e382002013-11-06 19:48:06 +0800712 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100713 }
714
715 bs->total_sectors = hint;
716 return 0;
717}
718
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100719/**
Paolo Bonzini9e8f1832013-02-08 14:06:11 +0100720 * Set open flags for a given discard mode
721 *
722 * Return 0 on success, -1 if the discard mode was invalid.
723 */
724int bdrv_parse_discard_flags(const char *mode, int *flags)
725{
726 *flags &= ~BDRV_O_UNMAP;
727
728 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
729 /* do nothing */
730 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
731 *flags |= BDRV_O_UNMAP;
732 } else {
733 return -1;
734 }
735
736 return 0;
737}
738
739/**
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100740 * Set open flags for a given cache mode
741 *
742 * Return 0 on success, -1 if the cache mode was invalid.
743 */
744int bdrv_parse_cache_flags(const char *mode, int *flags)
745{
746 *flags &= ~BDRV_O_CACHE_MASK;
747
748 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
749 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
Stefan Hajnoczi92196b22011-08-04 12:26:52 +0100750 } else if (!strcmp(mode, "directsync")) {
751 *flags |= BDRV_O_NOCACHE;
Stefan Hajnoczic3993cd2011-08-04 12:26:51 +0100752 } else if (!strcmp(mode, "writeback")) {
753 *flags |= BDRV_O_CACHE_WB;
754 } else if (!strcmp(mode, "unsafe")) {
755 *flags |= BDRV_O_CACHE_WB;
756 *flags |= BDRV_O_NO_FLUSH;
757 } else if (!strcmp(mode, "writethrough")) {
758 /* this is the default */
759 } else {
760 return -1;
761 }
762
763 return 0;
764}
765
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000766/**
767 * The copy-on-read flag is actually a reference count so multiple users may
768 * use the feature without worrying about clobbering its previous state.
769 * Copy-on-read stays enabled until all users have called to disable it.
770 */
771void bdrv_enable_copy_on_read(BlockDriverState *bs)
772{
773 bs->copy_on_read++;
774}
775
776void bdrv_disable_copy_on_read(BlockDriverState *bs)
777{
778 assert(bs->copy_on_read > 0);
779 bs->copy_on_read--;
780}
781
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200782/*
Kevin Wolfb1e6fc02014-05-06 12:11:42 +0200783 * Returns the flags that a temporary snapshot should get, based on the
784 * originally requested flags (the originally requested image will have flags
785 * like a backing file)
786 */
787static int bdrv_temp_snapshot_flags(int flags)
788{
789 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
790}
791
792/*
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200793 * Returns the flags that bs->file should get, based on the given flags for
794 * the parent BDS
795 */
796static int bdrv_inherited_flags(int flags)
797{
798 /* Enable protocol handling, disable format probing for bs->file */
799 flags |= BDRV_O_PROTOCOL;
800
801 /* Our block drivers take care to send flushes and respect unmap policy,
802 * so we can enable both unconditionally on lower layers. */
803 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
804
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200805 /* Clear flags that only apply to the top layer */
Kevin Wolf5669b442014-04-11 21:36:45 +0200806 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
Kevin Wolf0b50cc82014-04-11 21:29:52 +0200807
808 return flags;
809}
810
Kevin Wolf317fc442014-04-25 13:27:34 +0200811/*
812 * Returns the flags that bs->backing_hd should get, based on the given flags
813 * for the parent BDS
814 */
815static int bdrv_backing_flags(int flags)
816{
817 /* backing files always opened read-only */
818 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
819
820 /* snapshot=on is handled on the top layer */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200821 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
Kevin Wolf317fc442014-04-25 13:27:34 +0200822
823 return flags;
824}
825
Kevin Wolf7b272452012-11-12 17:05:39 +0100826static int bdrv_open_flags(BlockDriverState *bs, int flags)
827{
828 int open_flags = flags | BDRV_O_CACHE_WB;
829
830 /*
831 * Clear flags that are internal to the block layer before opening the
832 * image.
833 */
834 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
835
836 /*
837 * Snapshots should be writable.
838 */
Kevin Wolf8bfea152014-04-11 19:16:36 +0200839 if (flags & BDRV_O_TEMPORARY) {
Kevin Wolf7b272452012-11-12 17:05:39 +0100840 open_flags |= BDRV_O_RDWR;
841 }
842
843 return open_flags;
844}
845
Kevin Wolf636ea372014-01-24 14:11:52 +0100846static void bdrv_assign_node_name(BlockDriverState *bs,
847 const char *node_name,
848 Error **errp)
Benoît Canet6913c0c2014-01-23 21:31:33 +0100849{
850 if (!node_name) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100851 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100852 }
853
854 /* empty string node name is invalid */
855 if (node_name[0] == '\0') {
856 error_setg(errp, "Empty node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100857 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100858 }
859
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100860 /* takes care of avoiding namespaces collisions */
861 if (bdrv_find(node_name)) {
862 error_setg(errp, "node-name=%s is conflicting with a device id",
863 node_name);
Kevin Wolf636ea372014-01-24 14:11:52 +0100864 return;
Benoît Canet0c5e94e2014-02-12 17:15:07 +0100865 }
866
Benoît Canet6913c0c2014-01-23 21:31:33 +0100867 /* takes care of avoiding duplicates node names */
868 if (bdrv_find_node(node_name)) {
869 error_setg(errp, "Duplicate node name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100870 return;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100871 }
872
873 /* copy node name into the bs and insert it into the graph list */
874 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
875 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
Benoît Canet6913c0c2014-01-23 21:31:33 +0100876}
877
Kevin Wolfb6ce07a2010-04-12 16:37:13 +0200878/*
Kevin Wolf57915332010-04-14 15:24:50 +0200879 * Common part for opening disk images and files
Kevin Wolfb6ad4912013-03-15 10:35:04 +0100880 *
881 * Removes all processed options from *options.
Kevin Wolf57915332010-04-14 15:24:50 +0200882 */
Kevin Wolff500a6d2012-11-12 17:35:27 +0100883static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
Max Reitz34b5d2c2013-09-05 14:45:29 +0200884 QDict *options, int flags, BlockDriver *drv, Error **errp)
Kevin Wolf57915332010-04-14 15:24:50 +0200885{
886 int ret, open_flags;
Kevin Wolf035fccd2013-04-09 14:34:19 +0200887 const char *filename;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100888 const char *node_name = NULL;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200889 Error *local_err = NULL;
Kevin Wolf57915332010-04-14 15:24:50 +0200890
891 assert(drv != NULL);
Paolo Bonzini64058752012-05-08 16:51:49 +0200892 assert(bs->file == NULL);
Kevin Wolf707ff822013-03-06 12:20:31 +0100893 assert(options != NULL && bs->options != options);
Kevin Wolf57915332010-04-14 15:24:50 +0200894
Kevin Wolf45673672013-04-22 17:48:40 +0200895 if (file != NULL) {
896 filename = file->filename;
897 } else {
898 filename = qdict_get_try_str(options, "filename");
899 }
900
Kevin Wolf765003d2014-02-03 14:49:42 +0100901 if (drv->bdrv_needs_filename && !filename) {
902 error_setg(errp, "The '%s' block driver requires a file name",
903 drv->format_name);
904 return -EINVAL;
905 }
906
Kevin Wolf45673672013-04-22 17:48:40 +0200907 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
Stefan Hajnoczi28dcee12011-09-22 20:14:12 +0100908
Benoît Canet6913c0c2014-01-23 21:31:33 +0100909 node_name = qdict_get_try_str(options, "node-name");
Kevin Wolf636ea372014-01-24 14:11:52 +0100910 bdrv_assign_node_name(bs, node_name, &local_err);
Markus Armbruster0fb63952014-04-25 16:50:31 +0200911 if (local_err) {
Kevin Wolf636ea372014-01-24 14:11:52 +0100912 error_propagate(errp, local_err);
913 return -EINVAL;
Benoît Canet6913c0c2014-01-23 21:31:33 +0100914 }
915 qdict_del(options, "node-name");
916
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100917 /* bdrv_open() with directly using a protocol as drv. This layer is already
918 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
919 * and return immediately. */
920 if (file != NULL && drv->bdrv_file_open) {
921 bdrv_swap(file, bs);
922 return 0;
923 }
924
Kevin Wolf57915332010-04-14 15:24:50 +0200925 bs->open_flags = flags;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +0100926 bs->guest_block_size = 512;
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100927 bs->request_alignment = 512;
Asias He0d51b4d2013-08-22 15:24:14 +0800928 bs->zero_beyond_eof = true;
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800929 open_flags = bdrv_open_flags(bs, flags);
930 bs->read_only = !(open_flags & BDRV_O_RDWR);
931
932 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +0200933 error_setg(errp,
934 !bs->read_only && bdrv_is_whitelisted(drv, true)
935 ? "Driver '%s' can only be used for read-only devices"
936 : "Driver '%s' is not whitelisted",
937 drv->format_name);
Fam Zhengb64ec4e2013-05-29 19:35:40 +0800938 return -ENOTSUP;
939 }
Kevin Wolf57915332010-04-14 15:24:50 +0200940
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000941 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
Kevin Wolf0ebd24e2013-09-19 15:12:18 +0200942 if (flags & BDRV_O_COPY_ON_READ) {
943 if (!bs->read_only) {
944 bdrv_enable_copy_on_read(bs);
945 } else {
946 error_setg(errp, "Can't use copy-on-read on read-only device");
947 return -EINVAL;
948 }
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +0000949 }
950
Kevin Wolfc2ad1b02013-03-18 16:40:51 +0100951 if (filename != NULL) {
952 pstrcpy(bs->filename, sizeof(bs->filename), filename);
953 } else {
954 bs->filename[0] = '\0';
955 }
Kevin Wolf57915332010-04-14 15:24:50 +0200956
Kevin Wolf57915332010-04-14 15:24:50 +0200957 bs->drv = drv;
Anthony Liguori7267c092011-08-20 22:09:37 -0500958 bs->opaque = g_malloc0(drv->instance_size);
Kevin Wolf57915332010-04-14 15:24:50 +0200959
Stefan Hajnoczi03f541b2011-10-27 10:54:28 +0100960 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
Stefan Hajnoczie7c63792011-10-27 10:54:27 +0100961
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200962 /* Open the image, either directly or using a protocol */
963 if (drv->bdrv_file_open) {
Kevin Wolf5d186eb2013-03-27 17:28:18 +0100964 assert(file == NULL);
Benoît Canet030be322013-09-24 17:07:04 +0200965 assert(!drv->bdrv_needs_filename || filename != NULL);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200966 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
Kevin Wolff500a6d2012-11-12 17:35:27 +0100967 } else {
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200968 if (file == NULL) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200969 error_setg(errp, "Can't use '%s' as a block driver for the "
970 "protocol level", drv->format_name);
Kevin Wolf2af5ef72013-04-09 13:19:18 +0200971 ret = -EINVAL;
972 goto free_and_fail;
973 }
Kevin Wolff500a6d2012-11-12 17:35:27 +0100974 bs->file = file;
Max Reitz34b5d2c2013-09-05 14:45:29 +0200975 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
Kevin Wolf66f82ce2010-04-14 14:17:38 +0200976 }
977
Kevin Wolf57915332010-04-14 15:24:50 +0200978 if (ret < 0) {
Markus Armbruster84d18f02014-01-30 15:07:28 +0100979 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200980 error_propagate(errp, local_err);
Dunrong Huang2fa9aa52013-09-24 18:14:01 +0800981 } else if (bs->filename[0]) {
982 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
Max Reitz34b5d2c2013-09-05 14:45:29 +0200983 } else {
984 error_setg_errno(errp, -ret, "Could not open image");
985 }
Kevin Wolf57915332010-04-14 15:24:50 +0200986 goto free_and_fail;
987 }
988
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100989 ret = refresh_total_sectors(bs, bs->total_sectors);
990 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +0200991 error_setg_errno(errp, -ret, "Could not refresh total sector count");
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100992 goto free_and_fail;
Kevin Wolf57915332010-04-14 15:24:50 +0200993 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +0100994
Kevin Wolfd34682c2013-12-11 19:26:16 +0100995 bdrv_refresh_limits(bs);
Paolo Bonzinic25f53b2011-11-29 12:42:20 +0100996 assert(bdrv_opt_mem_align(bs) != 0);
Kevin Wolf47ea2de2014-03-05 15:49:55 +0100997 assert((bs->request_alignment != 0) || bs->sg);
Kevin Wolf57915332010-04-14 15:24:50 +0200998 return 0;
999
1000free_and_fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001001 bs->file = NULL;
Anthony Liguori7267c092011-08-20 22:09:37 -05001002 g_free(bs->opaque);
Kevin Wolf57915332010-04-14 15:24:50 +02001003 bs->opaque = NULL;
1004 bs->drv = NULL;
1005 return ret;
1006}
1007
1008/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001009 * Opens a file using a protocol (file, host_device, nbd, ...)
Kevin Wolf787e4a82013-03-06 11:52:48 +01001010 *
Max Reitz5acd9d82014-02-18 18:33:11 +01001011 * options is an indirect pointer to a QDict of options to pass to the block
1012 * drivers, or pointer to NULL for an empty set of options. If this function
1013 * takes ownership of the QDict reference, it will set *options to NULL;
1014 * otherwise, it will contain unused/unrecognized options after this function
1015 * returns. Then, the caller is responsible for freeing it. If it intends to
1016 * reuse the QDict, QINCREF() should be called beforehand.
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001017 */
Max Reitzd4446ea2014-02-18 18:33:09 +01001018static int bdrv_file_open(BlockDriverState *bs, const char *filename,
Max Reitz5acd9d82014-02-18 18:33:11 +01001019 QDict **options, int flags, Error **errp)
bellardb3380822004-03-14 21:38:54 +00001020{
Christoph Hellwig6db95602010-04-05 16:53:57 +02001021 BlockDriver *drv;
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001022 const char *drvname;
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001023 bool parse_filename = false;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001024 Error *local_err = NULL;
bellard83f64092006-08-01 16:21:11 +00001025 int ret;
1026
Kevin Wolf035fccd2013-04-09 14:34:19 +02001027 /* Fetch the file name from the options QDict if necessary */
1028 if (!filename) {
Max Reitz5acd9d82014-02-18 18:33:11 +01001029 filename = qdict_get_try_str(*options, "filename");
1030 } else if (filename && !qdict_haskey(*options, "filename")) {
1031 qdict_put(*options, "filename", qstring_from_str(filename));
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001032 parse_filename = true;
Kevin Wolf035fccd2013-04-09 14:34:19 +02001033 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001034 error_setg(errp, "Can't specify 'file' and 'filename' options at the "
1035 "same time");
Kevin Wolf035fccd2013-04-09 14:34:19 +02001036 ret = -EINVAL;
1037 goto fail;
1038 }
1039
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001040 /* Find the right block driver */
Max Reitz5acd9d82014-02-18 18:33:11 +01001041 drvname = qdict_get_try_str(*options, "driver");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001042 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001043 drv = bdrv_find_format(drvname);
Max Reitz34b5d2c2013-09-05 14:45:29 +02001044 if (!drv) {
1045 error_setg(errp, "Unknown driver '%s'", drvname);
1046 }
Max Reitz5acd9d82014-02-18 18:33:11 +01001047 qdict_del(*options, "driver");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001048 } else if (filename) {
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001049 drv = bdrv_find_protocol(filename, parse_filename);
Kevin Wolf98289622013-07-10 15:47:39 +02001050 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001051 error_setg(errp, "Unknown protocol");
Kevin Wolf98289622013-07-10 15:47:39 +02001052 }
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001053 } else {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001054 error_setg(errp, "Must specify either driver or file");
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001055 drv = NULL;
1056 }
1057
1058 if (!drv) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001059 /* errp has been set already */
Kevin Wolfc2ad1b02013-03-18 16:40:51 +01001060 ret = -ENOENT;
1061 goto fail;
1062 }
1063
1064 /* Parse the filename and open it */
Kevin Wolfe3fa4bf2014-04-03 12:45:51 +02001065 if (drv->bdrv_parse_filename && parse_filename) {
Max Reitz5acd9d82014-02-18 18:33:11 +01001066 drv->bdrv_parse_filename(filename, *options, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001067 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001068 error_propagate(errp, local_err);
Kevin Wolf6963a302013-03-15 18:47:22 +01001069 ret = -EINVAL;
1070 goto fail;
1071 }
Max Reitzcd5d0312014-03-05 22:41:36 +01001072
1073 if (!drv->bdrv_needs_filename) {
1074 qdict_del(*options, "filename");
1075 } else {
1076 filename = qdict_get_str(*options, "filename");
1077 }
Kevin Wolf6963a302013-03-15 18:47:22 +01001078 }
1079
Max Reitz505d7582013-12-20 19:28:13 +01001080 if (!drv->bdrv_file_open) {
Max Reitz5acd9d82014-02-18 18:33:11 +01001081 ret = bdrv_open(&bs, filename, NULL, *options, flags, drv, &local_err);
1082 *options = NULL;
Max Reitz505d7582013-12-20 19:28:13 +01001083 } else {
Max Reitz5acd9d82014-02-18 18:33:11 +01001084 ret = bdrv_open_common(bs, NULL, *options, flags, drv, &local_err);
Max Reitz505d7582013-12-20 19:28:13 +01001085 }
Kevin Wolf707ff822013-03-06 12:20:31 +01001086 if (ret < 0) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001087 error_propagate(errp, local_err);
Kevin Wolf707ff822013-03-06 12:20:31 +01001088 goto fail;
1089 }
1090
aliguori71d07702009-03-03 17:37:16 +00001091 bs->growable = 1;
bellard83f64092006-08-01 16:21:11 +00001092 return 0;
Kevin Wolf707ff822013-03-06 12:20:31 +01001093
1094fail:
Kevin Wolf707ff822013-03-06 12:20:31 +01001095 return ret;
bellardea2384d2004-08-01 21:59:26 +00001096}
bellardfc01f7e2003-06-30 10:03:06 +00001097
Fam Zheng8d24cce2014-05-23 21:29:45 +08001098void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1099{
1100
Fam Zheng826b6ca2014-05-23 21:29:47 +08001101 if (bs->backing_hd) {
1102 assert(bs->backing_blocker);
1103 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1104 } else if (backing_hd) {
1105 error_setg(&bs->backing_blocker,
1106 "device is used as backing hd of '%s'",
1107 bs->device_name);
1108 }
1109
Fam Zheng8d24cce2014-05-23 21:29:45 +08001110 bs->backing_hd = backing_hd;
1111 if (!backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001112 error_free(bs->backing_blocker);
1113 bs->backing_blocker = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001114 goto out;
1115 }
1116 bs->open_flags &= ~BDRV_O_NO_BACKING;
1117 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1118 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1119 backing_hd->drv ? backing_hd->drv->format_name : "");
Fam Zheng826b6ca2014-05-23 21:29:47 +08001120
1121 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1122 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1123 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1124 bs->backing_blocker);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001125out:
1126 bdrv_refresh_limits(bs);
1127}
1128
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001129/*
1130 * Opens the backing file for a BlockDriverState if not yet open
1131 *
1132 * options is a QDict of options to pass to the block drivers, or NULL for an
1133 * empty set of options. The reference to the QDict is transferred to this
1134 * function (even on failure), so if the caller intends to reuse the dictionary,
1135 * it needs to use QINCREF() before calling bdrv_file_open.
1136 */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001137int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
Paolo Bonzini9156df12012-10-18 16:49:17 +02001138{
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001139 char *backing_filename = g_malloc0(PATH_MAX);
Kevin Wolf317fc442014-04-25 13:27:34 +02001140 int ret = 0;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001141 BlockDriver *back_drv = NULL;
Fam Zheng8d24cce2014-05-23 21:29:45 +08001142 BlockDriverState *backing_hd;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001143 Error *local_err = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001144
1145 if (bs->backing_hd != NULL) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001146 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001147 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001148 }
1149
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001150 /* NULL means an empty set of options */
1151 if (options == NULL) {
1152 options = qdict_new();
1153 }
1154
Paolo Bonzini9156df12012-10-18 16:49:17 +02001155 bs->open_flags &= ~BDRV_O_NO_BACKING;
Kevin Wolf1cb6f502013-04-12 20:27:07 +02001156 if (qdict_haskey(options, "file.filename")) {
1157 backing_filename[0] = '\0';
1158 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001159 QDECREF(options);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001160 goto free_exit;
Fam Zhengdbecebd2013-09-22 20:05:06 +08001161 } else {
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001162 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001163 }
1164
Fam Zheng8d24cce2014-05-23 21:29:45 +08001165 backing_hd = bdrv_new("", errp);
1166
Paolo Bonzini9156df12012-10-18 16:49:17 +02001167 if (bs->backing_format[0] != '\0') {
1168 back_drv = bdrv_find_format(bs->backing_format);
1169 }
1170
Max Reitzf67503e2014-02-18 18:33:05 +01001171 assert(bs->backing_hd == NULL);
Fam Zheng8d24cce2014-05-23 21:29:45 +08001172 ret = bdrv_open(&backing_hd,
Max Reitzddf56362014-02-18 18:33:06 +01001173 *backing_filename ? backing_filename : NULL, NULL, options,
Kevin Wolf317fc442014-04-25 13:27:34 +02001174 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
Paolo Bonzini9156df12012-10-18 16:49:17 +02001175 if (ret < 0) {
Fam Zheng8d24cce2014-05-23 21:29:45 +08001176 bdrv_unref(backing_hd);
1177 backing_hd = NULL;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001178 bs->open_flags |= BDRV_O_NO_BACKING;
Fam Zhengb04b6b62013-11-08 11:26:49 +08001179 error_setg(errp, "Could not open backing file: %s",
1180 error_get_pretty(local_err));
1181 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001182 goto free_exit;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001183 }
Fam Zheng8d24cce2014-05-23 21:29:45 +08001184 bdrv_set_backing_hd(bs, backing_hd);
Peter Feinerd80ac652014-01-08 19:43:25 +00001185
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001186free_exit:
1187 g_free(backing_filename);
1188 return ret;
Paolo Bonzini9156df12012-10-18 16:49:17 +02001189}
1190
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001191/*
Max Reitzda557aa2013-12-20 19:28:11 +01001192 * Opens a disk image whose options are given as BlockdevRef in another block
1193 * device's options.
1194 *
Max Reitzda557aa2013-12-20 19:28:11 +01001195 * If allow_none is true, no image will be opened if filename is false and no
1196 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1197 *
1198 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1199 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1200 * itself, all options starting with "${bdref_key}." are considered part of the
1201 * BlockdevRef.
1202 *
1203 * The BlockdevRef will be removed from the options QDict.
Max Reitzf67503e2014-02-18 18:33:05 +01001204 *
1205 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
Max Reitzda557aa2013-12-20 19:28:11 +01001206 */
1207int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1208 QDict *options, const char *bdref_key, int flags,
Max Reitzf7d9fd82014-02-18 18:33:12 +01001209 bool allow_none, Error **errp)
Max Reitzda557aa2013-12-20 19:28:11 +01001210{
1211 QDict *image_options;
1212 int ret;
1213 char *bdref_key_dot;
1214 const char *reference;
1215
Max Reitzf67503e2014-02-18 18:33:05 +01001216 assert(pbs);
1217 assert(*pbs == NULL);
1218
Max Reitzda557aa2013-12-20 19:28:11 +01001219 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1220 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1221 g_free(bdref_key_dot);
1222
1223 reference = qdict_get_try_str(options, bdref_key);
1224 if (!filename && !reference && !qdict_size(image_options)) {
1225 if (allow_none) {
1226 ret = 0;
1227 } else {
1228 error_setg(errp, "A block device must be specified for \"%s\"",
1229 bdref_key);
1230 ret = -EINVAL;
1231 }
Markus Armbrusterb20e61e2014-05-28 11:16:57 +02001232 QDECREF(image_options);
Max Reitzda557aa2013-12-20 19:28:11 +01001233 goto done;
1234 }
1235
Max Reitzf7d9fd82014-02-18 18:33:12 +01001236 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
Max Reitzda557aa2013-12-20 19:28:11 +01001237
1238done:
1239 qdict_del(options, bdref_key);
1240 return ret;
1241}
1242
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001243void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
Kevin Wolfb9988752014-04-03 12:09:34 +02001244{
1245 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001246 char *tmp_filename = g_malloc0(PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001247 int64_t total_size;
1248 BlockDriver *bdrv_qcow2;
Chunyan Liu83d05212014-06-05 17:20:51 +08001249 QemuOpts *opts = NULL;
Kevin Wolfb9988752014-04-03 12:09:34 +02001250 QDict *snapshot_options;
1251 BlockDriverState *bs_snapshot;
1252 Error *local_err;
1253 int ret;
1254
1255 /* if snapshot, we create a temporary backing file and open it
1256 instead of opening 'filename' directly */
1257
1258 /* Get the required size from the image */
Kevin Wolff1877432014-04-04 17:07:19 +02001259 total_size = bdrv_getlength(bs);
1260 if (total_size < 0) {
1261 error_setg_errno(errp, -total_size, "Could not get image size");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001262 goto out;
Kevin Wolff1877432014-04-04 17:07:19 +02001263 }
1264 total_size &= BDRV_SECTOR_MASK;
Kevin Wolfb9988752014-04-03 12:09:34 +02001265
1266 /* Create the temporary image */
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001267 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
Kevin Wolfb9988752014-04-03 12:09:34 +02001268 if (ret < 0) {
1269 error_setg_errno(errp, -ret, "Could not get temporary filename");
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001270 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001271 }
1272
1273 bdrv_qcow2 = bdrv_find_format("qcow2");
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001274 opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1275 &error_abort);
Chunyan Liu83d05212014-06-05 17:20:51 +08001276 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
Chunyan Liuc282e1f2014-06-05 17:21:11 +08001277 ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08001278 qemu_opts_del(opts);
Kevin Wolfb9988752014-04-03 12:09:34 +02001279 if (ret < 0) {
1280 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1281 "'%s': %s", tmp_filename,
1282 error_get_pretty(local_err));
1283 error_free(local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001284 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001285 }
1286
1287 /* Prepare a new options QDict for the temporary file */
1288 snapshot_options = qdict_new();
1289 qdict_put(snapshot_options, "file.driver",
1290 qstring_from_str("file"));
1291 qdict_put(snapshot_options, "file.filename",
1292 qstring_from_str(tmp_filename));
1293
Kevin Wolf98522f62014-04-17 13:16:01 +02001294 bs_snapshot = bdrv_new("", &error_abort);
Kevin Wolfb9988752014-04-03 12:09:34 +02001295
1296 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001297 flags, bdrv_qcow2, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001298 if (ret < 0) {
1299 error_propagate(errp, local_err);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001300 goto out;
Kevin Wolfb9988752014-04-03 12:09:34 +02001301 }
1302
1303 bdrv_append(bs_snapshot, bs);
Benoît Canet1ba4b6a2014-04-22 17:05:27 +02001304
1305out:
1306 g_free(tmp_filename);
Kevin Wolfb9988752014-04-03 12:09:34 +02001307}
1308
Max Reitz4993f7e2014-05-08 20:12:41 +02001309static QDict *parse_json_filename(const char *filename, Error **errp)
1310{
1311 QObject *options_obj;
1312 QDict *options;
1313 int ret;
1314
1315 ret = strstart(filename, "json:", &filename);
1316 assert(ret);
1317
1318 options_obj = qobject_from_json(filename);
1319 if (!options_obj) {
1320 error_setg(errp, "Could not parse the JSON options");
1321 return NULL;
1322 }
1323
1324 if (qobject_type(options_obj) != QTYPE_QDICT) {
1325 qobject_decref(options_obj);
1326 error_setg(errp, "Invalid JSON object given");
1327 return NULL;
1328 }
1329
1330 options = qobject_to_qdict(options_obj);
1331 qdict_flatten(options);
1332
1333 return options;
1334}
1335
Max Reitzda557aa2013-12-20 19:28:11 +01001336/*
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001337 * Opens a disk image (raw, qcow2, vmdk, ...)
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001338 *
1339 * options is a QDict of options to pass to the block drivers, or NULL for an
1340 * empty set of options. The reference to the QDict belongs to the block layer
1341 * after the call (even on failure), so if the caller intends to reuse the
1342 * dictionary, it needs to use QINCREF() before calling bdrv_open.
Max Reitzf67503e2014-02-18 18:33:05 +01001343 *
1344 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1345 * If it is not NULL, the referenced BDS will be reused.
Max Reitzddf56362014-02-18 18:33:06 +01001346 *
1347 * The reference parameter may be used to specify an existing block device which
1348 * should be opened. If specified, neither options nor a filename may be given,
1349 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001350 */
Max Reitzddf56362014-02-18 18:33:06 +01001351int bdrv_open(BlockDriverState **pbs, const char *filename,
1352 const char *reference, QDict *options, int flags,
1353 BlockDriver *drv, Error **errp)
bellardea2384d2004-08-01 21:59:26 +00001354{
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001355 int ret;
Max Reitzf67503e2014-02-18 18:33:05 +01001356 BlockDriverState *file = NULL, *bs;
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001357 const char *drvname;
Max Reitz34b5d2c2013-09-05 14:45:29 +02001358 Error *local_err = NULL;
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001359 int snapshot_flags = 0;
bellard712e7872005-04-28 21:09:32 +00001360
Max Reitzf67503e2014-02-18 18:33:05 +01001361 assert(pbs);
1362
Max Reitzddf56362014-02-18 18:33:06 +01001363 if (reference) {
1364 bool options_non_empty = options ? qdict_size(options) : false;
1365 QDECREF(options);
1366
1367 if (*pbs) {
1368 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1369 "another block device");
1370 return -EINVAL;
1371 }
1372
1373 if (filename || options_non_empty) {
1374 error_setg(errp, "Cannot reference an existing block device with "
1375 "additional options or a new filename");
1376 return -EINVAL;
1377 }
1378
1379 bs = bdrv_lookup_bs(reference, reference, errp);
1380 if (!bs) {
1381 return -ENODEV;
1382 }
1383 bdrv_ref(bs);
1384 *pbs = bs;
1385 return 0;
1386 }
1387
Max Reitzf67503e2014-02-18 18:33:05 +01001388 if (*pbs) {
1389 bs = *pbs;
1390 } else {
Kevin Wolf98522f62014-04-17 13:16:01 +02001391 bs = bdrv_new("", &error_abort);
Max Reitzf67503e2014-02-18 18:33:05 +01001392 }
1393
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001394 /* NULL means an empty set of options */
1395 if (options == NULL) {
1396 options = qdict_new();
1397 }
1398
Max Reitz4993f7e2014-05-08 20:12:41 +02001399 if (filename && g_str_has_prefix(filename, "json:")) {
1400 QDict *json_options = parse_json_filename(filename, &local_err);
1401 if (local_err) {
1402 ret = -EINVAL;
1403 goto fail;
1404 }
1405
1406 /* Options given in the filename have lower priority than options
1407 * specified directly */
1408 qdict_join(options, json_options, false);
1409 QDECREF(json_options);
1410 filename = NULL;
1411 }
1412
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001413 bs->options = options;
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001414 options = qdict_clone_shallow(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001415
Max Reitz5469a2a2014-02-18 18:33:10 +01001416 if (flags & BDRV_O_PROTOCOL) {
1417 assert(!drv);
Max Reitz5acd9d82014-02-18 18:33:11 +01001418 ret = bdrv_file_open(bs, filename, &options, flags & ~BDRV_O_PROTOCOL,
Max Reitz5469a2a2014-02-18 18:33:10 +01001419 &local_err);
Max Reitz5469a2a2014-02-18 18:33:10 +01001420 if (!ret) {
Kevin Wolfeb909c72014-03-06 16:34:46 +01001421 drv = bs->drv;
Max Reitz5acd9d82014-02-18 18:33:11 +01001422 goto done;
Max Reitz5469a2a2014-02-18 18:33:10 +01001423 } else if (bs->drv) {
1424 goto close_and_fail;
1425 } else {
1426 goto fail;
1427 }
1428 }
1429
Kevin Wolff500a6d2012-11-12 17:35:27 +01001430 /* Open image file without format layer */
Jeff Codybe028ad2012-09-20 15:13:17 -04001431 if (flags & BDRV_O_RDWR) {
1432 flags |= BDRV_O_ALLOW_RDWR;
1433 }
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001434 if (flags & BDRV_O_SNAPSHOT) {
1435 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1436 flags = bdrv_backing_flags(flags);
1437 }
Jeff Codybe028ad2012-09-20 15:13:17 -04001438
Max Reitzf67503e2014-02-18 18:33:05 +01001439 assert(file == NULL);
Max Reitz054963f2013-12-20 19:28:12 +01001440 ret = bdrv_open_image(&file, filename, options, "file",
Kevin Wolf0b50cc82014-04-11 21:29:52 +02001441 bdrv_inherited_flags(flags),
1442 true, &local_err);
Max Reitz054963f2013-12-20 19:28:12 +01001443 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001444 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001445 }
1446
1447 /* Find the right image format driver */
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001448 drvname = qdict_get_try_str(options, "driver");
1449 if (drvname) {
Kevin Wolf8f94a6e2013-10-10 11:45:55 +02001450 drv = bdrv_find_format(drvname);
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001451 qdict_del(options, "driver");
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001452 if (!drv) {
1453 error_setg(errp, "Invalid driver: '%s'", drvname);
1454 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001455 goto fail;
Kevin Wolf06d22aa2013-08-08 17:44:52 +02001456 }
Kevin Wolf74fe54f2013-07-09 11:09:02 +02001457 }
1458
Kevin Wolff500a6d2012-11-12 17:35:27 +01001459 if (!drv) {
Max Reitz2a05cbe2013-12-20 19:28:10 +01001460 if (file) {
1461 ret = find_image_format(file, filename, &drv, &local_err);
1462 } else {
1463 error_setg(errp, "Must specify either driver or file");
1464 ret = -EINVAL;
Kevin Wolf8bfea152014-04-11 19:16:36 +02001465 goto fail;
Max Reitz2a05cbe2013-12-20 19:28:10 +01001466 }
Kevin Wolff500a6d2012-11-12 17:35:27 +01001467 }
1468
1469 if (!drv) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001470 goto fail;
Kevin Wolff500a6d2012-11-12 17:35:27 +01001471 }
1472
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001473 /* Open the image */
Max Reitz34b5d2c2013-09-05 14:45:29 +02001474 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001475 if (ret < 0) {
Kevin Wolf8bfea152014-04-11 19:16:36 +02001476 goto fail;
Christoph Hellwig69873072010-01-20 18:13:25 +01001477 }
1478
Max Reitz2a05cbe2013-12-20 19:28:10 +01001479 if (file && (bs->file != file)) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001480 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001481 file = NULL;
1482 }
1483
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001484 /* If there is a backing file, use it */
Paolo Bonzini9156df12012-10-18 16:49:17 +02001485 if ((flags & BDRV_O_NO_BACKING) == 0) {
Kevin Wolf31ca6d02013-03-28 15:29:24 +01001486 QDict *backing_options;
1487
Benoît Canet5726d872013-09-25 13:30:01 +02001488 qdict_extract_subqdict(options, &backing_options, "backing.");
Max Reitz34b5d2c2013-09-05 14:45:29 +02001489 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001490 if (ret < 0) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001491 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001492 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001493 }
1494
Kevin Wolfb9988752014-04-03 12:09:34 +02001495 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1496 * temporary snapshot afterwards. */
Kevin Wolfb1e6fc02014-05-06 12:11:42 +02001497 if (snapshot_flags) {
1498 bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
Kevin Wolfb9988752014-04-03 12:09:34 +02001499 if (local_err) {
1500 error_propagate(errp, local_err);
1501 goto close_and_fail;
1502 }
1503 }
1504
1505
Max Reitz5acd9d82014-02-18 18:33:11 +01001506done:
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001507 /* Check if any unknown options were used */
Max Reitz5acd9d82014-02-18 18:33:11 +01001508 if (options && (qdict_size(options) != 0)) {
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001509 const QDictEntry *entry = qdict_first(options);
Max Reitz5acd9d82014-02-18 18:33:11 +01001510 if (flags & BDRV_O_PROTOCOL) {
1511 error_setg(errp, "Block protocol '%s' doesn't support the option "
1512 "'%s'", drv->format_name, entry->key);
1513 } else {
1514 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1515 "support the option '%s'", drv->format_name,
1516 bs->device_name, entry->key);
1517 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001518
1519 ret = -EINVAL;
1520 goto close_and_fail;
1521 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001522
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001523 if (!bdrv_key_required(bs)) {
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02001524 bdrv_dev_change_media_cb(bs, true);
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001525 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1526 && !runstate_check(RUN_STATE_INMIGRATE)
1527 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1528 error_setg(errp,
1529 "Guest must be stopped for opening of encrypted image");
1530 ret = -EBUSY;
1531 goto close_and_fail;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001532 }
1533
Markus Armbrusterc3adb582014-03-14 09:22:48 +01001534 QDECREF(options);
Max Reitzf67503e2014-02-18 18:33:05 +01001535 *pbs = bs;
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001536 return 0;
1537
Kevin Wolf8bfea152014-04-11 19:16:36 +02001538fail:
Kevin Wolff500a6d2012-11-12 17:35:27 +01001539 if (file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001540 bdrv_unref(file);
Kevin Wolff500a6d2012-11-12 17:35:27 +01001541 }
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001542 QDECREF(bs->options);
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001543 QDECREF(options);
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001544 bs->options = NULL;
Max Reitzf67503e2014-02-18 18:33:05 +01001545 if (!*pbs) {
1546 /* If *pbs is NULL, a new BDS has been created in this function and
1547 needs to be freed now. Otherwise, it does not need to be closed,
1548 since it has not really been opened yet. */
1549 bdrv_unref(bs);
1550 }
Markus Armbruster84d18f02014-01-30 15:07:28 +01001551 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001552 error_propagate(errp, local_err);
1553 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001554 return ret;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001555
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001556close_and_fail:
Max Reitzf67503e2014-02-18 18:33:05 +01001557 /* See fail path, but now the BDS has to be always closed */
1558 if (*pbs) {
1559 bdrv_close(bs);
1560 } else {
1561 bdrv_unref(bs);
1562 }
Kevin Wolfb6ad4912013-03-15 10:35:04 +01001563 QDECREF(options);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001564 if (local_err) {
Max Reitz34b5d2c2013-09-05 14:45:29 +02001565 error_propagate(errp, local_err);
1566 }
Kevin Wolfb6ce07a2010-04-12 16:37:13 +02001567 return ret;
1568}
1569
Jeff Codye971aa12012-09-20 15:13:19 -04001570typedef struct BlockReopenQueueEntry {
1571 bool prepared;
1572 BDRVReopenState state;
1573 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1574} BlockReopenQueueEntry;
1575
1576/*
1577 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1578 * reopen of multiple devices.
1579 *
1580 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1581 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1582 * be created and initialized. This newly created BlockReopenQueue should be
1583 * passed back in for subsequent calls that are intended to be of the same
1584 * atomic 'set'.
1585 *
1586 * bs is the BlockDriverState to add to the reopen queue.
1587 *
1588 * flags contains the open flags for the associated bs
1589 *
1590 * returns a pointer to bs_queue, which is either the newly allocated
1591 * bs_queue, or the existing bs_queue being used.
1592 *
1593 */
1594BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1595 BlockDriverState *bs, int flags)
1596{
1597 assert(bs != NULL);
1598
1599 BlockReopenQueueEntry *bs_entry;
1600 if (bs_queue == NULL) {
1601 bs_queue = g_new0(BlockReopenQueue, 1);
1602 QSIMPLEQ_INIT(bs_queue);
1603 }
1604
Kevin Wolff1f25a22014-04-25 19:04:55 +02001605 /* bdrv_open() masks this flag out */
1606 flags &= ~BDRV_O_PROTOCOL;
1607
Jeff Codye971aa12012-09-20 15:13:19 -04001608 if (bs->file) {
Kevin Wolff1f25a22014-04-25 19:04:55 +02001609 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
Jeff Codye971aa12012-09-20 15:13:19 -04001610 }
1611
1612 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1613 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1614
1615 bs_entry->state.bs = bs;
1616 bs_entry->state.flags = flags;
1617
1618 return bs_queue;
1619}
1620
1621/*
1622 * Reopen multiple BlockDriverStates atomically & transactionally.
1623 *
1624 * The queue passed in (bs_queue) must have been built up previous
1625 * via bdrv_reopen_queue().
1626 *
1627 * Reopens all BDS specified in the queue, with the appropriate
1628 * flags. All devices are prepared for reopen, and failure of any
1629 * device will cause all device changes to be abandonded, and intermediate
1630 * data cleaned up.
1631 *
1632 * If all devices prepare successfully, then the changes are committed
1633 * to all devices.
1634 *
1635 */
1636int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1637{
1638 int ret = -1;
1639 BlockReopenQueueEntry *bs_entry, *next;
1640 Error *local_err = NULL;
1641
1642 assert(bs_queue != NULL);
1643
1644 bdrv_drain_all();
1645
1646 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1647 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1648 error_propagate(errp, local_err);
1649 goto cleanup;
1650 }
1651 bs_entry->prepared = true;
1652 }
1653
1654 /* If we reach this point, we have success and just need to apply the
1655 * changes
1656 */
1657 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1658 bdrv_reopen_commit(&bs_entry->state);
1659 }
1660
1661 ret = 0;
1662
1663cleanup:
1664 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1665 if (ret && bs_entry->prepared) {
1666 bdrv_reopen_abort(&bs_entry->state);
1667 }
1668 g_free(bs_entry);
1669 }
1670 g_free(bs_queue);
1671 return ret;
1672}
1673
1674
1675/* Reopen a single BlockDriverState with the specified flags. */
1676int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1677{
1678 int ret = -1;
1679 Error *local_err = NULL;
1680 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1681
1682 ret = bdrv_reopen_multiple(queue, &local_err);
1683 if (local_err != NULL) {
1684 error_propagate(errp, local_err);
1685 }
1686 return ret;
1687}
1688
1689
1690/*
1691 * Prepares a BlockDriverState for reopen. All changes are staged in the
1692 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1693 * the block driver layer .bdrv_reopen_prepare()
1694 *
1695 * bs is the BlockDriverState to reopen
1696 * flags are the new open flags
1697 * queue is the reopen queue
1698 *
1699 * Returns 0 on success, non-zero on error. On error errp will be set
1700 * as well.
1701 *
1702 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1703 * It is the responsibility of the caller to then call the abort() or
1704 * commit() for any other BDS that have been left in a prepare() state
1705 *
1706 */
1707int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1708 Error **errp)
1709{
1710 int ret = -1;
1711 Error *local_err = NULL;
1712 BlockDriver *drv;
1713
1714 assert(reopen_state != NULL);
1715 assert(reopen_state->bs->drv != NULL);
1716 drv = reopen_state->bs->drv;
1717
1718 /* if we are to stay read-only, do not allow permission change
1719 * to r/w */
1720 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1721 reopen_state->flags & BDRV_O_RDWR) {
1722 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1723 reopen_state->bs->device_name);
1724 goto error;
1725 }
1726
1727
1728 ret = bdrv_flush(reopen_state->bs);
1729 if (ret) {
1730 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1731 strerror(-ret));
1732 goto error;
1733 }
1734
1735 if (drv->bdrv_reopen_prepare) {
1736 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1737 if (ret) {
1738 if (local_err != NULL) {
1739 error_propagate(errp, local_err);
1740 } else {
Luiz Capitulinod8b68952013-06-10 11:29:27 -04001741 error_setg(errp, "failed while preparing to reopen image '%s'",
1742 reopen_state->bs->filename);
Jeff Codye971aa12012-09-20 15:13:19 -04001743 }
1744 goto error;
1745 }
1746 } else {
1747 /* It is currently mandatory to have a bdrv_reopen_prepare()
1748 * handler for each supported drv. */
1749 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1750 drv->format_name, reopen_state->bs->device_name,
1751 "reopening of file");
1752 ret = -1;
1753 goto error;
1754 }
1755
1756 ret = 0;
1757
1758error:
1759 return ret;
1760}
1761
1762/*
1763 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1764 * makes them final by swapping the staging BlockDriverState contents into
1765 * the active BlockDriverState contents.
1766 */
1767void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1768{
1769 BlockDriver *drv;
1770
1771 assert(reopen_state != NULL);
1772 drv = reopen_state->bs->drv;
1773 assert(drv != NULL);
1774
1775 /* If there are any driver level actions to take */
1776 if (drv->bdrv_reopen_commit) {
1777 drv->bdrv_reopen_commit(reopen_state);
1778 }
1779
1780 /* set BDS specific flags now */
1781 reopen_state->bs->open_flags = reopen_state->flags;
1782 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1783 BDRV_O_CACHE_WB);
1784 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
Kevin Wolf355ef4a2013-12-11 20:14:09 +01001785
1786 bdrv_refresh_limits(reopen_state->bs);
Jeff Codye971aa12012-09-20 15:13:19 -04001787}
1788
1789/*
1790 * Abort the reopen, and delete and free the staged changes in
1791 * reopen_state
1792 */
1793void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1794{
1795 BlockDriver *drv;
1796
1797 assert(reopen_state != NULL);
1798 drv = reopen_state->bs->drv;
1799 assert(drv != NULL);
1800
1801 if (drv->bdrv_reopen_abort) {
1802 drv->bdrv_reopen_abort(reopen_state);
1803 }
1804}
1805
1806
bellardfc01f7e2003-06-30 10:03:06 +00001807void bdrv_close(BlockDriverState *bs)
1808{
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001809 if (bs->job) {
1810 block_job_cancel_sync(bs->job);
1811 }
Stefan Hajnoczi58fda172013-07-02 15:36:25 +02001812 bdrv_drain_all(); /* complete I/O */
1813 bdrv_flush(bs);
1814 bdrv_drain_all(); /* in case flush left pending I/O */
Paolo Bonzinid7d512f2012-08-23 11:20:36 +02001815 notifier_list_notify(&bs->close_notifiers, bs);
Kevin Wolf7094f122012-04-11 11:06:37 +02001816
Paolo Bonzini3cbc0022012-10-19 11:36:48 +02001817 if (bs->drv) {
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001818 if (bs->backing_hd) {
Fam Zheng826b6ca2014-05-23 21:29:47 +08001819 BlockDriverState *backing_hd = bs->backing_hd;
1820 bdrv_set_backing_hd(bs, NULL);
1821 bdrv_unref(backing_hd);
Stefan Hajnoczi557df6a2010-04-17 10:49:06 +01001822 }
bellardea2384d2004-08-01 21:59:26 +00001823 bs->drv->bdrv_close(bs);
Anthony Liguori7267c092011-08-20 22:09:37 -05001824 g_free(bs->opaque);
bellardea2384d2004-08-01 21:59:26 +00001825 bs->opaque = NULL;
1826 bs->drv = NULL;
Stefan Hajnoczi53fec9d2011-11-28 16:08:47 +00001827 bs->copy_on_read = 0;
Paolo Bonzinia275fa42012-05-08 16:51:43 +02001828 bs->backing_file[0] = '\0';
1829 bs->backing_format[0] = '\0';
Paolo Bonzini64058752012-05-08 16:51:49 +02001830 bs->total_sectors = 0;
1831 bs->encrypted = 0;
1832 bs->valid_key = 0;
1833 bs->sg = 0;
1834 bs->growable = 0;
Asias He0d51b4d2013-08-22 15:24:14 +08001835 bs->zero_beyond_eof = false;
Kevin Wolfde9c0ce2013-03-15 10:35:02 +01001836 QDECREF(bs->options);
1837 bs->options = NULL;
bellardb3380822004-03-14 21:38:54 +00001838
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001839 if (bs->file != NULL) {
Fam Zheng4f6fd342013-08-23 09:14:47 +08001840 bdrv_unref(bs->file);
Paolo Bonzini0ac93772012-05-08 16:51:44 +02001841 bs->file = NULL;
Kevin Wolf66f82ce2010-04-14 14:17:38 +02001842 }
bellardb3380822004-03-14 21:38:54 +00001843 }
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001844
Pavel Hrdina9ca11152012-08-09 12:44:48 +02001845 bdrv_dev_change_media_cb(bs, false);
1846
Zhi Yong Wu98f90db2011-11-08 13:00:14 +08001847 /*throttling disk I/O limits*/
1848 if (bs->io_limits_enabled) {
1849 bdrv_io_limits_disable(bs);
1850 }
bellardb3380822004-03-14 21:38:54 +00001851}
1852
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001853void bdrv_close_all(void)
1854{
1855 BlockDriverState *bs;
1856
Benoît Canetdc364f42014-01-23 21:31:32 +01001857 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001858 AioContext *aio_context = bdrv_get_aio_context(bs);
1859
1860 aio_context_acquire(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001861 bdrv_close(bs);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02001862 aio_context_release(aio_context);
MORITA Kazutaka2bc93fe2010-05-28 11:44:57 +09001863 }
1864}
1865
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001866/* Check if any requests are in-flight (including throttled requests) */
1867static bool bdrv_requests_pending(BlockDriverState *bs)
1868{
1869 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1870 return true;
1871 }
Benoît Canetcc0681c2013-09-02 14:14:39 +02001872 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1873 return true;
1874 }
1875 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001876 return true;
1877 }
1878 if (bs->file && bdrv_requests_pending(bs->file)) {
1879 return true;
1880 }
1881 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1882 return true;
1883 }
1884 return false;
1885}
1886
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001887/*
1888 * Wait for pending requests to complete across all BlockDriverStates
1889 *
1890 * This function does not flush data to disk, use bdrv_flush_all() for that
1891 * after calling this function.
Zhi Yong Wu4c355d52012-04-12 14:00:57 +02001892 *
1893 * Note that completion of an asynchronous I/O operation can trigger any
1894 * number of other I/O operations on other devices---for example a coroutine
1895 * can be arbitrarily complex and a constant flow of I/O can come until the
1896 * coroutine is complete. Because of this, it is not possible to have a
1897 * function to drain a single device's I/O queue.
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001898 */
1899void bdrv_drain_all(void)
1900{
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001901 /* Always run first iteration so any pending completion BHs run */
1902 bool busy = true;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001903 BlockDriverState *bs;
1904
Stefan Hajnoczi88266f52013-04-11 15:41:13 +02001905 while (busy) {
Stefan Hajnoczi9b536ad2014-05-08 16:34:36 +02001906 busy = false;
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001907
Stefan Hajnoczi9b536ad2014-05-08 16:34:36 +02001908 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1909 AioContext *aio_context = bdrv_get_aio_context(bs);
1910 bool bs_busy;
1911
1912 aio_context_acquire(aio_context);
1913 bdrv_start_throttled_reqs(bs);
1914 bs_busy = bdrv_requests_pending(bs);
1915 bs_busy |= aio_poll(aio_context, bs_busy);
1916 aio_context_release(aio_context);
1917
1918 busy |= bs_busy;
1919 }
Stefan Hajnoczi922453b2011-11-30 12:23:43 +00001920 }
1921}
1922
Benoît Canetdc364f42014-01-23 21:31:32 +01001923/* make a BlockDriverState anonymous by removing from bdrv_state and
1924 * graph_bdrv_state list.
Ryan Harperd22b2f42011-03-29 20:51:47 -05001925 Also, NULL terminate the device_name to prevent double remove */
1926void bdrv_make_anon(BlockDriverState *bs)
1927{
1928 if (bs->device_name[0] != '\0') {
Benoît Canetdc364f42014-01-23 21:31:32 +01001929 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
Ryan Harperd22b2f42011-03-29 20:51:47 -05001930 }
1931 bs->device_name[0] = '\0';
Benoît Canetdc364f42014-01-23 21:31:32 +01001932 if (bs->node_name[0] != '\0') {
1933 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1934 }
1935 bs->node_name[0] = '\0';
Ryan Harperd22b2f42011-03-29 20:51:47 -05001936}
1937
Paolo Bonzinie023b2e2012-05-08 16:51:41 +02001938static void bdrv_rebind(BlockDriverState *bs)
1939{
1940 if (bs->drv && bs->drv->bdrv_rebind) {
1941 bs->drv->bdrv_rebind(bs);
1942 }
1943}
1944
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001945static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1946 BlockDriverState *bs_src)
1947{
1948 /* move some fields that need to stay attached to the device */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001949
1950 /* dev info */
1951 bs_dest->dev_ops = bs_src->dev_ops;
1952 bs_dest->dev_opaque = bs_src->dev_opaque;
1953 bs_dest->dev = bs_src->dev;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01001954 bs_dest->guest_block_size = bs_src->guest_block_size;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001955 bs_dest->copy_on_read = bs_src->copy_on_read;
1956
1957 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1958
Benoît Canetcc0681c2013-09-02 14:14:39 +02001959 /* i/o throttled req */
1960 memcpy(&bs_dest->throttle_state,
1961 &bs_src->throttle_state,
1962 sizeof(ThrottleState));
1963 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1964 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001965 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1966
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001967 /* r/w error */
1968 bs_dest->on_read_error = bs_src->on_read_error;
1969 bs_dest->on_write_error = bs_src->on_write_error;
1970
1971 /* i/o status */
1972 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1973 bs_dest->iostatus = bs_src->iostatus;
1974
1975 /* dirty bitmap */
Fam Zhenge4654d22013-11-13 18:29:43 +08001976 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001977
Fam Zheng9fcb0252013-08-23 09:14:46 +08001978 /* reference count */
1979 bs_dest->refcnt = bs_src->refcnt;
1980
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001981 /* job */
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001982 bs_dest->job = bs_src->job;
1983
1984 /* keep the same entry in bdrv_states */
1985 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1986 bs_src->device_name);
Benoît Canetdc364f42014-01-23 21:31:32 +01001987 bs_dest->device_list = bs_src->device_list;
Fam Zhengfbe40ff2014-05-23 21:29:42 +08001988 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1989 sizeof(bs_dest->op_blockers));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02001990}
1991
1992/*
1993 * Swap bs contents for two image chains while they are live,
1994 * while keeping required fields on the BlockDriverState that is
1995 * actually attached to a device.
1996 *
1997 * This will modify the BlockDriverState fields, and swap contents
1998 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1999 *
2000 * bs_new is required to be anonymous.
2001 *
2002 * This function does not create any image files.
2003 */
2004void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2005{
2006 BlockDriverState tmp;
2007
Benoît Canet90ce8a02014-03-05 23:48:29 +01002008 /* The code needs to swap the node_name but simply swapping node_list won't
2009 * work so first remove the nodes from the graph list, do the swap then
2010 * insert them back if needed.
2011 */
2012 if (bs_new->node_name[0] != '\0') {
2013 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2014 }
2015 if (bs_old->node_name[0] != '\0') {
2016 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2017 }
2018
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002019 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2020 assert(bs_new->device_name[0] == '\0');
Fam Zhenge4654d22013-11-13 18:29:43 +08002021 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002022 assert(bs_new->job == NULL);
2023 assert(bs_new->dev == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002024 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02002025 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002026
2027 tmp = *bs_new;
2028 *bs_new = *bs_old;
2029 *bs_old = tmp;
2030
2031 /* there are some fields that should not be swapped, move them back */
2032 bdrv_move_feature_fields(&tmp, bs_old);
2033 bdrv_move_feature_fields(bs_old, bs_new);
2034 bdrv_move_feature_fields(bs_new, &tmp);
2035
2036 /* bs_new shouldn't be in bdrv_states even after the swap! */
2037 assert(bs_new->device_name[0] == '\0');
2038
2039 /* Check a few fields that should remain attached to the device */
2040 assert(bs_new->dev == NULL);
2041 assert(bs_new->job == NULL);
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002042 assert(bs_new->io_limits_enabled == false);
Benoît Canetcc0681c2013-09-02 14:14:39 +02002043 assert(!throttle_have_timer(&bs_new->throttle_state));
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002044
Benoît Canet90ce8a02014-03-05 23:48:29 +01002045 /* insert the nodes back into the graph node list if needed */
2046 if (bs_new->node_name[0] != '\0') {
2047 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2048 }
2049 if (bs_old->node_name[0] != '\0') {
2050 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2051 }
2052
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002053 bdrv_rebind(bs_new);
2054 bdrv_rebind(bs_old);
2055}
2056
Jeff Cody8802d1f2012-02-28 15:54:06 -05002057/*
2058 * Add new bs contents at the top of an image chain while the chain is
2059 * live, while keeping required fields on the top layer.
2060 *
2061 * This will modify the BlockDriverState fields, and swap contents
2062 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2063 *
Jeff Codyf6801b82012-03-27 16:30:19 -04002064 * bs_new is required to be anonymous.
2065 *
Jeff Cody8802d1f2012-02-28 15:54:06 -05002066 * This function does not create any image files.
2067 */
2068void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2069{
Paolo Bonzini4ddc07c2012-06-14 16:55:02 +02002070 bdrv_swap(bs_new, bs_top);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002071
2072 /* The contents of 'tmp' will become bs_top, as we are
2073 * swapping bs_new and bs_top contents. */
Fam Zheng8d24cce2014-05-23 21:29:45 +08002074 bdrv_set_backing_hd(bs_top, bs_new);
Jeff Cody8802d1f2012-02-28 15:54:06 -05002075}
2076
Fam Zheng4f6fd342013-08-23 09:14:47 +08002077static void bdrv_delete(BlockDriverState *bs)
bellardb3380822004-03-14 21:38:54 +00002078{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002079 assert(!bs->dev);
Paolo Bonzini3e914652012-03-30 13:17:11 +02002080 assert(!bs->job);
Fam Zheng3718d8a2014-05-23 21:29:43 +08002081 assert(bdrv_op_blocker_is_empty(bs));
Fam Zheng4f6fd342013-08-23 09:14:47 +08002082 assert(!bs->refcnt);
Fam Zhenge4654d22013-11-13 18:29:43 +08002083 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Markus Armbruster18846de2010-06-29 16:58:30 +02002084
Stefan Hajnoczie1b5c522013-06-27 15:32:26 +02002085 bdrv_close(bs);
2086
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01002087 /* remove from list, if necessary */
Ryan Harperd22b2f42011-03-29 20:51:47 -05002088 bdrv_make_anon(bs);
aurel3234c6f052008-04-08 19:51:21 +00002089
Anthony Liguori7267c092011-08-20 22:09:37 -05002090 g_free(bs);
bellardfc01f7e2003-06-30 10:03:06 +00002091}
2092
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002093int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2094/* TODO change to DeviceState *dev when all users are qdevified */
Markus Armbruster18846de2010-06-29 16:58:30 +02002095{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002096 if (bs->dev) {
Markus Armbruster18846de2010-06-29 16:58:30 +02002097 return -EBUSY;
2098 }
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002099 bs->dev = dev;
Luiz Capitulino28a72822011-09-26 17:43:50 -03002100 bdrv_iostatus_reset(bs);
Markus Armbruster18846de2010-06-29 16:58:30 +02002101 return 0;
2102}
2103
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002104/* TODO qdevified devices don't use this, remove when devices are qdevified */
2105void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
Markus Armbruster18846de2010-06-29 16:58:30 +02002106{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002107 if (bdrv_attach_dev(bs, dev) < 0) {
2108 abort();
2109 }
2110}
2111
2112void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2113/* TODO change to DeviceState *dev when all users are qdevified */
2114{
2115 assert(bs->dev == dev);
2116 bs->dev = NULL;
Markus Armbruster0e49de52011-08-03 15:07:41 +02002117 bs->dev_ops = NULL;
2118 bs->dev_opaque = NULL;
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01002119 bs->guest_block_size = 512;
Markus Armbruster18846de2010-06-29 16:58:30 +02002120}
2121
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002122/* TODO change to return DeviceState * when all users are qdevified */
2123void *bdrv_get_attached_dev(BlockDriverState *bs)
Markus Armbruster18846de2010-06-29 16:58:30 +02002124{
Markus Armbrusterfa879d62011-08-03 15:07:40 +02002125 return bs->dev;
Markus Armbruster18846de2010-06-29 16:58:30 +02002126}
2127
Markus Armbruster0e49de52011-08-03 15:07:41 +02002128void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2129 void *opaque)
2130{
2131 bs->dev_ops = ops;
2132 bs->dev_opaque = opaque;
2133}
2134
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002135void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
2136 enum MonitorEvent ev,
2137 BlockErrorAction action, bool is_read)
Luiz Capitulino329c0a42012-01-25 16:59:43 -02002138{
2139 QObject *data;
2140 const char *action_str;
2141
2142 switch (action) {
2143 case BDRV_ACTION_REPORT:
2144 action_str = "report";
2145 break;
2146 case BDRV_ACTION_IGNORE:
2147 action_str = "ignore";
2148 break;
2149 case BDRV_ACTION_STOP:
2150 action_str = "stop";
2151 break;
2152 default:
2153 abort();
2154 }
2155
2156 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
2157 bdrv->device_name,
2158 action_str,
2159 is_read ? "read" : "write");
Paolo Bonzini32c81a42012-09-28 17:22:58 +02002160 monitor_protocol_event(ev, data);
Luiz Capitulino329c0a42012-01-25 16:59:43 -02002161
2162 qobject_decref(data);
2163}
2164
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002165static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
2166{
2167 QObject *data;
2168
2169 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
2170 bdrv_get_device_name(bs), ejected);
2171 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
2172
2173 qobject_decref(data);
2174}
2175
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002176static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
Markus Armbruster0e49de52011-08-03 15:07:41 +02002177{
Markus Armbruster145feb12011-08-03 15:07:42 +02002178 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002179 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02002180 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02002181 if (tray_was_closed) {
2182 /* tray open */
2183 bdrv_emit_qmp_eject_event(bs, true);
2184 }
2185 if (load) {
2186 /* tray close */
2187 bdrv_emit_qmp_eject_event(bs, false);
2188 }
Markus Armbruster145feb12011-08-03 15:07:42 +02002189 }
2190}
2191
Markus Armbruster2c6942f2011-09-06 18:58:51 +02002192bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2193{
2194 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2195}
2196
Paolo Bonzini025ccaa2011-11-07 17:50:13 +01002197void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2198{
2199 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2200 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2201 }
2202}
2203
Markus Armbrustere4def802011-09-06 18:58:53 +02002204bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2205{
2206 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2207 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2208 }
2209 return false;
2210}
2211
Markus Armbruster145feb12011-08-03 15:07:42 +02002212static void bdrv_dev_resize_cb(BlockDriverState *bs)
2213{
2214 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2215 bs->dev_ops->resize_cb(bs->dev_opaque);
Markus Armbruster0e49de52011-08-03 15:07:41 +02002216 }
2217}
2218
Markus Armbrusterf1076392011-09-06 18:58:46 +02002219bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2220{
2221 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2222 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2223 }
2224 return false;
2225}
2226
aliguorie97fc192009-04-21 23:11:50 +00002227/*
2228 * Run consistency checks on an image
2229 *
Kevin Wolfe076f332010-06-29 11:43:13 +02002230 * Returns 0 if the check could be completed (it doesn't mean that the image is
Stefan Weila1c72732011-04-28 17:20:38 +02002231 * free of errors) or -errno when an internal error occurred. The results of the
Kevin Wolfe076f332010-06-29 11:43:13 +02002232 * check are stored in res.
aliguorie97fc192009-04-21 23:11:50 +00002233 */
Kevin Wolf4534ff52012-05-11 16:07:02 +02002234int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
aliguorie97fc192009-04-21 23:11:50 +00002235{
2236 if (bs->drv->bdrv_check == NULL) {
2237 return -ENOTSUP;
2238 }
2239
Kevin Wolfe076f332010-06-29 11:43:13 +02002240 memset(res, 0, sizeof(*res));
Kevin Wolf4534ff52012-05-11 16:07:02 +02002241 return bs->drv->bdrv_check(bs, res, fix);
aliguorie97fc192009-04-21 23:11:50 +00002242}
2243
Kevin Wolf8a426612010-07-16 17:17:01 +02002244#define COMMIT_BUF_SECTORS 2048
2245
bellard33e39632003-07-06 17:15:21 +00002246/* commit COW file into the raw image */
2247int bdrv_commit(BlockDriverState *bs)
2248{
bellard19cb3732006-08-19 11:45:59 +00002249 BlockDriver *drv = bs->drv;
Jeff Cody72706ea2014-01-24 09:02:35 -05002250 int64_t sector, total_sectors, length, backing_length;
Kevin Wolf8a426612010-07-16 17:17:01 +02002251 int n, ro, open_flags;
Jeff Cody0bce5972012-09-20 15:13:34 -04002252 int ret = 0;
Jeff Cody72706ea2014-01-24 09:02:35 -05002253 uint8_t *buf = NULL;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002254 char filename[PATH_MAX];
bellard33e39632003-07-06 17:15:21 +00002255
bellard19cb3732006-08-19 11:45:59 +00002256 if (!drv)
2257 return -ENOMEDIUM;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002258
2259 if (!bs->backing_hd) {
2260 return -ENOTSUP;
bellard33e39632003-07-06 17:15:21 +00002261 }
2262
Fam Zheng3718d8a2014-05-23 21:29:43 +08002263 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2264 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
Stefan Hajnoczi2d3735d2012-01-18 14:40:41 +00002265 return -EBUSY;
2266 }
2267
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002268 ro = bs->backing_hd->read_only;
Jim Meyeringc2cba3d2012-10-04 13:09:46 +02002269 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2270 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002271 open_flags = bs->backing_hd->open_flags;
2272
2273 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002274 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2275 return -EACCES;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002276 }
bellard33e39632003-07-06 17:15:21 +00002277 }
bellardea2384d2004-08-01 21:59:26 +00002278
Jeff Cody72706ea2014-01-24 09:02:35 -05002279 length = bdrv_getlength(bs);
2280 if (length < 0) {
2281 ret = length;
2282 goto ro_cleanup;
2283 }
2284
2285 backing_length = bdrv_getlength(bs->backing_hd);
2286 if (backing_length < 0) {
2287 ret = backing_length;
2288 goto ro_cleanup;
2289 }
2290
2291 /* If our top snapshot is larger than the backing file image,
2292 * grow the backing file image if possible. If not possible,
2293 * we must return an error */
2294 if (length > backing_length) {
2295 ret = bdrv_truncate(bs->backing_hd, length);
2296 if (ret < 0) {
2297 goto ro_cleanup;
2298 }
2299 }
2300
2301 total_sectors = length >> BDRV_SECTOR_BITS;
Anthony Liguori7267c092011-08-20 22:09:37 -05002302 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
bellardea2384d2004-08-01 21:59:26 +00002303
Kevin Wolf8a426612010-07-16 17:17:01 +02002304 for (sector = 0; sector < total_sectors; sector += n) {
Paolo Bonzinid6636402013-09-04 19:00:25 +02002305 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2306 if (ret < 0) {
2307 goto ro_cleanup;
2308 }
2309 if (ret) {
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002310 ret = bdrv_read(bs, sector, buf, n);
2311 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002312 goto ro_cleanup;
2313 }
2314
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002315 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2316 if (ret < 0) {
Kevin Wolf8a426612010-07-16 17:17:01 +02002317 goto ro_cleanup;
2318 }
bellardea2384d2004-08-01 21:59:26 +00002319 }
2320 }
bellard95389c82005-12-18 18:28:15 +00002321
Christoph Hellwig1d449522010-01-17 12:32:30 +01002322 if (drv->bdrv_make_empty) {
2323 ret = drv->bdrv_make_empty(bs);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002324 if (ret < 0) {
2325 goto ro_cleanup;
2326 }
Christoph Hellwig1d449522010-01-17 12:32:30 +01002327 bdrv_flush(bs);
2328 }
bellard95389c82005-12-18 18:28:15 +00002329
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002330 /*
2331 * Make sure all data we wrote to the backing device is actually
2332 * stable on disk.
2333 */
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002334 if (bs->backing_hd) {
Christoph Hellwig3f5075a2010-01-12 13:49:23 +01002335 bdrv_flush(bs->backing_hd);
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002336 }
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002337
Kevin Wolfdabfa6c2014-01-24 14:00:43 +01002338 ret = 0;
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002339ro_cleanup:
Anthony Liguori7267c092011-08-20 22:09:37 -05002340 g_free(buf);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002341
2342 if (ro) {
Jeff Cody0bce5972012-09-20 15:13:34 -04002343 /* ignoring error return here */
2344 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
Naphtali Sprei4dca4b62010-02-14 13:39:18 +02002345 }
2346
Christoph Hellwig1d449522010-01-17 12:32:30 +01002347 return ret;
bellard33e39632003-07-06 17:15:21 +00002348}
2349
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002350int bdrv_commit_all(void)
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002351{
2352 BlockDriverState *bs;
2353
Benoît Canetdc364f42014-01-23 21:31:32 +01002354 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002355 AioContext *aio_context = bdrv_get_aio_context(bs);
2356
2357 aio_context_acquire(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002358 if (bs->drv && bs->backing_hd) {
2359 int ret = bdrv_commit(bs);
2360 if (ret < 0) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002361 aio_context_release(aio_context);
Jeff Cody272d2d82013-02-26 09:55:48 -05002362 return ret;
2363 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002364 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02002365 aio_context_release(aio_context);
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002366 }
Stefan Hajnoczie8877492012-03-05 18:10:11 +00002367 return 0;
Markus Armbruster6ab4b5a2010-06-02 18:55:18 +02002368}
2369
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002370/**
2371 * Remove an active request from the tracked requests list
2372 *
2373 * This function should be called when a tracked request is completing.
2374 */
2375static void tracked_request_end(BdrvTrackedRequest *req)
2376{
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002377 if (req->serialising) {
2378 req->bs->serialising_in_flight--;
2379 }
2380
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002381 QLIST_REMOVE(req, list);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002382 qemu_co_queue_restart_all(&req->wait_queue);
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002383}
2384
2385/**
2386 * Add an active request to the tracked requests list
2387 */
2388static void tracked_request_begin(BdrvTrackedRequest *req,
2389 BlockDriverState *bs,
Kevin Wolf793ed472013-12-03 15:31:25 +01002390 int64_t offset,
2391 unsigned int bytes, bool is_write)
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002392{
2393 *req = (BdrvTrackedRequest){
2394 .bs = bs,
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002395 .offset = offset,
2396 .bytes = bytes,
2397 .is_write = is_write,
2398 .co = qemu_coroutine_self(),
2399 .serialising = false,
Kevin Wolf73271452013-12-04 17:08:50 +01002400 .overlap_offset = offset,
2401 .overlap_bytes = bytes,
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002402 };
2403
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002404 qemu_co_queue_init(&req->wait_queue);
2405
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00002406 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2407}
2408
Kevin Wolfe96126f2014-02-08 10:42:18 +01002409static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002410{
Kevin Wolf73271452013-12-04 17:08:50 +01002411 int64_t overlap_offset = req->offset & ~(align - 1);
Kevin Wolfe96126f2014-02-08 10:42:18 +01002412 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2413 - overlap_offset;
Kevin Wolf73271452013-12-04 17:08:50 +01002414
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002415 if (!req->serialising) {
2416 req->bs->serialising_in_flight++;
2417 req->serialising = true;
2418 }
Kevin Wolf73271452013-12-04 17:08:50 +01002419
2420 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2421 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002422}
2423
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002424/**
2425 * Round a region to cluster boundaries
2426 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002427void bdrv_round_to_clusters(BlockDriverState *bs,
2428 int64_t sector_num, int nb_sectors,
2429 int64_t *cluster_sector_num,
2430 int *cluster_nb_sectors)
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002431{
2432 BlockDriverInfo bdi;
2433
2434 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2435 *cluster_sector_num = sector_num;
2436 *cluster_nb_sectors = nb_sectors;
2437 } else {
2438 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2439 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2440 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2441 nb_sectors, c);
2442 }
2443}
2444
Kevin Wolf73271452013-12-04 17:08:50 +01002445static int bdrv_get_cluster_size(BlockDriverState *bs)
Kevin Wolf793ed472013-12-03 15:31:25 +01002446{
2447 BlockDriverInfo bdi;
Kevin Wolf73271452013-12-04 17:08:50 +01002448 int ret;
Kevin Wolf793ed472013-12-03 15:31:25 +01002449
Kevin Wolf73271452013-12-04 17:08:50 +01002450 ret = bdrv_get_info(bs, &bdi);
2451 if (ret < 0 || bdi.cluster_size == 0) {
2452 return bs->request_alignment;
Kevin Wolf793ed472013-12-03 15:31:25 +01002453 } else {
Kevin Wolf73271452013-12-04 17:08:50 +01002454 return bdi.cluster_size;
Kevin Wolf793ed472013-12-03 15:31:25 +01002455 }
2456}
2457
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002458static bool tracked_request_overlaps(BdrvTrackedRequest *req,
Kevin Wolf793ed472013-12-03 15:31:25 +01002459 int64_t offset, unsigned int bytes)
2460{
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002461 /* aaaa bbbb */
Kevin Wolf73271452013-12-04 17:08:50 +01002462 if (offset >= req->overlap_offset + req->overlap_bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002463 return false;
2464 }
2465 /* bbbb aaaa */
Kevin Wolf73271452013-12-04 17:08:50 +01002466 if (req->overlap_offset >= offset + bytes) {
Stefan Hajnoczid83947a2011-11-23 11:47:56 +00002467 return false;
2468 }
2469 return true;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002470}
2471
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002472static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002473{
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002474 BlockDriverState *bs = self->bs;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002475 BdrvTrackedRequest *req;
2476 bool retry;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002477 bool waited = false;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002478
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002479 if (!bs->serialising_in_flight) {
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002480 return false;
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002481 }
2482
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002483 do {
2484 retry = false;
2485 QLIST_FOREACH(req, &bs->tracked_requests, list) {
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01002486 if (req == self || (!req->serialising && !self->serialising)) {
Kevin Wolf65afd212013-12-03 14:55:55 +01002487 continue;
2488 }
Kevin Wolf73271452013-12-04 17:08:50 +01002489 if (tracked_request_overlaps(req, self->overlap_offset,
2490 self->overlap_bytes))
2491 {
Stefan Hajnoczi5f8b6492011-11-30 12:23:42 +00002492 /* Hitting this means there was a reentrant request, for
2493 * example, a block driver issuing nested requests. This must
2494 * never happen since it means deadlock.
2495 */
2496 assert(qemu_coroutine_self() != req->co);
2497
Kevin Wolf64604402013-12-13 13:04:35 +01002498 /* If the request is already (indirectly) waiting for us, or
2499 * will wait for us as soon as it wakes up, then just go on
2500 * (instead of producing a deadlock in the former case). */
2501 if (!req->waiting_for) {
2502 self->waiting_for = req;
2503 qemu_co_queue_wait(&req->wait_queue);
2504 self->waiting_for = NULL;
2505 retry = true;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002506 waited = true;
Kevin Wolf64604402013-12-13 13:04:35 +01002507 break;
2508 }
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002509 }
2510 }
2511 } while (retry);
Kevin Wolf28de2dc2014-01-14 11:41:35 +01002512
2513 return waited;
Stefan Hajnoczif4658282011-11-17 13:40:29 +00002514}
2515
Kevin Wolf756e6732010-01-12 12:55:17 +01002516/*
2517 * Return values:
2518 * 0 - success
2519 * -EINVAL - backing format specified, but no file
2520 * -ENOSPC - can't update the backing file because no space is left in the
2521 * image file header
2522 * -ENOTSUP - format driver doesn't support changing the backing file
2523 */
2524int bdrv_change_backing_file(BlockDriverState *bs,
2525 const char *backing_file, const char *backing_fmt)
2526{
2527 BlockDriver *drv = bs->drv;
Paolo Bonzini469ef352012-04-12 14:01:02 +02002528 int ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002529
Paolo Bonzini5f377792012-04-12 14:01:01 +02002530 /* Backing file format doesn't make sense without a backing file */
2531 if (backing_fmt && !backing_file) {
2532 return -EINVAL;
2533 }
2534
Kevin Wolf756e6732010-01-12 12:55:17 +01002535 if (drv->bdrv_change_backing_file != NULL) {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002536 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
Kevin Wolf756e6732010-01-12 12:55:17 +01002537 } else {
Paolo Bonzini469ef352012-04-12 14:01:02 +02002538 ret = -ENOTSUP;
Kevin Wolf756e6732010-01-12 12:55:17 +01002539 }
Paolo Bonzini469ef352012-04-12 14:01:02 +02002540
2541 if (ret == 0) {
2542 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2543 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2544 }
2545 return ret;
Kevin Wolf756e6732010-01-12 12:55:17 +01002546}
2547
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002548/*
2549 * Finds the image layer in the chain that has 'bs' as its backing file.
2550 *
2551 * active is the current topmost image.
2552 *
2553 * Returns NULL if bs is not found in active's image chain,
2554 * or if active == bs.
2555 */
2556BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2557 BlockDriverState *bs)
2558{
2559 BlockDriverState *overlay = NULL;
2560 BlockDriverState *intermediate;
2561
2562 assert(active != NULL);
2563 assert(bs != NULL);
2564
2565 /* if bs is the same as active, then by definition it has no overlay
2566 */
2567 if (active == bs) {
2568 return NULL;
2569 }
2570
2571 intermediate = active;
2572 while (intermediate->backing_hd) {
2573 if (intermediate->backing_hd == bs) {
2574 overlay = intermediate;
2575 break;
2576 }
2577 intermediate = intermediate->backing_hd;
2578 }
2579
2580 return overlay;
2581}
2582
2583typedef struct BlkIntermediateStates {
2584 BlockDriverState *bs;
2585 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2586} BlkIntermediateStates;
2587
2588
2589/*
2590 * Drops images above 'base' up to and including 'top', and sets the image
2591 * above 'top' to have base as its backing file.
2592 *
2593 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2594 * information in 'bs' can be properly updated.
2595 *
2596 * E.g., this will convert the following chain:
2597 * bottom <- base <- intermediate <- top <- active
2598 *
2599 * to
2600 *
2601 * bottom <- base <- active
2602 *
2603 * It is allowed for bottom==base, in which case it converts:
2604 *
2605 * base <- intermediate <- top <- active
2606 *
2607 * to
2608 *
2609 * base <- active
2610 *
2611 * Error conditions:
2612 * if active == top, that is considered an error
2613 *
2614 */
2615int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2616 BlockDriverState *base)
2617{
2618 BlockDriverState *intermediate;
2619 BlockDriverState *base_bs = NULL;
2620 BlockDriverState *new_top_bs = NULL;
2621 BlkIntermediateStates *intermediate_state, *next;
2622 int ret = -EIO;
2623
2624 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2625 QSIMPLEQ_INIT(&states_to_delete);
2626
2627 if (!top->drv || !base->drv) {
2628 goto exit;
2629 }
2630
2631 new_top_bs = bdrv_find_overlay(active, top);
2632
2633 if (new_top_bs == NULL) {
2634 /* we could not find the image above 'top', this is an error */
2635 goto exit;
2636 }
2637
2638 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2639 * to do, no intermediate images */
2640 if (new_top_bs->backing_hd == base) {
2641 ret = 0;
2642 goto exit;
2643 }
2644
2645 intermediate = top;
2646
2647 /* now we will go down through the list, and add each BDS we find
2648 * into our deletion queue, until we hit the 'base'
2649 */
2650 while (intermediate) {
2651 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2652 intermediate_state->bs = intermediate;
2653 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2654
2655 if (intermediate->backing_hd == base) {
2656 base_bs = intermediate->backing_hd;
2657 break;
2658 }
2659 intermediate = intermediate->backing_hd;
2660 }
2661 if (base_bs == NULL) {
2662 /* something went wrong, we did not end at the base. safely
2663 * unravel everything, and exit with error */
2664 goto exit;
2665 }
2666
2667 /* success - we can delete the intermediate states, and link top->base */
2668 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
2669 base_bs->drv ? base_bs->drv->format_name : "");
2670 if (ret) {
2671 goto exit;
2672 }
Fam Zheng920beae2014-05-23 21:29:46 +08002673 bdrv_set_backing_hd(new_top_bs, base_bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002674
2675 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2676 /* so that bdrv_close() does not recursively close the chain */
Fam Zheng920beae2014-05-23 21:29:46 +08002677 bdrv_set_backing_hd(intermediate_state->bs, NULL);
Fam Zheng4f6fd342013-08-23 09:14:47 +08002678 bdrv_unref(intermediate_state->bs);
Jeff Cody6ebdcee2012-09-27 13:29:12 -04002679 }
2680 ret = 0;
2681
2682exit:
2683 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2684 g_free(intermediate_state);
2685 }
2686 return ret;
2687}
2688
2689
aliguori71d07702009-03-03 17:37:16 +00002690static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2691 size_t size)
2692{
2693 int64_t len;
2694
Kevin Wolf1dd3a442014-04-14 14:48:16 +02002695 if (size > INT_MAX) {
2696 return -EIO;
2697 }
2698
aliguori71d07702009-03-03 17:37:16 +00002699 if (!bdrv_is_inserted(bs))
2700 return -ENOMEDIUM;
2701
2702 if (bs->growable)
2703 return 0;
2704
2705 len = bdrv_getlength(bs);
2706
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02002707 if (offset < 0)
2708 return -EIO;
2709
2710 if ((offset > len) || (len - offset < size))
aliguori71d07702009-03-03 17:37:16 +00002711 return -EIO;
2712
2713 return 0;
2714}
2715
2716static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2717 int nb_sectors)
2718{
Kevin Wolf54db38a2014-04-14 14:47:14 +02002719 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
Kevin Wolf8f4754e2014-03-26 13:06:02 +01002720 return -EIO;
2721 }
2722
Jes Sorenseneb5a3162010-05-27 16:20:31 +02002723 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2724 nb_sectors * BDRV_SECTOR_SIZE);
aliguori71d07702009-03-03 17:37:16 +00002725}
2726
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002727typedef struct RwCo {
2728 BlockDriverState *bs;
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002729 int64_t offset;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002730 QEMUIOVector *qiov;
2731 bool is_write;
2732 int ret;
Peter Lieven4105eaa2013-07-11 14:16:22 +02002733 BdrvRequestFlags flags;
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002734} RwCo;
2735
2736static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2737{
2738 RwCo *rwco = opaque;
2739
2740 if (!rwco->is_write) {
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002741 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2742 rwco->qiov->size, rwco->qiov,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002743 rwco->flags);
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002744 } else {
2745 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2746 rwco->qiov->size, rwco->qiov,
2747 rwco->flags);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002748 }
2749}
2750
2751/*
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002752 * Process a vectored synchronous request using coroutines
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002753 */
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002754static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2755 QEMUIOVector *qiov, bool is_write,
2756 BdrvRequestFlags flags)
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002757{
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002758 Coroutine *co;
2759 RwCo rwco = {
2760 .bs = bs,
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002761 .offset = offset,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002762 .qiov = qiov,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002763 .is_write = is_write,
2764 .ret = NOT_DONE,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002765 .flags = flags,
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002766 };
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002767
Zhi Yong Wu498e3862012-04-02 18:59:34 +08002768 /**
2769 * In sync call context, when the vcpu is blocked, this throttling timer
2770 * will not fire; so the I/O throttling function has to be disabled here
2771 * if it has been enabled.
2772 */
2773 if (bs->io_limits_enabled) {
2774 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2775 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2776 bdrv_io_limits_disable(bs);
2777 }
2778
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002779 if (qemu_in_coroutine()) {
2780 /* Fast-path if already in coroutine context */
2781 bdrv_rw_co_entry(&rwco);
2782 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02002783 AioContext *aio_context = bdrv_get_aio_context(bs);
2784
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002785 co = qemu_coroutine_create(bdrv_rw_co_entry);
2786 qemu_coroutine_enter(co, &rwco);
2787 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02002788 aio_poll(aio_context, true);
Stefan Hajnoczi1c9805a2011-10-13 13:08:22 +01002789 }
2790 }
2791 return rwco.ret;
2792}
2793
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002794/*
2795 * Process a synchronous request using coroutines
2796 */
2797static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
Peter Lieven4105eaa2013-07-11 14:16:22 +02002798 int nb_sectors, bool is_write, BdrvRequestFlags flags)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002799{
2800 QEMUIOVector qiov;
2801 struct iovec iov = {
2802 .iov_base = (void *)buf,
2803 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2804 };
2805
Kevin Wolfda15ee52014-04-14 15:39:36 +02002806 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2807 return -EINVAL;
2808 }
2809
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002810 qemu_iovec_init_external(&qiov, &iov, 1);
Kevin Wolf775aa8b2013-12-05 12:09:38 +01002811 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2812 &qiov, is_write, flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002813}
2814
bellard19cb3732006-08-19 11:45:59 +00002815/* return < 0 if error. See bdrv_write() for the return codes */
ths5fafdf22007-09-16 21:08:06 +00002816int bdrv_read(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002817 uint8_t *buf, int nb_sectors)
2818{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002819 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
bellardfc01f7e2003-06-30 10:03:06 +00002820}
2821
Markus Armbruster07d27a42012-06-29 17:34:29 +02002822/* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2823int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2824 uint8_t *buf, int nb_sectors)
2825{
2826 bool enabled;
2827 int ret;
2828
2829 enabled = bs->io_limits_enabled;
2830 bs->io_limits_enabled = false;
Peter Lieven4e7395e2013-07-18 10:37:32 +02002831 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
Markus Armbruster07d27a42012-06-29 17:34:29 +02002832 bs->io_limits_enabled = enabled;
2833 return ret;
2834}
2835
ths5fafdf22007-09-16 21:08:06 +00002836/* Return < 0 if error. Important errors are:
bellard19cb3732006-08-19 11:45:59 +00002837 -EIO generic I/O error (may happen for all errors)
2838 -ENOMEDIUM No media inserted.
2839 -EINVAL Invalid sector number or nb_sectors
2840 -EACCES Trying to write a read-only device
2841*/
ths5fafdf22007-09-16 21:08:06 +00002842int bdrv_write(BlockDriverState *bs, int64_t sector_num,
bellardfc01f7e2003-06-30 10:03:06 +00002843 const uint8_t *buf, int nb_sectors)
2844{
Peter Lieven4105eaa2013-07-11 14:16:22 +02002845 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
bellard83f64092006-08-01 16:21:11 +00002846}
2847
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002848int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2849 int nb_sectors, BdrvRequestFlags flags)
Peter Lieven4105eaa2013-07-11 14:16:22 +02002850{
2851 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02002852 BDRV_REQ_ZERO_WRITE | flags);
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002853}
2854
Peter Lievend75cbb52013-10-24 12:07:03 +02002855/*
2856 * Completely zero out a block device with the help of bdrv_write_zeroes.
2857 * The operation is sped up by checking the block status and only writing
2858 * zeroes to the device if they currently do not return zeroes. Optional
2859 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2860 *
2861 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2862 */
2863int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2864{
Kevin Wolf9ce10c02014-04-14 17:03:34 +02002865 int64_t target_size;
Peter Lievend75cbb52013-10-24 12:07:03 +02002866 int64_t ret, nb_sectors, sector_num = 0;
2867 int n;
2868
Kevin Wolf9ce10c02014-04-14 17:03:34 +02002869 target_size = bdrv_getlength(bs);
2870 if (target_size < 0) {
2871 return target_size;
2872 }
2873 target_size /= BDRV_SECTOR_SIZE;
2874
Peter Lievend75cbb52013-10-24 12:07:03 +02002875 for (;;) {
2876 nb_sectors = target_size - sector_num;
2877 if (nb_sectors <= 0) {
2878 return 0;
2879 }
2880 if (nb_sectors > INT_MAX) {
2881 nb_sectors = INT_MAX;
2882 }
2883 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
Peter Lieven3d94ce62013-12-12 13:57:05 +01002884 if (ret < 0) {
2885 error_report("error getting block status at sector %" PRId64 ": %s",
2886 sector_num, strerror(-ret));
2887 return ret;
2888 }
Peter Lievend75cbb52013-10-24 12:07:03 +02002889 if (ret & BDRV_BLOCK_ZERO) {
2890 sector_num += n;
2891 continue;
2892 }
2893 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2894 if (ret < 0) {
2895 error_report("error writing zeroes at sector %" PRId64 ": %s",
2896 sector_num, strerror(-ret));
2897 return ret;
2898 }
2899 sector_num += n;
2900 }
2901}
2902
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002903int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
bellard83f64092006-08-01 16:21:11 +00002904{
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002905 QEMUIOVector qiov;
2906 struct iovec iov = {
2907 .iov_base = (void *)buf,
2908 .iov_len = bytes,
2909 };
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002910 int ret;
bellard83f64092006-08-01 16:21:11 +00002911
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002912 if (bytes < 0) {
2913 return -EINVAL;
bellard83f64092006-08-01 16:21:11 +00002914 }
2915
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002916 qemu_iovec_init_external(&qiov, &iov, 1);
2917 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2918 if (ret < 0) {
2919 return ret;
bellard83f64092006-08-01 16:21:11 +00002920 }
2921
Kevin Wolfa3ef6572013-12-05 12:29:59 +01002922 return bytes;
bellard83f64092006-08-01 16:21:11 +00002923}
2924
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002925int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
bellard83f64092006-08-01 16:21:11 +00002926{
Kevin Wolf9a8c4cc2010-01-20 15:03:02 +01002927 int ret;
bellard83f64092006-08-01 16:21:11 +00002928
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002929 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2930 if (ret < 0) {
2931 return ret;
bellard83f64092006-08-01 16:21:11 +00002932 }
2933
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002934 return qiov->size;
2935}
2936
2937int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002938 const void *buf, int bytes)
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002939{
2940 QEMUIOVector qiov;
2941 struct iovec iov = {
2942 .iov_base = (void *) buf,
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002943 .iov_len = bytes,
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002944 };
2945
Kevin Wolf8407d5d2013-12-05 12:34:02 +01002946 if (bytes < 0) {
2947 return -EINVAL;
2948 }
2949
Kevin Wolf8d3b1a22013-04-05 21:27:55 +02002950 qemu_iovec_init_external(&qiov, &iov, 1);
2951 return bdrv_pwritev(bs, offset, &qiov);
bellard83f64092006-08-01 16:21:11 +00002952}
bellard83f64092006-08-01 16:21:11 +00002953
Kevin Wolff08145f2010-06-16 16:38:15 +02002954/*
2955 * Writes to the file and ensures that no writes are reordered across this
2956 * request (acts as a barrier)
2957 *
2958 * Returns 0 on success, -errno in error cases.
2959 */
2960int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2961 const void *buf, int count)
2962{
2963 int ret;
2964
2965 ret = bdrv_pwrite(bs, offset, buf, count);
2966 if (ret < 0) {
2967 return ret;
2968 }
2969
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02002970 /* No flush needed for cache modes that already do it */
2971 if (bs->enable_write_cache) {
Kevin Wolff08145f2010-06-16 16:38:15 +02002972 bdrv_flush(bs);
2973 }
2974
2975 return 0;
2976}
2977
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00002978static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
Stefan Hajnocziab185922011-11-17 13:40:31 +00002979 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2980{
2981 /* Perform I/O through a temporary buffer so that users who scribble over
2982 * their read buffer while the operation is in progress do not end up
2983 * modifying the image file. This is critical for zero-copy guest I/O
2984 * where anything might happen inside guest memory.
2985 */
2986 void *bounce_buffer;
2987
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00002988 BlockDriver *drv = bs->drv;
Stefan Hajnocziab185922011-11-17 13:40:31 +00002989 struct iovec iov;
2990 QEMUIOVector bounce_qiov;
2991 int64_t cluster_sector_num;
2992 int cluster_nb_sectors;
2993 size_t skip_bytes;
2994 int ret;
2995
2996 /* Cover entire cluster so no additional backing file I/O is required when
2997 * allocating cluster in the image file.
2998 */
Paolo Bonzini343bded2013-01-21 17:09:42 +01002999 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
3000 &cluster_sector_num, &cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003001
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003002 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
3003 cluster_sector_num, cluster_nb_sectors);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003004
3005 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
3006 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
3007 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
3008
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003009 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
3010 &bounce_qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003011 if (ret < 0) {
3012 goto err;
3013 }
3014
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003015 if (drv->bdrv_co_write_zeroes &&
3016 buffer_is_zero(bounce_buffer, iov.iov_len)) {
Kevin Wolf621f0582012-03-20 15:12:58 +01003017 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003018 cluster_nb_sectors, 0);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003019 } else {
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02003020 /* This does not change the data on the disk, it is not necessary
3021 * to flush even in cache=writethrough mode.
3022 */
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003023 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
Stefan Hajnocziab185922011-11-17 13:40:31 +00003024 &bounce_qiov);
Stefan Hajnoczi79c053b2012-02-07 13:27:26 +00003025 }
3026
Stefan Hajnocziab185922011-11-17 13:40:31 +00003027 if (ret < 0) {
3028 /* It might be okay to ignore write errors for guest requests. If this
3029 * is a deliberate copy-on-read then we don't want to ignore the error.
3030 * Simply report it in all cases.
3031 */
3032 goto err;
3033 }
3034
3035 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
Michael Tokarev03396142012-06-07 20:17:55 +04003036 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3037 nb_sectors * BDRV_SECTOR_SIZE);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003038
3039err:
3040 qemu_vfree(bounce_buffer);
3041 return ret;
3042}
3043
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003044/*
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003045 * Forwards an already correctly aligned request to the BlockDriver. This
3046 * handles copy on read and zeroing after EOF; any other features must be
3047 * implemented by the caller.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003048 */
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003049static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003050 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
Kevin Wolfec746e12013-12-04 12:13:10 +01003051 int64_t align, QEMUIOVector *qiov, int flags)
Kevin Wolfda1fa912011-07-14 17:27:13 +02003052{
3053 BlockDriver *drv = bs->drv;
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00003054 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003055
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003056 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3057 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003058
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003059 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3060 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3061
3062 /* Handle Copy on Read and associated serialisation */
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003063 if (flags & BDRV_REQ_COPY_ON_READ) {
Kevin Wolf73271452013-12-04 17:08:50 +01003064 /* If we touch the same cluster it counts as an overlap. This
3065 * guarantees that allocating writes will be serialized and not race
3066 * with each other for the same cluster. For example, in copy-on-read
3067 * it ensures that the CoR read and write operations are atomic and
3068 * guest writes cannot interleave between them. */
3069 mark_request_serialising(req, bdrv_get_cluster_size(bs));
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003070 }
3071
Kevin Wolf2dbafdc2013-12-04 16:43:44 +01003072 wait_serialising_requests(req);
Stefan Hajnoczif4658282011-11-17 13:40:29 +00003073
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003074 if (flags & BDRV_REQ_COPY_ON_READ) {
Stefan Hajnocziab185922011-11-17 13:40:31 +00003075 int pnum;
3076
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02003077 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003078 if (ret < 0) {
3079 goto out;
3080 }
3081
3082 if (!ret || pnum != nb_sectors) {
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003083 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
Stefan Hajnocziab185922011-11-17 13:40:31 +00003084 goto out;
3085 }
3086 }
3087
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003088 /* Forward the request to the BlockDriver */
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08003089 if (!(bs->zero_beyond_eof && bs->growable)) {
3090 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3091 } else {
3092 /* Read zeros after EOF of growable BDSes */
3093 int64_t len, total_sectors, max_nb_sectors;
3094
3095 len = bdrv_getlength(bs);
3096 if (len < 0) {
3097 ret = len;
3098 goto out;
3099 }
3100
Fam Zhengd055a1f2013-09-26 19:55:33 +08003101 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE);
Kevin Wolf5f5bcd82014-02-07 16:00:09 +01003102 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3103 align >> BDRV_SECTOR_BITS);
MORITA Kazutaka893a8f62013-08-06 09:53:40 +08003104 if (max_nb_sectors > 0) {
3105 ret = drv->bdrv_co_readv(bs, sector_num,
3106 MIN(nb_sectors, max_nb_sectors), qiov);
3107 } else {
3108 ret = 0;
3109 }
3110
3111 /* Reading beyond end of file is supposed to produce zeroes */
3112 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3113 uint64_t offset = MAX(0, total_sectors - sector_num);
3114 uint64_t bytes = (sector_num + nb_sectors - offset) *
3115 BDRV_SECTOR_SIZE;
3116 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3117 }
3118 }
Stefan Hajnocziab185922011-11-17 13:40:31 +00003119
3120out:
Stefan Hajnoczidbffbdc2011-11-17 13:40:27 +00003121 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003122}
3123
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003124/*
3125 * Handle a read request in coroutine context
3126 */
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003127static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3128 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003129 BdrvRequestFlags flags)
3130{
3131 BlockDriver *drv = bs->drv;
Kevin Wolf65afd212013-12-03 14:55:55 +01003132 BdrvTrackedRequest req;
3133
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003134 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3135 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3136 uint8_t *head_buf = NULL;
3137 uint8_t *tail_buf = NULL;
3138 QEMUIOVector local_qiov;
3139 bool use_local_qiov = false;
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003140 int ret;
3141
3142 if (!drv) {
3143 return -ENOMEDIUM;
3144 }
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003145 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003146 return -EIO;
3147 }
3148
3149 if (bs->copy_on_read) {
3150 flags |= BDRV_REQ_COPY_ON_READ;
3151 }
3152
3153 /* throttling disk I/O */
3154 if (bs->io_limits_enabled) {
Kevin Wolfd5103582014-01-16 13:29:10 +01003155 bdrv_io_limits_intercept(bs, bytes, false);
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003156 }
3157
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003158 /* Align read if necessary by padding qiov */
3159 if (offset & (align - 1)) {
3160 head_buf = qemu_blockalign(bs, align);
3161 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3162 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3163 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3164 use_local_qiov = true;
3165
3166 bytes += offset & (align - 1);
3167 offset = offset & ~(align - 1);
3168 }
3169
3170 if ((offset + bytes) & (align - 1)) {
3171 if (!use_local_qiov) {
3172 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3173 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3174 use_local_qiov = true;
3175 }
3176 tail_buf = qemu_blockalign(bs, align);
3177 qemu_iovec_add(&local_qiov, tail_buf,
3178 align - ((offset + bytes) & (align - 1)));
3179
3180 bytes = ROUND_UP(bytes, align);
3181 }
3182
Kevin Wolf65afd212013-12-03 14:55:55 +01003183 tracked_request_begin(&req, bs, offset, bytes, false);
Kevin Wolfec746e12013-12-04 12:13:10 +01003184 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003185 use_local_qiov ? &local_qiov : qiov,
3186 flags);
Kevin Wolf65afd212013-12-03 14:55:55 +01003187 tracked_request_end(&req);
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003188
3189 if (use_local_qiov) {
3190 qemu_iovec_destroy(&local_qiov);
3191 qemu_vfree(head_buf);
3192 qemu_vfree(tail_buf);
3193 }
3194
Kevin Wolfd0c7f642013-12-02 15:07:48 +01003195 return ret;
3196}
3197
Kevin Wolf1b0288a2013-12-02 16:09:46 +01003198static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3199 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3200 BdrvRequestFlags flags)
3201{
3202 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3203 return -EINVAL;
3204 }
3205
3206 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3207 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3208}
3209
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003210int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
Kevin Wolfda1fa912011-07-14 17:27:13 +02003211 int nb_sectors, QEMUIOVector *qiov)
3212{
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003213 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003214
Stefan Hajnoczi470c0502012-01-18 14:40:42 +00003215 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3216}
3217
3218int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3219 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3220{
3221 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3222
3223 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3224 BDRV_REQ_COPY_ON_READ);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003225}
3226
Peter Lievenc31cb702013-10-24 12:06:58 +02003227/* if no limit is specified in the BlockLimits use a default
3228 * of 32768 512-byte sectors (16 MiB) per request.
3229 */
3230#define MAX_WRITE_ZEROES_DEFAULT 32768
3231
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003232static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003233 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003234{
3235 BlockDriver *drv = bs->drv;
3236 QEMUIOVector qiov;
Peter Lievenc31cb702013-10-24 12:06:58 +02003237 struct iovec iov = {0};
3238 int ret = 0;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003239
Peter Lievenc31cb702013-10-24 12:06:58 +02003240 int max_write_zeroes = bs->bl.max_write_zeroes ?
3241 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
Kevin Wolf621f0582012-03-20 15:12:58 +01003242
Peter Lievenc31cb702013-10-24 12:06:58 +02003243 while (nb_sectors > 0 && !ret) {
3244 int num = nb_sectors;
3245
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003246 /* Align request. Block drivers can expect the "bulk" of the request
3247 * to be aligned.
3248 */
3249 if (bs->bl.write_zeroes_alignment
3250 && num > bs->bl.write_zeroes_alignment) {
3251 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3252 /* Make a small request up to the first aligned sector. */
Peter Lievenc31cb702013-10-24 12:06:58 +02003253 num = bs->bl.write_zeroes_alignment;
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003254 num -= sector_num % bs->bl.write_zeroes_alignment;
3255 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3256 /* Shorten the request to the last aligned sector. num cannot
3257 * underflow because num > bs->bl.write_zeroes_alignment.
3258 */
3259 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
Peter Lievenc31cb702013-10-24 12:06:58 +02003260 }
Kevin Wolf621f0582012-03-20 15:12:58 +01003261 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003262
3263 /* limit request size */
3264 if (num > max_write_zeroes) {
3265 num = max_write_zeroes;
3266 }
3267
3268 ret = -ENOTSUP;
3269 /* First try the efficient write zeroes operation */
3270 if (drv->bdrv_co_write_zeroes) {
3271 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3272 }
3273
3274 if (ret == -ENOTSUP) {
3275 /* Fall back to bounce buffer if write zeroes is unsupported */
3276 iov.iov_len = num * BDRV_SECTOR_SIZE;
3277 if (iov.iov_base == NULL) {
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003278 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE);
3279 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
Peter Lievenc31cb702013-10-24 12:06:58 +02003280 }
3281 qemu_iovec_init_external(&qiov, &iov, 1);
3282
3283 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
Paolo Bonzinib8d71c02013-11-22 13:39:48 +01003284
3285 /* Keep bounce buffer around if it is big enough for all
3286 * all future requests.
3287 */
3288 if (num < max_write_zeroes) {
3289 qemu_vfree(iov.iov_base);
3290 iov.iov_base = NULL;
3291 }
Peter Lievenc31cb702013-10-24 12:06:58 +02003292 }
3293
3294 sector_num += num;
3295 nb_sectors -= num;
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003296 }
3297
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003298 qemu_vfree(iov.iov_base);
3299 return ret;
3300}
3301
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003302/*
Kevin Wolfb404f722013-12-03 14:02:23 +01003303 * Forwards an already correctly aligned write request to the BlockDriver.
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003304 */
Kevin Wolfb404f722013-12-03 14:02:23 +01003305static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
Kevin Wolf65afd212013-12-03 14:55:55 +01003306 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3307 QEMUIOVector *qiov, int flags)
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003308{
3309 BlockDriver *drv = bs->drv;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003310 bool waited;
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003311 int ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003312
Kevin Wolfb404f722013-12-03 14:02:23 +01003313 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3314 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003315
Kevin Wolfb404f722013-12-03 14:02:23 +01003316 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3317 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
Benoît Canetcc0681c2013-09-02 14:14:39 +02003318
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003319 waited = wait_serialising_requests(req);
3320 assert(!waited || !req->serialising);
Kevin Wolfaf91f9a2014-02-07 15:35:56 +01003321 assert(req->overlap_offset <= offset);
3322 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
Kevin Wolf244eade2013-12-03 14:30:44 +01003323
Kevin Wolf65afd212013-12-03 14:55:55 +01003324 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003325
Peter Lieven465bee12014-05-18 00:58:19 +02003326 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3327 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3328 qemu_iovec_is_zero(qiov)) {
3329 flags |= BDRV_REQ_ZERO_WRITE;
3330 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3331 flags |= BDRV_REQ_MAY_UNMAP;
3332 }
3333 }
3334
Stefan Hajnoczid616b222013-06-24 17:13:10 +02003335 if (ret < 0) {
3336 /* Do nothing, write notifier decided to fail this request */
3337 } else if (flags & BDRV_REQ_ZERO_WRITE) {
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003338 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003339 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003340 } else {
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003341 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003342 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3343 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003344 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003345
Paolo Bonzinif05fa4a2012-06-06 00:04:49 +02003346 if (ret == 0 && !bs->enable_write_cache) {
3347 ret = bdrv_co_flush(bs);
3348 }
3349
Fam Zhenge4654d22013-11-13 18:29:43 +08003350 bdrv_set_dirty(bs, sector_num, nb_sectors);
Kevin Wolfda1fa912011-07-14 17:27:13 +02003351
3352 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3353 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3354 }
Paolo Bonzinidf2a6f22013-09-04 19:00:21 +02003355 if (bs->growable && ret >= 0) {
3356 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3357 }
Kevin Wolfda1fa912011-07-14 17:27:13 +02003358
Stefan Hajnoczi6b7cb242011-10-13 13:08:24 +01003359 return ret;
Kevin Wolfda1fa912011-07-14 17:27:13 +02003360}
3361
Kevin Wolfb404f722013-12-03 14:02:23 +01003362/*
3363 * Handle a write request in coroutine context
3364 */
Kevin Wolf66015532013-12-03 14:40:18 +01003365static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3366 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
Kevin Wolfb404f722013-12-03 14:02:23 +01003367 BdrvRequestFlags flags)
3368{
Kevin Wolf65afd212013-12-03 14:55:55 +01003369 BdrvTrackedRequest req;
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003370 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3371 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3372 uint8_t *head_buf = NULL;
3373 uint8_t *tail_buf = NULL;
3374 QEMUIOVector local_qiov;
3375 bool use_local_qiov = false;
Kevin Wolfb404f722013-12-03 14:02:23 +01003376 int ret;
3377
3378 if (!bs->drv) {
3379 return -ENOMEDIUM;
3380 }
3381 if (bs->read_only) {
3382 return -EACCES;
3383 }
Kevin Wolf66015532013-12-03 14:40:18 +01003384 if (bdrv_check_byte_request(bs, offset, bytes)) {
Kevin Wolfb404f722013-12-03 14:02:23 +01003385 return -EIO;
3386 }
3387
Kevin Wolfb404f722013-12-03 14:02:23 +01003388 /* throttling disk I/O */
3389 if (bs->io_limits_enabled) {
Kevin Wolfd5103582014-01-16 13:29:10 +01003390 bdrv_io_limits_intercept(bs, bytes, true);
Kevin Wolfb404f722013-12-03 14:02:23 +01003391 }
3392
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003393 /*
3394 * Align write if necessary by performing a read-modify-write cycle.
3395 * Pad qiov with the read parts and be sure to have a tracked request not
3396 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3397 */
Kevin Wolf65afd212013-12-03 14:55:55 +01003398 tracked_request_begin(&req, bs, offset, bytes, true);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003399
3400 if (offset & (align - 1)) {
3401 QEMUIOVector head_qiov;
3402 struct iovec head_iov;
3403
3404 mark_request_serialising(&req, align);
3405 wait_serialising_requests(&req);
3406
3407 head_buf = qemu_blockalign(bs, align);
3408 head_iov = (struct iovec) {
3409 .iov_base = head_buf,
3410 .iov_len = align,
3411 };
3412 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3413
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003414 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003415 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3416 align, &head_qiov, 0);
3417 if (ret < 0) {
3418 goto fail;
3419 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003420 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003421
3422 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3423 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3424 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3425 use_local_qiov = true;
3426
3427 bytes += offset & (align - 1);
3428 offset = offset & ~(align - 1);
3429 }
3430
3431 if ((offset + bytes) & (align - 1)) {
3432 QEMUIOVector tail_qiov;
3433 struct iovec tail_iov;
3434 size_t tail_bytes;
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003435 bool waited;
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003436
3437 mark_request_serialising(&req, align);
Kevin Wolf28de2dc2014-01-14 11:41:35 +01003438 waited = wait_serialising_requests(&req);
3439 assert(!waited || !use_local_qiov);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003440
3441 tail_buf = qemu_blockalign(bs, align);
3442 tail_iov = (struct iovec) {
3443 .iov_base = tail_buf,
3444 .iov_len = align,
3445 };
3446 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3447
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003448 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003449 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3450 align, &tail_qiov, 0);
3451 if (ret < 0) {
3452 goto fail;
3453 }
Kevin Wolf9e1cb962014-01-14 15:37:03 +01003454 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003455
3456 if (!use_local_qiov) {
3457 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3458 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3459 use_local_qiov = true;
3460 }
3461
3462 tail_bytes = (offset + bytes) & (align - 1);
3463 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3464
3465 bytes = ROUND_UP(bytes, align);
3466 }
3467
3468 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3469 use_local_qiov ? &local_qiov : qiov,
3470 flags);
3471
3472fail:
Kevin Wolf65afd212013-12-03 14:55:55 +01003473 tracked_request_end(&req);
Kevin Wolfb404f722013-12-03 14:02:23 +01003474
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003475 if (use_local_qiov) {
3476 qemu_iovec_destroy(&local_qiov);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003477 }
Kevin Wolf99c4a852014-02-07 15:29:00 +01003478 qemu_vfree(head_buf);
3479 qemu_vfree(tail_buf);
Kevin Wolf3b8242e2013-12-03 16:34:41 +01003480
Kevin Wolfb404f722013-12-03 14:02:23 +01003481 return ret;
3482}
3483
Kevin Wolf66015532013-12-03 14:40:18 +01003484static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3485 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3486 BdrvRequestFlags flags)
3487{
3488 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3489 return -EINVAL;
3490 }
3491
3492 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3493 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3494}
3495
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003496int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3497 int nb_sectors, QEMUIOVector *qiov)
3498{
3499 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3500
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003501 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3502}
3503
3504int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003505 int64_t sector_num, int nb_sectors,
3506 BdrvRequestFlags flags)
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003507{
Paolo Bonzini94d6ff22013-11-22 13:39:45 +01003508 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003509
Peter Lievend32f35c2013-10-24 12:06:52 +02003510 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3511 flags &= ~BDRV_REQ_MAY_UNMAP;
3512 }
3513
Stefan Hajnoczif08f2dd2012-02-07 13:27:25 +00003514 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
Peter Lievenaa7bfbf2013-10-24 12:06:51 +02003515 BDRV_REQ_ZERO_WRITE | flags);
Stefan Hajnoczic5fbe572011-10-05 17:17:03 +01003516}
3517
bellard83f64092006-08-01 16:21:11 +00003518/**
bellard83f64092006-08-01 16:21:11 +00003519 * Truncate file to 'offset' bytes (needed only for file protocols)
3520 */
3521int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3522{
3523 BlockDriver *drv = bs->drv;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003524 int ret;
bellard83f64092006-08-01 16:21:11 +00003525 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003526 return -ENOMEDIUM;
bellard83f64092006-08-01 16:21:11 +00003527 if (!drv->bdrv_truncate)
3528 return -ENOTSUP;
Naphtali Sprei59f26892009-10-26 16:25:16 +02003529 if (bs->read_only)
3530 return -EACCES;
Fam Zheng3718d8a2014-05-23 21:29:43 +08003531 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {
Marcelo Tosatti85916752011-01-26 12:12:35 -02003532 return -EBUSY;
Fam Zheng3718d8a2014-05-23 21:29:43 +08003533 }
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003534 ret = drv->bdrv_truncate(bs, offset);
3535 if (ret == 0) {
3536 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
Markus Armbruster145feb12011-08-03 15:07:42 +02003537 bdrv_dev_resize_cb(bs);
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003538 }
3539 return ret;
bellard83f64092006-08-01 16:21:11 +00003540}
3541
3542/**
Fam Zheng4a1d5e12011-07-12 19:56:39 +08003543 * Length of a allocated file in bytes. Sparse files are counted by actual
3544 * allocated space. Return < 0 if error or unknown.
3545 */
3546int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3547{
3548 BlockDriver *drv = bs->drv;
3549 if (!drv) {
3550 return -ENOMEDIUM;
3551 }
3552 if (drv->bdrv_get_allocated_file_size) {
3553 return drv->bdrv_get_allocated_file_size(bs);
3554 }
3555 if (bs->file) {
3556 return bdrv_get_allocated_file_size(bs->file);
3557 }
3558 return -ENOTSUP;
3559}
3560
3561/**
bellard83f64092006-08-01 16:21:11 +00003562 * Length of a file in bytes. Return < 0 if error or unknown.
3563 */
3564int64_t bdrv_getlength(BlockDriverState *bs)
3565{
3566 BlockDriver *drv = bs->drv;
3567 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00003568 return -ENOMEDIUM;
Stefan Hajnoczi51762282010-04-19 16:56:41 +01003569
Kevin Wolfb94a2612013-10-29 12:18:58 +01003570 if (drv->has_variable_length) {
3571 int ret = refresh_total_sectors(bs, bs->total_sectors);
3572 if (ret < 0) {
3573 return ret;
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003574 }
bellard83f64092006-08-01 16:21:11 +00003575 }
Stefan Hajnoczi46a4e4e2011-03-29 20:04:41 +01003576 return bs->total_sectors * BDRV_SECTOR_SIZE;
bellardfc01f7e2003-06-30 10:03:06 +00003577}
3578
bellard19cb3732006-08-19 11:45:59 +00003579/* return 0 as number of sectors if no device present or error */
ths96b8f132007-12-17 01:35:20 +00003580void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
bellardfc01f7e2003-06-30 10:03:06 +00003581{
bellard19cb3732006-08-19 11:45:59 +00003582 int64_t length;
3583 length = bdrv_getlength(bs);
3584 if (length < 0)
3585 length = 0;
3586 else
Jan Kiszka6ea44302009-11-30 18:21:19 +01003587 length = length >> BDRV_SECTOR_BITS;
bellard19cb3732006-08-19 11:45:59 +00003588 *nb_sectors_ptr = length;
bellardfc01f7e2003-06-30 10:03:06 +00003589}
bellardcf989512004-02-16 21:56:36 +00003590
Paolo Bonziniff06f5f2012-09-28 17:22:54 +02003591void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3592 BlockdevOnError on_write_error)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003593{
3594 bs->on_read_error = on_read_error;
3595 bs->on_write_error = on_write_error;
3596}
3597
Paolo Bonzini1ceee0d2012-09-28 17:22:56 +02003598BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
Markus Armbrusterabd7f682010-06-02 18:55:17 +02003599{
3600 return is_read ? bs->on_read_error : bs->on_write_error;
3601}
3602
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003603BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3604{
3605 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3606
3607 switch (on_err) {
3608 case BLOCKDEV_ON_ERROR_ENOSPC:
3609 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
3610 case BLOCKDEV_ON_ERROR_STOP:
3611 return BDRV_ACTION_STOP;
3612 case BLOCKDEV_ON_ERROR_REPORT:
3613 return BDRV_ACTION_REPORT;
3614 case BLOCKDEV_ON_ERROR_IGNORE:
3615 return BDRV_ACTION_IGNORE;
3616 default:
3617 abort();
3618 }
3619}
3620
3621/* This is done by device models because, while the block layer knows
3622 * about the error, it does not know whether an operation comes from
3623 * the device or the block layer (from a job, for example).
3624 */
3625void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3626 bool is_read, int error)
3627{
3628 assert(error >= 0);
Paolo Bonzini32c81a42012-09-28 17:22:58 +02003629 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02003630 if (action == BDRV_ACTION_STOP) {
3631 vm_stop(RUN_STATE_IO_ERROR);
3632 bdrv_iostatus_set_err(bs, error);
3633 }
3634}
3635
bellardb3380822004-03-14 21:38:54 +00003636int bdrv_is_read_only(BlockDriverState *bs)
3637{
3638 return bs->read_only;
3639}
3640
ths985a03b2007-12-24 16:10:43 +00003641int bdrv_is_sg(BlockDriverState *bs)
3642{
3643 return bs->sg;
3644}
3645
Christoph Hellwige900a7b2009-09-04 19:01:15 +02003646int bdrv_enable_write_cache(BlockDriverState *bs)
3647{
3648 return bs->enable_write_cache;
3649}
3650
Paolo Bonzini425b0142012-06-06 00:04:52 +02003651void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3652{
3653 bs->enable_write_cache = wce;
Jeff Cody55b110f2012-09-20 15:13:18 -04003654
3655 /* so a reopen() will preserve wce */
3656 if (wce) {
3657 bs->open_flags |= BDRV_O_CACHE_WB;
3658 } else {
3659 bs->open_flags &= ~BDRV_O_CACHE_WB;
3660 }
Paolo Bonzini425b0142012-06-06 00:04:52 +02003661}
3662
bellardea2384d2004-08-01 21:59:26 +00003663int bdrv_is_encrypted(BlockDriverState *bs)
3664{
3665 if (bs->backing_hd && bs->backing_hd->encrypted)
3666 return 1;
3667 return bs->encrypted;
3668}
3669
aliguoric0f4ce72009-03-05 23:01:01 +00003670int bdrv_key_required(BlockDriverState *bs)
3671{
3672 BlockDriverState *backing_hd = bs->backing_hd;
3673
3674 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3675 return 1;
3676 return (bs->encrypted && !bs->valid_key);
3677}
3678
bellardea2384d2004-08-01 21:59:26 +00003679int bdrv_set_key(BlockDriverState *bs, const char *key)
3680{
3681 int ret;
3682 if (bs->backing_hd && bs->backing_hd->encrypted) {
3683 ret = bdrv_set_key(bs->backing_hd, key);
3684 if (ret < 0)
3685 return ret;
3686 if (!bs->encrypted)
3687 return 0;
3688 }
Shahar Havivifd04a2a2010-03-06 00:26:13 +02003689 if (!bs->encrypted) {
3690 return -EINVAL;
3691 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3692 return -ENOMEDIUM;
3693 }
aliguoric0f4ce72009-03-05 23:01:01 +00003694 ret = bs->drv->bdrv_set_key(bs, key);
aliguoribb5fc202009-03-05 23:01:15 +00003695 if (ret < 0) {
3696 bs->valid_key = 0;
3697 } else if (!bs->valid_key) {
3698 bs->valid_key = 1;
3699 /* call the change callback now, we skipped it on open */
Markus Armbruster7d4b4ba2011-09-06 18:58:59 +02003700 bdrv_dev_change_media_cb(bs, true);
aliguoribb5fc202009-03-05 23:01:15 +00003701 }
aliguoric0f4ce72009-03-05 23:01:01 +00003702 return ret;
bellardea2384d2004-08-01 21:59:26 +00003703}
3704
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003705const char *bdrv_get_format_name(BlockDriverState *bs)
bellardea2384d2004-08-01 21:59:26 +00003706{
Markus Armbrusterf8d6bba2012-06-13 10:11:48 +02003707 return bs->drv ? bs->drv->format_name : NULL;
bellardea2384d2004-08-01 21:59:26 +00003708}
3709
ths5fafdf22007-09-16 21:08:06 +00003710void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
bellardea2384d2004-08-01 21:59:26 +00003711 void *opaque)
3712{
3713 BlockDriver *drv;
Jeff Codye855e4f2014-04-28 18:29:54 -04003714 int count = 0;
3715 const char **formats = NULL;
bellardea2384d2004-08-01 21:59:26 +00003716
Stefan Hajnoczi8a22f022010-04-13 10:29:33 +01003717 QLIST_FOREACH(drv, &bdrv_drivers, list) {
Jeff Codye855e4f2014-04-28 18:29:54 -04003718 if (drv->format_name) {
3719 bool found = false;
3720 int i = count;
3721 while (formats && i && !found) {
3722 found = !strcmp(formats[--i], drv->format_name);
3723 }
3724
3725 if (!found) {
3726 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3727 formats[count++] = drv->format_name;
3728 it(opaque, drv->format_name);
3729 }
3730 }
bellardea2384d2004-08-01 21:59:26 +00003731 }
Jeff Codye855e4f2014-04-28 18:29:54 -04003732 g_free(formats);
bellardea2384d2004-08-01 21:59:26 +00003733}
3734
Benoît Canetdc364f42014-01-23 21:31:32 +01003735/* This function is to find block backend bs */
bellardb3380822004-03-14 21:38:54 +00003736BlockDriverState *bdrv_find(const char *name)
3737{
3738 BlockDriverState *bs;
3739
Benoît Canetdc364f42014-01-23 21:31:32 +01003740 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003741 if (!strcmp(name, bs->device_name)) {
bellardb3380822004-03-14 21:38:54 +00003742 return bs;
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003743 }
bellardb3380822004-03-14 21:38:54 +00003744 }
3745 return NULL;
3746}
3747
Benoît Canetdc364f42014-01-23 21:31:32 +01003748/* This function is to find a node in the bs graph */
3749BlockDriverState *bdrv_find_node(const char *node_name)
3750{
3751 BlockDriverState *bs;
3752
3753 assert(node_name);
3754
3755 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3756 if (!strcmp(node_name, bs->node_name)) {
3757 return bs;
3758 }
3759 }
3760 return NULL;
3761}
3762
Benoît Canetc13163f2014-01-23 21:31:34 +01003763/* Put this QMP function here so it can access the static graph_bdrv_states. */
3764BlockDeviceInfoList *bdrv_named_nodes_list(void)
3765{
3766 BlockDeviceInfoList *list, *entry;
3767 BlockDriverState *bs;
3768
3769 list = NULL;
3770 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3771 entry = g_malloc0(sizeof(*entry));
3772 entry->value = bdrv_block_device_info(bs);
3773 entry->next = list;
3774 list = entry;
3775 }
3776
3777 return list;
3778}
3779
Benoît Canet12d3ba82014-01-23 21:31:35 +01003780BlockDriverState *bdrv_lookup_bs(const char *device,
3781 const char *node_name,
3782 Error **errp)
3783{
3784 BlockDriverState *bs = NULL;
3785
Benoît Canet12d3ba82014-01-23 21:31:35 +01003786 if (device) {
3787 bs = bdrv_find(device);
3788
Benoît Canetdd67fa52014-02-12 17:15:06 +01003789 if (bs) {
3790 return bs;
Benoît Canet12d3ba82014-01-23 21:31:35 +01003791 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01003792 }
3793
Benoît Canetdd67fa52014-02-12 17:15:06 +01003794 if (node_name) {
3795 bs = bdrv_find_node(node_name);
Benoît Canet12d3ba82014-01-23 21:31:35 +01003796
Benoît Canetdd67fa52014-02-12 17:15:06 +01003797 if (bs) {
3798 return bs;
3799 }
Benoît Canet12d3ba82014-01-23 21:31:35 +01003800 }
3801
Benoît Canetdd67fa52014-02-12 17:15:06 +01003802 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3803 device ? device : "",
3804 node_name ? node_name : "");
3805 return NULL;
Benoît Canet12d3ba82014-01-23 21:31:35 +01003806}
3807
Markus Armbruster2f399b02010-06-02 18:55:20 +02003808BlockDriverState *bdrv_next(BlockDriverState *bs)
3809{
3810 if (!bs) {
3811 return QTAILQ_FIRST(&bdrv_states);
3812 }
Benoît Canetdc364f42014-01-23 21:31:32 +01003813 return QTAILQ_NEXT(bs, device_list);
Markus Armbruster2f399b02010-06-02 18:55:20 +02003814}
3815
aliguori51de9762009-03-05 23:00:43 +00003816void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
bellard81d09122004-07-14 17:21:37 +00003817{
3818 BlockDriverState *bs;
3819
Benoît Canetdc364f42014-01-23 21:31:32 +01003820 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
aliguori51de9762009-03-05 23:00:43 +00003821 it(opaque, bs);
bellard81d09122004-07-14 17:21:37 +00003822 }
3823}
3824
bellardea2384d2004-08-01 21:59:26 +00003825const char *bdrv_get_device_name(BlockDriverState *bs)
3826{
3827 return bs->device_name;
3828}
3829
Markus Armbrusterc8433282012-06-05 16:49:24 +02003830int bdrv_get_flags(BlockDriverState *bs)
3831{
3832 return bs->open_flags;
3833}
3834
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003835int bdrv_flush_all(void)
aliguoric6ca28d2008-10-06 13:55:43 +00003836{
3837 BlockDriverState *bs;
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003838 int result = 0;
aliguoric6ca28d2008-10-06 13:55:43 +00003839
Benoît Canetdc364f42014-01-23 21:31:32 +01003840 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003841 AioContext *aio_context = bdrv_get_aio_context(bs);
3842 int ret;
3843
3844 aio_context_acquire(aio_context);
3845 ret = bdrv_flush(bs);
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003846 if (ret < 0 && !result) {
3847 result = ret;
3848 }
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02003849 aio_context_release(aio_context);
Stefan Hajnoczi1b7bdbc2010-04-10 07:02:42 +01003850 }
Kevin Wolff0f0fdf2013-07-05 13:48:01 +02003851
3852 return result;
aliguoric6ca28d2008-10-06 13:55:43 +00003853}
3854
Peter Lieven3ac21622013-06-28 12:47:42 +02003855int bdrv_has_zero_init_1(BlockDriverState *bs)
3856{
3857 return 1;
3858}
3859
Kevin Wolff2feebb2010-04-14 17:30:35 +02003860int bdrv_has_zero_init(BlockDriverState *bs)
3861{
3862 assert(bs->drv);
3863
Paolo Bonzini11212d82013-09-04 19:00:27 +02003864 /* If BS is a copy on write image, it is initialized to
3865 the contents of the base image, which may not be zeroes. */
3866 if (bs->backing_hd) {
3867 return 0;
3868 }
Kevin Wolf336c1c12010-07-28 11:26:29 +02003869 if (bs->drv->bdrv_has_zero_init) {
3870 return bs->drv->bdrv_has_zero_init(bs);
Kevin Wolff2feebb2010-04-14 17:30:35 +02003871 }
3872
Peter Lieven3ac21622013-06-28 12:47:42 +02003873 /* safe default */
3874 return 0;
Kevin Wolff2feebb2010-04-14 17:30:35 +02003875}
3876
Peter Lieven4ce78692013-10-24 12:06:54 +02003877bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3878{
3879 BlockDriverInfo bdi;
3880
3881 if (bs->backing_hd) {
3882 return false;
3883 }
3884
3885 if (bdrv_get_info(bs, &bdi) == 0) {
3886 return bdi.unallocated_blocks_are_zero;
3887 }
3888
3889 return false;
3890}
3891
3892bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3893{
3894 BlockDriverInfo bdi;
3895
3896 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3897 return false;
3898 }
3899
3900 if (bdrv_get_info(bs, &bdi) == 0) {
3901 return bdi.can_write_zeroes_with_unmap;
3902 }
3903
3904 return false;
3905}
3906
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003907typedef struct BdrvCoGetBlockStatusData {
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003908 BlockDriverState *bs;
Miroslav Rezaninab35b2bb2013-02-13 09:09:39 +01003909 BlockDriverState *base;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003910 int64_t sector_num;
3911 int nb_sectors;
3912 int *pnum;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003913 int64_t ret;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003914 bool done;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003915} BdrvCoGetBlockStatusData;
Stefan Hajnoczi376ae3f2011-11-14 12:44:19 +00003916
thsf58c7b32008-06-05 21:53:49 +00003917/*
3918 * Returns true iff the specified sector is present in the disk image. Drivers
3919 * not implementing the functionality are assumed to not support backing files,
3920 * hence all their sectors are reported as allocated.
3921 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003922 * If 'sector_num' is beyond the end of the disk image the return value is 0
3923 * and 'pnum' is set to 0.
3924 *
thsf58c7b32008-06-05 21:53:49 +00003925 * 'pnum' is set to the number of sectors (including and immediately following
3926 * the specified sector) that are known to be in the same
3927 * allocated/unallocated state.
3928 *
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003929 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3930 * beyond the end of the disk image it will be clamped.
thsf58c7b32008-06-05 21:53:49 +00003931 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003932static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3933 int64_t sector_num,
3934 int nb_sectors, int *pnum)
thsf58c7b32008-06-05 21:53:49 +00003935{
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003936 int64_t length;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003937 int64_t n;
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003938 int64_t ret, ret2;
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003939
Paolo Bonzini617ccb42013-09-04 19:00:23 +02003940 length = bdrv_getlength(bs);
3941 if (length < 0) {
3942 return length;
3943 }
3944
3945 if (sector_num >= (length >> BDRV_SECTOR_BITS)) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003946 *pnum = 0;
3947 return 0;
3948 }
3949
3950 n = bs->total_sectors - sector_num;
3951 if (n < nb_sectors) {
3952 nb_sectors = n;
3953 }
3954
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02003955 if (!bs->drv->bdrv_co_get_block_status) {
Stefan Hajnoczibd9533e2011-11-29 13:49:51 +00003956 *pnum = nb_sectors;
Kevin Wolfe88ae222014-05-06 15:25:36 +02003957 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
Paolo Bonzini918e92d2013-09-04 19:00:37 +02003958 if (bs->drv->protocol_name) {
3959 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3960 }
3961 return ret;
thsf58c7b32008-06-05 21:53:49 +00003962 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00003963
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003964 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3965 if (ret < 0) {
Peter Lieven3e0a2332013-09-24 15:35:08 +02003966 *pnum = 0;
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003967 return ret;
3968 }
3969
Peter Lieven92bc50a2013-10-08 14:43:14 +02003970 if (ret & BDRV_BLOCK_RAW) {
3971 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3972 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3973 *pnum, pnum);
3974 }
3975
Kevin Wolfe88ae222014-05-06 15:25:36 +02003976 if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
3977 ret |= BDRV_BLOCK_ALLOCATED;
3978 }
3979
Peter Lievenc3d86882013-10-24 12:07:04 +02003980 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3981 if (bdrv_unallocated_blocks_are_zero(bs)) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003982 ret |= BDRV_BLOCK_ZERO;
Peter Lieven1f9db222013-09-24 15:35:09 +02003983 } else if (bs->backing_hd) {
Paolo Bonzinif0ad5712013-09-04 19:00:32 +02003984 BlockDriverState *bs2 = bs->backing_hd;
3985 int64_t length2 = bdrv_getlength(bs2);
3986 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) {
3987 ret |= BDRV_BLOCK_ZERO;
3988 }
3989 }
Paolo Bonzini415b5b02013-09-04 19:00:31 +02003990 }
Paolo Bonzini5daa74a2013-09-04 19:00:38 +02003991
3992 if (bs->file &&
3993 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3994 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3995 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3996 *pnum, pnum);
3997 if (ret2 >= 0) {
3998 /* Ignore errors. This is just providing extra information, it
3999 * is useful but not necessary.
4000 */
4001 ret |= (ret2 & BDRV_BLOCK_ZERO);
4002 }
4003 }
4004
Paolo Bonzini415b5b02013-09-04 19:00:31 +02004005 return ret;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004006}
4007
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004008/* Coroutine wrapper for bdrv_get_block_status() */
4009static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004010{
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004011 BdrvCoGetBlockStatusData *data = opaque;
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004012 BlockDriverState *bs = data->bs;
4013
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004014 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4015 data->pnum);
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004016 data->done = true;
4017}
4018
4019/*
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004020 * Synchronous wrapper around bdrv_co_get_block_status().
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004021 *
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004022 * See bdrv_co_get_block_status() for details.
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004023 */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004024int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4025 int nb_sectors, int *pnum)
Stefan Hajnoczi060f51c2011-11-14 12:44:26 +00004026{
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004027 Coroutine *co;
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004028 BdrvCoGetBlockStatusData data = {
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004029 .bs = bs,
4030 .sector_num = sector_num,
4031 .nb_sectors = nb_sectors,
4032 .pnum = pnum,
4033 .done = false,
4034 };
4035
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004036 if (qemu_in_coroutine()) {
4037 /* Fast-path if already in coroutine context */
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004038 bdrv_get_block_status_co_entry(&data);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004039 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004040 AioContext *aio_context = bdrv_get_aio_context(bs);
4041
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004042 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004043 qemu_coroutine_enter(co, &data);
4044 while (!data.done) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004045 aio_poll(aio_context, true);
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004046 }
Stefan Hajnoczi6aebab12011-11-14 12:44:25 +00004047 }
4048 return data.ret;
thsf58c7b32008-06-05 21:53:49 +00004049}
4050
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004051int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4052 int nb_sectors, int *pnum)
4053{
Paolo Bonzini4333bb72013-09-04 19:00:29 +02004054 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4055 if (ret < 0) {
4056 return ret;
4057 }
Kevin Wolfe88ae222014-05-06 15:25:36 +02004058 return (ret & BDRV_BLOCK_ALLOCATED);
Paolo Bonzinib6b8a332013-09-04 19:00:28 +02004059}
4060
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004061/*
4062 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4063 *
4064 * Return true if the given sector is allocated in any image between
4065 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4066 * sector is allocated in any image of the chain. Return false otherwise.
4067 *
4068 * 'pnum' is set to the number of sectors (including and immediately following
4069 * the specified sector) that are known to be in the same
4070 * allocated/unallocated state.
4071 *
4072 */
Paolo Bonzini4f578632013-09-04 19:00:24 +02004073int bdrv_is_allocated_above(BlockDriverState *top,
4074 BlockDriverState *base,
4075 int64_t sector_num,
4076 int nb_sectors, int *pnum)
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004077{
4078 BlockDriverState *intermediate;
4079 int ret, n = nb_sectors;
4080
4081 intermediate = top;
4082 while (intermediate && intermediate != base) {
4083 int pnum_inter;
Paolo Bonzinibdad13b2013-09-04 19:00:22 +02004084 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4085 &pnum_inter);
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004086 if (ret < 0) {
4087 return ret;
4088 } else if (ret) {
4089 *pnum = pnum_inter;
4090 return 1;
4091 }
4092
4093 /*
4094 * [sector_num, nb_sectors] is unallocated on top but intermediate
4095 * might have
4096 *
4097 * [sector_num+x, nr_sectors] allocated.
4098 */
Vishvananda Ishaya63ba17d2013-01-24 10:02:08 -08004099 if (n > pnum_inter &&
4100 (intermediate == top ||
4101 sector_num + pnum_inter < intermediate->total_sectors)) {
Paolo Bonzini188a7bb2012-05-08 16:52:01 +02004102 n = pnum_inter;
4103 }
4104
4105 intermediate = intermediate->backing_hd;
4106 }
4107
4108 *pnum = n;
4109 return 0;
4110}
4111
aliguori045df332009-03-05 23:00:48 +00004112const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4113{
4114 if (bs->backing_hd && bs->backing_hd->encrypted)
4115 return bs->backing_file;
4116 else if (bs->encrypted)
4117 return bs->filename;
4118 else
4119 return NULL;
4120}
4121
ths5fafdf22007-09-16 21:08:06 +00004122void bdrv_get_backing_filename(BlockDriverState *bs,
bellard83f64092006-08-01 16:21:11 +00004123 char *filename, int filename_size)
bellardea2384d2004-08-01 21:59:26 +00004124{
Kevin Wolf3574c602011-10-26 11:02:11 +02004125 pstrcpy(filename, filename_size, bs->backing_file);
bellardea2384d2004-08-01 21:59:26 +00004126}
4127
ths5fafdf22007-09-16 21:08:06 +00004128int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
bellardfaea38e2006-08-05 21:31:00 +00004129 const uint8_t *buf, int nb_sectors)
4130{
4131 BlockDriver *drv = bs->drv;
4132 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004133 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00004134 if (!drv->bdrv_write_compressed)
4135 return -ENOTSUP;
Kevin Wolffbb7b4e2009-05-08 14:47:24 +02004136 if (bdrv_check_request(bs, sector_num, nb_sectors))
4137 return -EIO;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004138
Fam Zhenge4654d22013-11-13 18:29:43 +08004139 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
Jan Kiszkaa55eb922009-11-30 18:21:19 +01004140
bellardfaea38e2006-08-05 21:31:00 +00004141 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4142}
ths3b46e622007-09-17 08:09:54 +00004143
bellardfaea38e2006-08-05 21:31:00 +00004144int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4145{
4146 BlockDriver *drv = bs->drv;
4147 if (!drv)
bellard19cb3732006-08-19 11:45:59 +00004148 return -ENOMEDIUM;
bellardfaea38e2006-08-05 21:31:00 +00004149 if (!drv->bdrv_get_info)
4150 return -ENOTSUP;
4151 memset(bdi, 0, sizeof(*bdi));
4152 return drv->bdrv_get_info(bs, bdi);
4153}
4154
Max Reitzeae041f2013-10-09 10:46:16 +02004155ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4156{
4157 BlockDriver *drv = bs->drv;
4158 if (drv && drv->bdrv_get_specific_info) {
4159 return drv->bdrv_get_specific_info(bs);
4160 }
4161 return NULL;
4162}
4163
Christoph Hellwig45566e92009-07-10 23:11:57 +02004164int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4165 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00004166{
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004167 QEMUIOVector qiov;
4168 struct iovec iov = {
4169 .iov_base = (void *) buf,
4170 .iov_len = size,
4171 };
4172
4173 qemu_iovec_init_external(&qiov, &iov, 1);
4174 return bdrv_writev_vmstate(bs, &qiov, pos);
4175}
4176
4177int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4178{
aliguori178e08a2009-04-05 19:10:55 +00004179 BlockDriver *drv = bs->drv;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004180
4181 if (!drv) {
aliguori178e08a2009-04-05 19:10:55 +00004182 return -ENOMEDIUM;
Kevin Wolfcf8074b2013-04-05 21:27:53 +02004183 } else if (drv->bdrv_save_vmstate) {
4184 return drv->bdrv_save_vmstate(bs, qiov, pos);
4185 } else if (bs->file) {
4186 return bdrv_writev_vmstate(bs->file, qiov, pos);
4187 }
4188
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09004189 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00004190}
4191
Christoph Hellwig45566e92009-07-10 23:11:57 +02004192int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4193 int64_t pos, int size)
aliguori178e08a2009-04-05 19:10:55 +00004194{
4195 BlockDriver *drv = bs->drv;
4196 if (!drv)
4197 return -ENOMEDIUM;
MORITA Kazutaka7cdb1f62010-05-28 11:44:58 +09004198 if (drv->bdrv_load_vmstate)
4199 return drv->bdrv_load_vmstate(bs, buf, pos, size);
4200 if (bs->file)
4201 return bdrv_load_vmstate(bs->file, buf, pos, size);
4202 return -ENOTSUP;
aliguori178e08a2009-04-05 19:10:55 +00004203}
4204
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004205void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4206{
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004207 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004208 return;
4209 }
4210
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004211 bs->drv->bdrv_debug_event(bs, event);
Kevin Wolf41c695c2012-12-06 14:32:58 +01004212}
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004213
Kevin Wolf41c695c2012-12-06 14:32:58 +01004214int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4215 const char *tag)
4216{
4217 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4218 bs = bs->file;
4219 }
4220
4221 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4222 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4223 }
4224
4225 return -ENOTSUP;
4226}
4227
Fam Zheng4cc70e92013-11-20 10:01:54 +08004228int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4229{
4230 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4231 bs = bs->file;
4232 }
4233
4234 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4235 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4236 }
4237
4238 return -ENOTSUP;
4239}
4240
Kevin Wolf41c695c2012-12-06 14:32:58 +01004241int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4242{
Max Reitz938789e2014-03-10 23:44:08 +01004243 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
Kevin Wolf41c695c2012-12-06 14:32:58 +01004244 bs = bs->file;
4245 }
4246
4247 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4248 return bs->drv->bdrv_debug_resume(bs, tag);
4249 }
4250
4251 return -ENOTSUP;
4252}
4253
4254bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4255{
4256 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4257 bs = bs->file;
4258 }
4259
4260 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4261 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4262 }
4263
4264 return false;
Kevin Wolf8b9b0cc2010-03-15 17:27:00 +01004265}
4266
Blue Swirl199630b2010-07-25 20:49:34 +00004267int bdrv_is_snapshot(BlockDriverState *bs)
4268{
4269 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4270}
4271
Jeff Codyb1b1d782012-10-16 15:49:09 -04004272/* backing_file can either be relative, or absolute, or a protocol. If it is
4273 * relative, it must be relative to the chain. So, passing in bs->filename
4274 * from a BDS as backing_file should not be done, as that may be relative to
4275 * the CWD rather than the chain. */
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004276BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4277 const char *backing_file)
4278{
Jeff Codyb1b1d782012-10-16 15:49:09 -04004279 char *filename_full = NULL;
4280 char *backing_file_full = NULL;
4281 char *filename_tmp = NULL;
4282 int is_protocol = 0;
4283 BlockDriverState *curr_bs = NULL;
4284 BlockDriverState *retval = NULL;
4285
4286 if (!bs || !bs->drv || !backing_file) {
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004287 return NULL;
4288 }
4289
Jeff Codyb1b1d782012-10-16 15:49:09 -04004290 filename_full = g_malloc(PATH_MAX);
4291 backing_file_full = g_malloc(PATH_MAX);
4292 filename_tmp = g_malloc(PATH_MAX);
4293
4294 is_protocol = path_has_protocol(backing_file);
4295
4296 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4297
4298 /* If either of the filename paths is actually a protocol, then
4299 * compare unmodified paths; otherwise make paths relative */
4300 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4301 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4302 retval = curr_bs->backing_hd;
4303 break;
4304 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004305 } else {
Jeff Codyb1b1d782012-10-16 15:49:09 -04004306 /* If not an absolute filename path, make it relative to the current
4307 * image's filename path */
4308 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4309 backing_file);
4310
4311 /* We are going to compare absolute pathnames */
4312 if (!realpath(filename_tmp, filename_full)) {
4313 continue;
4314 }
4315
4316 /* We need to make sure the backing filename we are comparing against
4317 * is relative to the current image filename (or absolute) */
4318 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4319 curr_bs->backing_file);
4320
4321 if (!realpath(filename_tmp, backing_file_full)) {
4322 continue;
4323 }
4324
4325 if (strcmp(backing_file_full, filename_full) == 0) {
4326 retval = curr_bs->backing_hd;
4327 break;
4328 }
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004329 }
4330 }
4331
Jeff Codyb1b1d782012-10-16 15:49:09 -04004332 g_free(filename_full);
4333 g_free(backing_file_full);
4334 g_free(filename_tmp);
4335 return retval;
Marcelo Tosattie8a6bb92012-01-18 14:40:51 +00004336}
4337
Benoît Canetf198fd12012-08-02 10:22:47 +02004338int bdrv_get_backing_file_depth(BlockDriverState *bs)
4339{
4340 if (!bs->drv) {
4341 return 0;
4342 }
4343
4344 if (!bs->backing_hd) {
4345 return 0;
4346 }
4347
4348 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4349}
4350
Jeff Cody79fac562012-09-27 13:29:15 -04004351BlockDriverState *bdrv_find_base(BlockDriverState *bs)
4352{
4353 BlockDriverState *curr_bs = NULL;
4354
4355 if (!bs) {
4356 return NULL;
4357 }
4358
4359 curr_bs = bs;
4360
4361 while (curr_bs->backing_hd) {
4362 curr_bs = curr_bs->backing_hd;
4363 }
4364 return curr_bs;
4365}
4366
bellard83f64092006-08-01 16:21:11 +00004367/**************************************************************/
4368/* async I/Os */
4369
aliguori3b69e4b2009-01-22 16:59:24 +00004370BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
aliguorif141eaf2009-04-07 18:43:24 +00004371 QEMUIOVector *qiov, int nb_sectors,
aliguori3b69e4b2009-01-22 16:59:24 +00004372 BlockDriverCompletionFunc *cb, void *opaque)
4373{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004374 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4375
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004376 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004377 cb, opaque, false);
bellard83f64092006-08-01 16:21:11 +00004378}
4379
aliguorif141eaf2009-04-07 18:43:24 +00004380BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4381 QEMUIOVector *qiov, int nb_sectors,
4382 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004383{
Stefan Hajnoczibbf0a442010-10-05 14:28:53 +01004384 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4385
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004386 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004387 cb, opaque, true);
bellard83f64092006-08-01 16:21:11 +00004388}
4389
Paolo Bonzinid5ef94d2013-11-22 13:39:46 +01004390BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4391 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4392 BlockDriverCompletionFunc *cb, void *opaque)
4393{
4394 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4395
4396 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4397 BDRV_REQ_ZERO_WRITE | flags,
4398 cb, opaque, true);
4399}
4400
Kevin Wolf40b4f532009-09-09 17:53:37 +02004401
4402typedef struct MultiwriteCB {
4403 int error;
4404 int num_requests;
4405 int num_callbacks;
4406 struct {
4407 BlockDriverCompletionFunc *cb;
4408 void *opaque;
4409 QEMUIOVector *free_qiov;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004410 } callbacks[];
4411} MultiwriteCB;
4412
4413static void multiwrite_user_cb(MultiwriteCB *mcb)
4414{
4415 int i;
4416
4417 for (i = 0; i < mcb->num_callbacks; i++) {
4418 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
Stefan Hajnoczi1e1ea482010-04-21 20:35:45 +01004419 if (mcb->callbacks[i].free_qiov) {
4420 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4421 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004422 g_free(mcb->callbacks[i].free_qiov);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004423 }
4424}
4425
4426static void multiwrite_cb(void *opaque, int ret)
4427{
4428 MultiwriteCB *mcb = opaque;
4429
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004430 trace_multiwrite_cb(mcb, ret);
4431
Kevin Wolfcb6d3ca2010-04-01 22:48:44 +02004432 if (ret < 0 && !mcb->error) {
Kevin Wolf40b4f532009-09-09 17:53:37 +02004433 mcb->error = ret;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004434 }
4435
4436 mcb->num_requests--;
4437 if (mcb->num_requests == 0) {
Kevin Wolfde189a12010-07-01 16:08:51 +02004438 multiwrite_user_cb(mcb);
Anthony Liguori7267c092011-08-20 22:09:37 -05004439 g_free(mcb);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004440 }
4441}
4442
4443static int multiwrite_req_compare(const void *a, const void *b)
4444{
Christoph Hellwig77be4362010-05-19 20:53:10 +02004445 const BlockRequest *req1 = a, *req2 = b;
4446
4447 /*
4448 * Note that we can't simply subtract req2->sector from req1->sector
4449 * here as that could overflow the return value.
4450 */
4451 if (req1->sector > req2->sector) {
4452 return 1;
4453 } else if (req1->sector < req2->sector) {
4454 return -1;
4455 } else {
4456 return 0;
4457 }
Kevin Wolf40b4f532009-09-09 17:53:37 +02004458}
4459
4460/*
4461 * Takes a bunch of requests and tries to merge them. Returns the number of
4462 * requests that remain after merging.
4463 */
4464static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4465 int num_reqs, MultiwriteCB *mcb)
4466{
4467 int i, outidx;
4468
4469 // Sort requests by start sector
4470 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4471
4472 // Check if adjacent requests touch the same clusters. If so, combine them,
4473 // filling up gaps with zero sectors.
4474 outidx = 0;
4475 for (i = 1; i < num_reqs; i++) {
4476 int merge = 0;
4477 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4478
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004479 // Handle exactly sequential writes and overlapping writes.
Kevin Wolf40b4f532009-09-09 17:53:37 +02004480 if (reqs[i].sector <= oldreq_last) {
4481 merge = 1;
4482 }
4483
Christoph Hellwige2a305f2010-01-26 14:49:08 +01004484 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4485 merge = 0;
4486 }
4487
Kevin Wolf40b4f532009-09-09 17:53:37 +02004488 if (merge) {
4489 size_t size;
Anthony Liguori7267c092011-08-20 22:09:37 -05004490 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004491 qemu_iovec_init(qiov,
4492 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4493
4494 // Add the first request to the merged one. If the requests are
4495 // overlapping, drop the last sectors of the first request.
4496 size = (reqs[i].sector - reqs[outidx].sector) << 9;
Michael Tokarev1b093c42012-03-12 21:28:06 +04004497 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004498
Paolo Bonzinib6a127a2012-02-21 16:43:52 +01004499 // We should need to add any zeros between the two requests
4500 assert (reqs[i].sector <= oldreq_last);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004501
4502 // Add the second request
Michael Tokarev1b093c42012-03-12 21:28:06 +04004503 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004504
Kevin Wolfcbf1dff2010-05-21 11:09:42 +02004505 reqs[outidx].nb_sectors = qiov->size >> 9;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004506 reqs[outidx].qiov = qiov;
4507
4508 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4509 } else {
4510 outidx++;
4511 reqs[outidx].sector = reqs[i].sector;
4512 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4513 reqs[outidx].qiov = reqs[i].qiov;
4514 }
4515 }
4516
4517 return outidx + 1;
4518}
4519
4520/*
4521 * Submit multiple AIO write requests at once.
4522 *
4523 * On success, the function returns 0 and all requests in the reqs array have
4524 * been submitted. In error case this function returns -1, and any of the
4525 * requests may or may not be submitted yet. In particular, this means that the
4526 * callback will be called for some of the requests, for others it won't. The
4527 * caller must check the error field of the BlockRequest to wait for the right
4528 * callbacks (if error != 0, no callback will be called).
4529 *
4530 * The implementation may modify the contents of the reqs array, e.g. to merge
4531 * requests. However, the fields opaque and error are left unmodified as they
4532 * are used to signal failure for a single request to the caller.
4533 */
4534int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4535{
Kevin Wolf40b4f532009-09-09 17:53:37 +02004536 MultiwriteCB *mcb;
4537 int i;
4538
Ryan Harper301db7c2011-03-07 10:01:04 -06004539 /* don't submit writes if we don't have a medium */
4540 if (bs->drv == NULL) {
4541 for (i = 0; i < num_reqs; i++) {
4542 reqs[i].error = -ENOMEDIUM;
4543 }
4544 return -1;
4545 }
4546
Kevin Wolf40b4f532009-09-09 17:53:37 +02004547 if (num_reqs == 0) {
4548 return 0;
4549 }
4550
4551 // Create MultiwriteCB structure
Anthony Liguori7267c092011-08-20 22:09:37 -05004552 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
Kevin Wolf40b4f532009-09-09 17:53:37 +02004553 mcb->num_requests = 0;
4554 mcb->num_callbacks = num_reqs;
4555
4556 for (i = 0; i < num_reqs; i++) {
4557 mcb->callbacks[i].cb = reqs[i].cb;
4558 mcb->callbacks[i].opaque = reqs[i].opaque;
4559 }
4560
4561 // Check for mergable requests
4562 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4563
Stefan Hajnoczi6d519a52010-05-22 18:15:08 +01004564 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4565
Paolo Bonzinidf9309f2011-11-14 17:50:50 +01004566 /* Run the aio requests. */
4567 mcb->num_requests = num_reqs;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004568 for (i = 0; i < num_reqs; i++) {
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004569 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4570 reqs[i].nb_sectors, reqs[i].flags,
4571 multiwrite_cb, mcb,
4572 true);
Kevin Wolf40b4f532009-09-09 17:53:37 +02004573 }
4574
4575 return 0;
Kevin Wolf40b4f532009-09-09 17:53:37 +02004576}
4577
bellard83f64092006-08-01 16:21:11 +00004578void bdrv_aio_cancel(BlockDriverAIOCB *acb)
pbrookce1a14d2006-08-07 02:38:06 +00004579{
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004580 acb->aiocb_info->cancel(acb);
bellard83f64092006-08-01 16:21:11 +00004581}
4582
4583/**************************************************************/
4584/* async block device emulation */
4585
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004586typedef struct BlockDriverAIOCBSync {
4587 BlockDriverAIOCB common;
4588 QEMUBH *bh;
4589 int ret;
4590 /* vector translation state */
4591 QEMUIOVector *qiov;
4592 uint8_t *bounce;
4593 int is_write;
4594} BlockDriverAIOCBSync;
4595
4596static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4597{
Kevin Wolfb666d232010-05-05 11:44:39 +02004598 BlockDriverAIOCBSync *acb =
4599 container_of(blockacb, BlockDriverAIOCBSync, common);
Dor Laor6a7ad292009-06-01 12:07:23 +03004600 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004601 acb->bh = NULL;
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004602 qemu_aio_release(acb);
4603}
4604
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004605static const AIOCBInfo bdrv_em_aiocb_info = {
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004606 .aiocb_size = sizeof(BlockDriverAIOCBSync),
4607 .cancel = bdrv_aio_cancel_em,
4608};
4609
bellard83f64092006-08-01 16:21:11 +00004610static void bdrv_aio_bh_cb(void *opaque)
bellardbeac80c2006-06-26 20:08:57 +00004611{
pbrookce1a14d2006-08-07 02:38:06 +00004612 BlockDriverAIOCBSync *acb = opaque;
aliguorif141eaf2009-04-07 18:43:24 +00004613
aliguorif141eaf2009-04-07 18:43:24 +00004614 if (!acb->is_write)
Michael Tokarev03396142012-06-07 20:17:55 +04004615 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
aliguoriceb42de2009-04-07 18:43:28 +00004616 qemu_vfree(acb->bounce);
pbrookce1a14d2006-08-07 02:38:06 +00004617 acb->common.cb(acb->common.opaque, acb->ret);
Dor Laor6a7ad292009-06-01 12:07:23 +03004618 qemu_bh_delete(acb->bh);
Avi Kivity36afc452009-06-23 16:20:36 +03004619 acb->bh = NULL;
pbrookce1a14d2006-08-07 02:38:06 +00004620 qemu_aio_release(acb);
bellardbeac80c2006-06-26 20:08:57 +00004621}
bellardbeac80c2006-06-26 20:08:57 +00004622
aliguorif141eaf2009-04-07 18:43:24 +00004623static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4624 int64_t sector_num,
4625 QEMUIOVector *qiov,
4626 int nb_sectors,
4627 BlockDriverCompletionFunc *cb,
4628 void *opaque,
4629 int is_write)
4630
bellardea2384d2004-08-01 21:59:26 +00004631{
pbrookce1a14d2006-08-07 02:38:06 +00004632 BlockDriverAIOCBSync *acb;
pbrookce1a14d2006-08-07 02:38:06 +00004633
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004634 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
aliguorif141eaf2009-04-07 18:43:24 +00004635 acb->is_write = is_write;
4636 acb->qiov = qiov;
aliguorie268ca52009-04-22 20:20:00 +00004637 acb->bounce = qemu_blockalign(bs, qiov->size);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004638 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
aliguorif141eaf2009-04-07 18:43:24 +00004639
4640 if (is_write) {
Michael Tokarevd5e6b162012-06-07 20:21:06 +04004641 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004642 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004643 } else {
Stefan Hajnoczi1ed20ac2011-10-13 13:08:21 +01004644 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
aliguorif141eaf2009-04-07 18:43:24 +00004645 }
4646
pbrookce1a14d2006-08-07 02:38:06 +00004647 qemu_bh_schedule(acb->bh);
aliguorif141eaf2009-04-07 18:43:24 +00004648
pbrookce1a14d2006-08-07 02:38:06 +00004649 return &acb->common;
pbrook7a6cba62006-06-04 11:39:07 +00004650}
4651
aliguorif141eaf2009-04-07 18:43:24 +00004652static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4653 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
pbrookce1a14d2006-08-07 02:38:06 +00004654 BlockDriverCompletionFunc *cb, void *opaque)
bellard83f64092006-08-01 16:21:11 +00004655{
aliguorif141eaf2009-04-07 18:43:24 +00004656 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
bellard83f64092006-08-01 16:21:11 +00004657}
4658
aliguorif141eaf2009-04-07 18:43:24 +00004659static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4660 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4661 BlockDriverCompletionFunc *cb, void *opaque)
4662{
4663 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4664}
4665
Kevin Wolf68485422011-06-30 10:05:46 +02004666
4667typedef struct BlockDriverAIOCBCoroutine {
4668 BlockDriverAIOCB common;
4669 BlockRequest req;
4670 bool is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004671 bool *done;
Kevin Wolf68485422011-06-30 10:05:46 +02004672 QEMUBH* bh;
4673} BlockDriverAIOCBCoroutine;
4674
4675static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4676{
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004677 AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004678 BlockDriverAIOCBCoroutine *acb =
4679 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4680 bool done = false;
4681
4682 acb->done = &done;
4683 while (!done) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004684 aio_poll(aio_context, true);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004685 }
Kevin Wolf68485422011-06-30 10:05:46 +02004686}
4687
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004688static const AIOCBInfo bdrv_em_co_aiocb_info = {
Kevin Wolf68485422011-06-30 10:05:46 +02004689 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4690 .cancel = bdrv_aio_co_cancel_em,
4691};
4692
Paolo Bonzini35246a62011-10-14 10:41:29 +02004693static void bdrv_co_em_bh(void *opaque)
Kevin Wolf68485422011-06-30 10:05:46 +02004694{
4695 BlockDriverAIOCBCoroutine *acb = opaque;
4696
4697 acb->common.cb(acb->common.opaque, acb->req.error);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004698
4699 if (acb->done) {
4700 *acb->done = true;
4701 }
4702
Kevin Wolf68485422011-06-30 10:05:46 +02004703 qemu_bh_delete(acb->bh);
4704 qemu_aio_release(acb);
4705}
4706
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004707/* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4708static void coroutine_fn bdrv_co_do_rw(void *opaque)
4709{
4710 BlockDriverAIOCBCoroutine *acb = opaque;
4711 BlockDriverState *bs = acb->common.bs;
4712
4713 if (!acb->is_write) {
4714 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004715 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004716 } else {
4717 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004718 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004719 }
4720
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004721 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Stefan Hajnoczib2a61372011-10-13 13:08:23 +01004722 qemu_bh_schedule(acb->bh);
4723}
4724
Kevin Wolf68485422011-06-30 10:05:46 +02004725static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4726 int64_t sector_num,
4727 QEMUIOVector *qiov,
4728 int nb_sectors,
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004729 BdrvRequestFlags flags,
Kevin Wolf68485422011-06-30 10:05:46 +02004730 BlockDriverCompletionFunc *cb,
4731 void *opaque,
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004732 bool is_write)
Kevin Wolf68485422011-06-30 10:05:46 +02004733{
4734 Coroutine *co;
4735 BlockDriverAIOCBCoroutine *acb;
4736
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004737 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolf68485422011-06-30 10:05:46 +02004738 acb->req.sector = sector_num;
4739 acb->req.nb_sectors = nb_sectors;
4740 acb->req.qiov = qiov;
Paolo Bonzinid20d9b72013-11-22 13:39:44 +01004741 acb->req.flags = flags;
Kevin Wolf68485422011-06-30 10:05:46 +02004742 acb->is_write = is_write;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004743 acb->done = NULL;
Kevin Wolf68485422011-06-30 10:05:46 +02004744
Stefan Hajnoczi8c5873d2011-10-13 21:09:28 +01004745 co = qemu_coroutine_create(bdrv_co_do_rw);
Kevin Wolf68485422011-06-30 10:05:46 +02004746 qemu_coroutine_enter(co, acb);
4747
4748 return &acb->common;
4749}
4750
Paolo Bonzini07f07612011-10-17 12:32:12 +02004751static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004752{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004753 BlockDriverAIOCBCoroutine *acb = opaque;
4754 BlockDriverState *bs = acb->common.bs;
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004755
Paolo Bonzini07f07612011-10-17 12:32:12 +02004756 acb->req.error = bdrv_co_flush(bs);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004757 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004758 qemu_bh_schedule(acb->bh);
Christoph Hellwigb2e12bc2009-09-04 19:01:49 +02004759}
4760
Paolo Bonzini07f07612011-10-17 12:32:12 +02004761BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
Alexander Graf016f5cf2010-05-26 17:51:49 +02004762 BlockDriverCompletionFunc *cb, void *opaque)
4763{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004764 trace_bdrv_aio_flush(bs, opaque);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004765
Paolo Bonzini07f07612011-10-17 12:32:12 +02004766 Coroutine *co;
4767 BlockDriverAIOCBCoroutine *acb;
Alexander Graf016f5cf2010-05-26 17:51:49 +02004768
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004769 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Kevin Wolfd318aea2012-11-13 16:35:08 +01004770 acb->done = NULL;
4771
Paolo Bonzini07f07612011-10-17 12:32:12 +02004772 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4773 qemu_coroutine_enter(co, acb);
Alexander Graf016f5cf2010-05-26 17:51:49 +02004774
Alexander Graf016f5cf2010-05-26 17:51:49 +02004775 return &acb->common;
4776}
4777
Paolo Bonzini4265d622011-10-17 12:32:14 +02004778static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4779{
4780 BlockDriverAIOCBCoroutine *acb = opaque;
4781 BlockDriverState *bs = acb->common.bs;
4782
4783 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02004784 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004785 qemu_bh_schedule(acb->bh);
4786}
4787
4788BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4789 int64_t sector_num, int nb_sectors,
4790 BlockDriverCompletionFunc *cb, void *opaque)
4791{
4792 Coroutine *co;
4793 BlockDriverAIOCBCoroutine *acb;
4794
4795 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4796
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004797 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
Paolo Bonzini4265d622011-10-17 12:32:14 +02004798 acb->req.sector = sector_num;
4799 acb->req.nb_sectors = nb_sectors;
Kevin Wolfd318aea2012-11-13 16:35:08 +01004800 acb->done = NULL;
Paolo Bonzini4265d622011-10-17 12:32:14 +02004801 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4802 qemu_coroutine_enter(co, acb);
4803
4804 return &acb->common;
4805}
4806
bellardea2384d2004-08-01 21:59:26 +00004807void bdrv_init(void)
4808{
Anthony Liguori5efa9d52009-05-09 17:03:42 -05004809 module_call_init(MODULE_INIT_BLOCK);
bellardea2384d2004-08-01 21:59:26 +00004810}
pbrookce1a14d2006-08-07 02:38:06 +00004811
Markus Armbrustereb852012009-10-27 18:41:44 +01004812void bdrv_init_with_whitelist(void)
4813{
4814 use_bdrv_whitelist = 1;
4815 bdrv_init();
4816}
4817
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004818void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
Christoph Hellwigc16b5a22009-05-25 12:37:32 +02004819 BlockDriverCompletionFunc *cb, void *opaque)
aliguori6bbff9a2009-03-20 18:25:59 +00004820{
pbrookce1a14d2006-08-07 02:38:06 +00004821 BlockDriverAIOCB *acb;
4822
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004823 acb = g_slice_alloc(aiocb_info->aiocb_size);
4824 acb->aiocb_info = aiocb_info;
pbrookce1a14d2006-08-07 02:38:06 +00004825 acb->bs = bs;
4826 acb->cb = cb;
4827 acb->opaque = opaque;
4828 return acb;
4829}
4830
4831void qemu_aio_release(void *p)
4832{
Stefan Hajnoczid37c9752012-10-31 16:34:36 +01004833 BlockDriverAIOCB *acb = p;
Stefan Hajnoczid7331be2012-10-31 16:34:37 +01004834 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
pbrookce1a14d2006-08-07 02:38:06 +00004835}
bellard19cb3732006-08-19 11:45:59 +00004836
4837/**************************************************************/
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004838/* Coroutine block device emulation */
4839
4840typedef struct CoroutineIOCompletion {
4841 Coroutine *coroutine;
4842 int ret;
4843} CoroutineIOCompletion;
4844
4845static void bdrv_co_io_em_complete(void *opaque, int ret)
4846{
4847 CoroutineIOCompletion *co = opaque;
4848
4849 co->ret = ret;
4850 qemu_coroutine_enter(co->coroutine, NULL);
4851}
4852
4853static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4854 int nb_sectors, QEMUIOVector *iov,
4855 bool is_write)
4856{
4857 CoroutineIOCompletion co = {
4858 .coroutine = qemu_coroutine_self(),
4859 };
4860 BlockDriverAIOCB *acb;
4861
4862 if (is_write) {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004863 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4864 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004865 } else {
Stefan Hajnoczia652d162011-10-05 17:17:02 +01004866 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4867 bdrv_co_io_em_complete, &co);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004868 }
4869
Stefan Hajnoczi59370aa2011-09-30 17:34:58 +01004870 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
Kevin Wolff9f05dc2011-07-15 13:50:26 +02004871 if (!acb) {
4872 return -EIO;
4873 }
4874 qemu_coroutine_yield();
4875
4876 return co.ret;
4877}
4878
4879static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4880 int64_t sector_num, int nb_sectors,
4881 QEMUIOVector *iov)
4882{
4883 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4884}
4885
4886static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4887 int64_t sector_num, int nb_sectors,
4888 QEMUIOVector *iov)
4889{
4890 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4891}
4892
Paolo Bonzini07f07612011-10-17 12:32:12 +02004893static void coroutine_fn bdrv_flush_co_entry(void *opaque)
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004894{
Paolo Bonzini07f07612011-10-17 12:32:12 +02004895 RwCo *rwco = opaque;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004896
Paolo Bonzini07f07612011-10-17 12:32:12 +02004897 rwco->ret = bdrv_co_flush(rwco->bs);
4898}
4899
4900int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4901{
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004902 int ret;
4903
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004904 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
Paolo Bonzini07f07612011-10-17 12:32:12 +02004905 return 0;
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004906 }
4907
Kevin Wolfca716362011-11-10 18:13:59 +01004908 /* Write back cached data to the OS even with cache=unsafe */
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004909 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004910 if (bs->drv->bdrv_co_flush_to_os) {
4911 ret = bs->drv->bdrv_co_flush_to_os(bs);
4912 if (ret < 0) {
4913 return ret;
4914 }
4915 }
4916
Kevin Wolfca716362011-11-10 18:13:59 +01004917 /* But don't actually force it to the disk with cache=unsafe */
4918 if (bs->open_flags & BDRV_O_NO_FLUSH) {
Kevin Wolfd4c82322012-08-15 12:52:45 +02004919 goto flush_parent;
Kevin Wolfca716362011-11-10 18:13:59 +01004920 }
4921
Kevin Wolfbf736fe2013-06-05 15:17:55 +02004922 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
Kevin Wolfeb489bb2011-11-10 18:10:11 +01004923 if (bs->drv->bdrv_co_flush_to_disk) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004924 ret = bs->drv->bdrv_co_flush_to_disk(bs);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004925 } else if (bs->drv->bdrv_aio_flush) {
4926 BlockDriverAIOCB *acb;
4927 CoroutineIOCompletion co = {
4928 .coroutine = qemu_coroutine_self(),
4929 };
4930
4931 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4932 if (acb == NULL) {
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004933 ret = -EIO;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004934 } else {
4935 qemu_coroutine_yield();
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004936 ret = co.ret;
Paolo Bonzini07f07612011-10-17 12:32:12 +02004937 }
Paolo Bonzini07f07612011-10-17 12:32:12 +02004938 } else {
4939 /*
4940 * Some block drivers always operate in either writethrough or unsafe
4941 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4942 * know how the server works (because the behaviour is hardcoded or
4943 * depends on server-side configuration), so we can't ensure that
4944 * everything is safe on disk. Returning an error doesn't work because
4945 * that would break guests even if the server operates in writethrough
4946 * mode.
4947 *
4948 * Let's hope the user knows what he's doing.
4949 */
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004950 ret = 0;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02004951 }
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004952 if (ret < 0) {
4953 return ret;
4954 }
4955
4956 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4957 * in the case of cache=unsafe, so there are no useless flushes.
4958 */
Kevin Wolfd4c82322012-08-15 12:52:45 +02004959flush_parent:
Paolo Bonzini29cdb252012-03-12 18:26:01 +01004960 return bdrv_co_flush(bs->file);
Paolo Bonzini07f07612011-10-17 12:32:12 +02004961}
4962
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004963void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06004964{
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004965 Error *local_err = NULL;
4966 int ret;
4967
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004968 if (!bs->drv) {
4969 return;
Anthony Liguori0f154232011-11-14 15:09:45 -06004970 }
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004971
4972 if (bs->drv->bdrv_invalidate_cache) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004973 bs->drv->bdrv_invalidate_cache(bs, &local_err);
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004974 } else if (bs->file) {
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004975 bdrv_invalidate_cache(bs->file, &local_err);
4976 }
4977 if (local_err) {
4978 error_propagate(errp, local_err);
4979 return;
Kevin Wolf3456a8d2014-03-11 10:58:39 +01004980 }
4981
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004982 ret = refresh_total_sectors(bs, bs->total_sectors);
4983 if (ret < 0) {
4984 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4985 return;
4986 }
Anthony Liguori0f154232011-11-14 15:09:45 -06004987}
4988
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004989void bdrv_invalidate_cache_all(Error **errp)
Anthony Liguori0f154232011-11-14 15:09:45 -06004990{
4991 BlockDriverState *bs;
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004992 Error *local_err = NULL;
Anthony Liguori0f154232011-11-14 15:09:45 -06004993
Benoît Canetdc364f42014-01-23 21:31:32 +01004994 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004995 AioContext *aio_context = bdrv_get_aio_context(bs);
4996
4997 aio_context_acquire(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01004998 bdrv_invalidate_cache(bs, &local_err);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02004999 aio_context_release(aio_context);
Kevin Wolf5a8a30d2014-03-12 15:59:16 +01005000 if (local_err) {
5001 error_propagate(errp, local_err);
5002 return;
5003 }
Anthony Liguori0f154232011-11-14 15:09:45 -06005004 }
5005}
5006
Benoît Canet07789262012-03-23 08:36:49 +01005007void bdrv_clear_incoming_migration_all(void)
5008{
5009 BlockDriverState *bs;
5010
Benoît Canetdc364f42014-01-23 21:31:32 +01005011 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005012 AioContext *aio_context = bdrv_get_aio_context(bs);
5013
5014 aio_context_acquire(aio_context);
Benoît Canet07789262012-03-23 08:36:49 +01005015 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
Stefan Hajnoczied78cda2014-05-08 16:34:35 +02005016 aio_context_release(aio_context);
Benoît Canet07789262012-03-23 08:36:49 +01005017 }
5018}
5019
Paolo Bonzini07f07612011-10-17 12:32:12 +02005020int bdrv_flush(BlockDriverState *bs)
5021{
5022 Coroutine *co;
5023 RwCo rwco = {
5024 .bs = bs,
5025 .ret = NOT_DONE,
5026 };
5027
5028 if (qemu_in_coroutine()) {
5029 /* Fast-path if already in coroutine context */
5030 bdrv_flush_co_entry(&rwco);
5031 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005032 AioContext *aio_context = bdrv_get_aio_context(bs);
5033
Paolo Bonzini07f07612011-10-17 12:32:12 +02005034 co = qemu_coroutine_create(bdrv_flush_co_entry);
5035 qemu_coroutine_enter(co, &rwco);
5036 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005037 aio_poll(aio_context, true);
Paolo Bonzini07f07612011-10-17 12:32:12 +02005038 }
5039 }
5040
5041 return rwco.ret;
Kevin Wolfe7a8a782011-07-15 16:05:00 +02005042}
5043
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005044typedef struct DiscardCo {
5045 BlockDriverState *bs;
5046 int64_t sector_num;
5047 int nb_sectors;
5048 int ret;
5049} DiscardCo;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005050static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5051{
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005052 DiscardCo *rwco = opaque;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005053
5054 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5055}
5056
Peter Lieven6f14da52013-10-24 12:06:59 +02005057/* if no limit is specified in the BlockLimits use a default
5058 * of 32768 512-byte sectors (16 MiB) per request.
5059 */
5060#define MAX_DISCARD_DEFAULT 32768
5061
Paolo Bonzini4265d622011-10-17 12:32:14 +02005062int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5063 int nb_sectors)
5064{
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005065 int max_discard;
5066
Paolo Bonzini4265d622011-10-17 12:32:14 +02005067 if (!bs->drv) {
5068 return -ENOMEDIUM;
5069 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5070 return -EIO;
5071 } else if (bs->read_only) {
5072 return -EROFS;
Paolo Bonzinidf702c92013-01-14 16:26:58 +01005073 }
5074
Fam Zhenge4654d22013-11-13 18:29:43 +08005075 bdrv_reset_dirty(bs, sector_num, nb_sectors);
Paolo Bonzinidf702c92013-01-14 16:26:58 +01005076
Paolo Bonzini9e8f1832013-02-08 14:06:11 +01005077 /* Do nothing if disabled. */
5078 if (!(bs->open_flags & BDRV_O_UNMAP)) {
5079 return 0;
5080 }
5081
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005082 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
Paolo Bonzini4265d622011-10-17 12:32:14 +02005083 return 0;
5084 }
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005085
5086 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5087 while (nb_sectors > 0) {
5088 int ret;
5089 int num = nb_sectors;
5090
5091 /* align request */
5092 if (bs->bl.discard_alignment &&
5093 num >= bs->bl.discard_alignment &&
5094 sector_num % bs->bl.discard_alignment) {
5095 if (num > bs->bl.discard_alignment) {
5096 num = bs->bl.discard_alignment;
5097 }
5098 num -= sector_num % bs->bl.discard_alignment;
5099 }
5100
5101 /* limit request size */
5102 if (num > max_discard) {
5103 num = max_discard;
5104 }
5105
5106 if (bs->drv->bdrv_co_discard) {
5107 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5108 } else {
5109 BlockDriverAIOCB *acb;
5110 CoroutineIOCompletion co = {
5111 .coroutine = qemu_coroutine_self(),
5112 };
5113
5114 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5115 bdrv_co_io_em_complete, &co);
5116 if (acb == NULL) {
5117 return -EIO;
5118 } else {
5119 qemu_coroutine_yield();
5120 ret = co.ret;
5121 }
5122 }
Paolo Bonzini7ce21012013-11-22 13:39:47 +01005123 if (ret && ret != -ENOTSUP) {
Paolo Bonzinid51e9fe2013-11-22 13:39:43 +01005124 return ret;
5125 }
5126
5127 sector_num += num;
5128 nb_sectors -= num;
5129 }
5130 return 0;
Paolo Bonzini4265d622011-10-17 12:32:14 +02005131}
5132
5133int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5134{
5135 Coroutine *co;
Kevin Wolf775aa8b2013-12-05 12:09:38 +01005136 DiscardCo rwco = {
Paolo Bonzini4265d622011-10-17 12:32:14 +02005137 .bs = bs,
5138 .sector_num = sector_num,
5139 .nb_sectors = nb_sectors,
5140 .ret = NOT_DONE,
5141 };
5142
5143 if (qemu_in_coroutine()) {
5144 /* Fast-path if already in coroutine context */
5145 bdrv_discard_co_entry(&rwco);
5146 } else {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005147 AioContext *aio_context = bdrv_get_aio_context(bs);
5148
Paolo Bonzini4265d622011-10-17 12:32:14 +02005149 co = qemu_coroutine_create(bdrv_discard_co_entry);
5150 qemu_coroutine_enter(co, &rwco);
5151 while (rwco.ret == NOT_DONE) {
Stefan Hajnoczi2572b372014-05-08 16:34:34 +02005152 aio_poll(aio_context, true);
Paolo Bonzini4265d622011-10-17 12:32:14 +02005153 }
5154 }
5155
5156 return rwco.ret;
5157}
5158
Kevin Wolff9f05dc2011-07-15 13:50:26 +02005159/**************************************************************/
bellard19cb3732006-08-19 11:45:59 +00005160/* removable device support */
5161
5162/**
5163 * Return TRUE if the media is present
5164 */
5165int bdrv_is_inserted(BlockDriverState *bs)
5166{
5167 BlockDriver *drv = bs->drv;
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005168
bellard19cb3732006-08-19 11:45:59 +00005169 if (!drv)
5170 return 0;
5171 if (!drv->bdrv_is_inserted)
Markus Armbrustera1aff5b2011-09-06 18:58:41 +02005172 return 1;
5173 return drv->bdrv_is_inserted(bs);
bellard19cb3732006-08-19 11:45:59 +00005174}
5175
5176/**
Markus Armbruster8e49ca42011-08-03 15:08:08 +02005177 * Return whether the media changed since the last call to this
5178 * function, or -ENOTSUP if we don't know. Most drivers don't know.
bellard19cb3732006-08-19 11:45:59 +00005179 */
5180int bdrv_media_changed(BlockDriverState *bs)
5181{
5182 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005183
Markus Armbruster8e49ca42011-08-03 15:08:08 +02005184 if (drv && drv->bdrv_media_changed) {
5185 return drv->bdrv_media_changed(bs);
5186 }
5187 return -ENOTSUP;
bellard19cb3732006-08-19 11:45:59 +00005188}
5189
5190/**
5191 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5192 */
Luiz Capitulinof36f3942012-02-03 16:24:53 -02005193void bdrv_eject(BlockDriverState *bs, bool eject_flag)
bellard19cb3732006-08-19 11:45:59 +00005194{
5195 BlockDriver *drv = bs->drv;
bellard19cb3732006-08-19 11:45:59 +00005196
Markus Armbruster822e1cd2011-07-20 18:23:42 +02005197 if (drv && drv->bdrv_eject) {
5198 drv->bdrv_eject(bs, eject_flag);
bellard19cb3732006-08-19 11:45:59 +00005199 }
Luiz Capitulino6f382ed2012-02-14 13:41:13 -02005200
5201 if (bs->device_name[0] != '\0') {
5202 bdrv_emit_qmp_eject_event(bs, eject_flag);
5203 }
bellard19cb3732006-08-19 11:45:59 +00005204}
5205
bellard19cb3732006-08-19 11:45:59 +00005206/**
5207 * Lock or unlock the media (if it is locked, the user won't be able
5208 * to eject it manually).
5209 */
Markus Armbruster025e8492011-09-06 18:58:47 +02005210void bdrv_lock_medium(BlockDriverState *bs, bool locked)
bellard19cb3732006-08-19 11:45:59 +00005211{
5212 BlockDriver *drv = bs->drv;
5213
Markus Armbruster025e8492011-09-06 18:58:47 +02005214 trace_bdrv_lock_medium(bs, locked);
Stefan Hajnoczib8c6d092011-03-29 20:04:40 +01005215
Markus Armbruster025e8492011-09-06 18:58:47 +02005216 if (drv && drv->bdrv_lock_medium) {
5217 drv->bdrv_lock_medium(bs, locked);
bellard19cb3732006-08-19 11:45:59 +00005218 }
5219}
ths985a03b2007-12-24 16:10:43 +00005220
5221/* needed for generic scsi interface */
5222
5223int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5224{
5225 BlockDriver *drv = bs->drv;
5226
5227 if (drv && drv->bdrv_ioctl)
5228 return drv->bdrv_ioctl(bs, req, buf);
5229 return -ENOTSUP;
5230}
aliguori7d780662009-03-12 19:57:08 +00005231
aliguori221f7152009-03-28 17:28:41 +00005232BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5233 unsigned long int req, void *buf,
5234 BlockDriverCompletionFunc *cb, void *opaque)
aliguori7d780662009-03-12 19:57:08 +00005235{
aliguori221f7152009-03-28 17:28:41 +00005236 BlockDriver *drv = bs->drv;
aliguori7d780662009-03-12 19:57:08 +00005237
aliguori221f7152009-03-28 17:28:41 +00005238 if (drv && drv->bdrv_aio_ioctl)
5239 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5240 return NULL;
aliguori7d780662009-03-12 19:57:08 +00005241}
aliguorie268ca52009-04-22 20:20:00 +00005242
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01005243void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
Markus Armbruster7b6f9302011-09-06 18:58:56 +02005244{
Paolo Bonzini1b7fd722011-11-29 11:35:47 +01005245 bs->guest_block_size = align;
Markus Armbruster7b6f9302011-09-06 18:58:56 +02005246}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005247
aliguorie268ca52009-04-22 20:20:00 +00005248void *qemu_blockalign(BlockDriverState *bs, size_t size)
5249{
Kevin Wolf339064d2013-11-28 10:23:32 +01005250 return qemu_memalign(bdrv_opt_mem_align(bs), size);
aliguorie268ca52009-04-22 20:20:00 +00005251}
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005252
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005253/*
5254 * Check if all memory in this vector is sector aligned.
5255 */
5256bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5257{
5258 int i;
Kevin Wolf339064d2013-11-28 10:23:32 +01005259 size_t alignment = bdrv_opt_mem_align(bs);
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005260
5261 for (i = 0; i < qiov->niov; i++) {
Kevin Wolf339064d2013-11-28 10:23:32 +01005262 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005263 return false;
5264 }
Kevin Wolf339064d2013-11-28 10:23:32 +01005265 if (qiov->iov[i].iov_len % alignment) {
Kevin Wolf1ff735b2013-12-05 13:01:46 +01005266 return false;
5267 }
Stefan Hajnoczic53b1c52013-01-11 16:41:27 +01005268 }
5269
5270 return true;
5271}
5272
Fam Zhengb8afb522014-04-16 09:34:30 +08005273BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5274 Error **errp)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005275{
5276 int64_t bitmap_size;
Fam Zhenge4654d22013-11-13 18:29:43 +08005277 BdrvDirtyBitmap *bitmap;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01005278
Paolo Bonzini50717e92013-01-21 17:09:45 +01005279 assert((granularity & (granularity - 1)) == 0);
5280
Fam Zhenge4654d22013-11-13 18:29:43 +08005281 granularity >>= BDRV_SECTOR_BITS;
5282 assert(granularity);
Fam Zhengb8afb522014-04-16 09:34:30 +08005283 bitmap_size = bdrv_getlength(bs);
5284 if (bitmap_size < 0) {
5285 error_setg_errno(errp, -bitmap_size, "could not get length of device");
5286 errno = -bitmap_size;
5287 return NULL;
5288 }
5289 bitmap_size >>= BDRV_SECTOR_BITS;
Fam Zhenge4654d22013-11-13 18:29:43 +08005290 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5291 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5292 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5293 return bitmap;
5294}
5295
5296void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5297{
5298 BdrvDirtyBitmap *bm, *next;
5299 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5300 if (bm == bitmap) {
5301 QLIST_REMOVE(bitmap, list);
5302 hbitmap_free(bitmap->bitmap);
5303 g_free(bitmap);
5304 return;
Jan Kiszkaa55eb922009-11-30 18:21:19 +01005305 }
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005306 }
5307}
5308
Fam Zheng21b56832013-11-13 18:29:44 +08005309BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5310{
5311 BdrvDirtyBitmap *bm;
5312 BlockDirtyInfoList *list = NULL;
5313 BlockDirtyInfoList **plist = &list;
5314
5315 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5316 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5317 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5318 info->count = bdrv_get_dirty_count(bs, bm);
5319 info->granularity =
5320 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5321 entry->value = info;
5322 *plist = entry;
5323 plist = &entry->next;
5324 }
5325
5326 return list;
5327}
5328
Fam Zhenge4654d22013-11-13 18:29:43 +08005329int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005330{
Fam Zhenge4654d22013-11-13 18:29:43 +08005331 if (bitmap) {
5332 return hbitmap_get(bitmap->bitmap, sector);
lirans@il.ibm.com7cd1e322009-11-02 15:40:41 +02005333 } else {
5334 return 0;
5335 }
5336}
5337
Fam Zhenge4654d22013-11-13 18:29:43 +08005338void bdrv_dirty_iter_init(BlockDriverState *bs,
5339 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
Paolo Bonzini1755da12012-10-18 16:49:18 +02005340{
Fam Zhenge4654d22013-11-13 18:29:43 +08005341 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
Paolo Bonzini1755da12012-10-18 16:49:18 +02005342}
5343
5344void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5345 int nr_sectors)
5346{
Fam Zhenge4654d22013-11-13 18:29:43 +08005347 BdrvDirtyBitmap *bitmap;
5348 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5349 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
Paolo Bonzini8f0720e2013-01-21 17:09:41 +01005350 }
Liran Schouraaa0eb72010-01-26 10:31:48 +02005351}
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005352
Fam Zhenge4654d22013-11-13 18:29:43 +08005353void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5354{
5355 BdrvDirtyBitmap *bitmap;
5356 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5357 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5358 }
5359}
5360
5361int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5362{
5363 return hbitmap_count(bitmap->bitmap);
5364}
5365
Fam Zheng9fcb0252013-08-23 09:14:46 +08005366/* Get a reference to bs */
5367void bdrv_ref(BlockDriverState *bs)
5368{
5369 bs->refcnt++;
5370}
5371
5372/* Release a previously grabbed reference to bs.
5373 * If after releasing, reference count is zero, the BlockDriverState is
5374 * deleted. */
5375void bdrv_unref(BlockDriverState *bs)
5376{
5377 assert(bs->refcnt > 0);
5378 if (--bs->refcnt == 0) {
5379 bdrv_delete(bs);
5380 }
5381}
5382
Fam Zhengfbe40ff2014-05-23 21:29:42 +08005383struct BdrvOpBlocker {
5384 Error *reason;
5385 QLIST_ENTRY(BdrvOpBlocker) list;
5386};
5387
5388bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5389{
5390 BdrvOpBlocker *blocker;
5391 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5392 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5393 blocker = QLIST_FIRST(&bs->op_blockers[op]);
5394 if (errp) {
5395 error_setg(errp, "Device '%s' is busy: %s",
5396 bs->device_name, error_get_pretty(blocker->reason));
5397 }
5398 return true;
5399 }
5400 return false;
5401}
5402
5403void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5404{
5405 BdrvOpBlocker *blocker;
5406 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5407
5408 blocker = g_malloc0(sizeof(BdrvOpBlocker));
5409 blocker->reason = reason;
5410 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5411}
5412
5413void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5414{
5415 BdrvOpBlocker *blocker, *next;
5416 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5417 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5418 if (blocker->reason == reason) {
5419 QLIST_REMOVE(blocker, list);
5420 g_free(blocker);
5421 }
5422 }
5423}
5424
5425void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5426{
5427 int i;
5428 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5429 bdrv_op_block(bs, i, reason);
5430 }
5431}
5432
5433void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5434{
5435 int i;
5436 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5437 bdrv_op_unblock(bs, i, reason);
5438 }
5439}
5440
5441bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5442{
5443 int i;
5444
5445 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5446 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5447 return false;
5448 }
5449 }
5450 return true;
5451}
5452
Luiz Capitulino28a72822011-09-26 17:43:50 -03005453void bdrv_iostatus_enable(BlockDriverState *bs)
5454{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005455 bs->iostatus_enabled = true;
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005456 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005457}
5458
5459/* The I/O status is only enabled if the drive explicitly
5460 * enables it _and_ the VM is configured to stop on errors */
5461bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5462{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005463 return (bs->iostatus_enabled &&
Paolo Bonzini92aa5c62012-09-28 17:22:55 +02005464 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5465 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5466 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
Luiz Capitulino28a72822011-09-26 17:43:50 -03005467}
5468
5469void bdrv_iostatus_disable(BlockDriverState *bs)
5470{
Luiz Capitulinod6bf2792011-10-14 17:11:23 -03005471 bs->iostatus_enabled = false;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005472}
5473
5474void bdrv_iostatus_reset(BlockDriverState *bs)
5475{
5476 if (bdrv_iostatus_is_enabled(bs)) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005477 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Paolo Bonzini3bd293c2012-10-18 16:49:27 +02005478 if (bs->job) {
5479 block_job_iostatus_reset(bs->job);
5480 }
Luiz Capitulino28a72822011-09-26 17:43:50 -03005481 }
5482}
5483
Luiz Capitulino28a72822011-09-26 17:43:50 -03005484void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5485{
Paolo Bonzini3e1caa52012-09-28 17:22:57 +02005486 assert(bdrv_iostatus_is_enabled(bs));
5487 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
Luiz Capitulino58e21ef2011-10-14 17:22:24 -03005488 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5489 BLOCK_DEVICE_IO_STATUS_FAILED;
Luiz Capitulino28a72822011-09-26 17:43:50 -03005490 }
5491}
5492
Christoph Hellwiga597e792011-08-25 08:26:01 +02005493void
5494bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5495 enum BlockAcctType type)
5496{
5497 assert(type < BDRV_MAX_IOTYPE);
5498
5499 cookie->bytes = bytes;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005500 cookie->start_time_ns = get_clock();
Christoph Hellwiga597e792011-08-25 08:26:01 +02005501 cookie->type = type;
5502}
5503
5504void
5505bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5506{
5507 assert(cookie->type < BDRV_MAX_IOTYPE);
5508
5509 bs->nr_bytes[cookie->type] += cookie->bytes;
5510 bs->nr_ops[cookie->type]++;
Christoph Hellwigc488c7f2011-08-25 08:26:10 +02005511 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
Christoph Hellwiga597e792011-08-25 08:26:01 +02005512}
5513
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005514void bdrv_img_create(const char *filename, const char *fmt,
5515 const char *base_filename, const char *base_fmt,
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005516 char *options, uint64_t img_size, int flags,
5517 Error **errp, bool quiet)
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005518{
Chunyan Liu83d05212014-06-05 17:20:51 +08005519 QemuOptsList *create_opts = NULL;
5520 QemuOpts *opts = NULL;
5521 const char *backing_fmt, *backing_file;
5522 int64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005523 BlockDriver *drv, *proto_drv;
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005524 BlockDriver *backing_drv = NULL;
Max Reitzcc84d902013-09-06 17:14:26 +02005525 Error *local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005526 int ret = 0;
5527
5528 /* Find driver and parse its options */
5529 drv = bdrv_find_format(fmt);
5530 if (!drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005531 error_setg(errp, "Unknown file format '%s'", fmt);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005532 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005533 }
5534
Kevin Wolf98289622013-07-10 15:47:39 +02005535 proto_drv = bdrv_find_protocol(filename, true);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005536 if (!proto_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005537 error_setg(errp, "Unknown protocol '%s'", filename);
Luiz Capitulinod92ada22012-11-30 10:52:09 -02005538 return;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005539 }
5540
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005541 create_opts = qemu_opts_append(create_opts, drv->create_opts);
5542 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005543
5544 /* Create parameter list with default values */
Chunyan Liu83d05212014-06-05 17:20:51 +08005545 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5546 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005547
5548 /* Parse -o options */
5549 if (options) {
Chunyan Liu83d05212014-06-05 17:20:51 +08005550 if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5551 error_setg(errp, "Invalid options for file format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005552 goto out;
5553 }
5554 }
5555
5556 if (base_filename) {
Chunyan Liu83d05212014-06-05 17:20:51 +08005557 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005558 error_setg(errp, "Backing file not supported for file format '%s'",
5559 fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005560 goto out;
5561 }
5562 }
5563
5564 if (base_fmt) {
Chunyan Liu83d05212014-06-05 17:20:51 +08005565 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005566 error_setg(errp, "Backing file format not supported for file "
5567 "format '%s'", fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005568 goto out;
5569 }
5570 }
5571
Chunyan Liu83d05212014-06-05 17:20:51 +08005572 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5573 if (backing_file) {
5574 if (!strcmp(filename, backing_file)) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005575 error_setg(errp, "Error: Trying to create an image with the "
5576 "same filename as the backing file");
Jes Sorensen792da932010-12-16 13:52:17 +01005577 goto out;
5578 }
5579 }
5580
Chunyan Liu83d05212014-06-05 17:20:51 +08005581 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5582 if (backing_fmt) {
5583 backing_drv = bdrv_find_format(backing_fmt);
Stefan Hajnoczi96df67d2011-01-24 09:32:20 +00005584 if (!backing_drv) {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005585 error_setg(errp, "Unknown backing file format '%s'",
Chunyan Liu83d05212014-06-05 17:20:51 +08005586 backing_fmt);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005587 goto out;
5588 }
5589 }
5590
5591 // The size for the image must always be specified, with one exception:
5592 // If we are using a backing file, we can obtain the size from there
Chunyan Liu83d05212014-06-05 17:20:51 +08005593 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5594 if (size == -1) {
5595 if (backing_file) {
Max Reitz66f6b812013-12-03 14:57:52 +01005596 BlockDriverState *bs;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005597 uint64_t size;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005598 char buf[32];
Paolo Bonzini63090da2012-04-12 14:01:03 +02005599 int back_flags;
5600
5601 /* backing files always opened read-only */
5602 back_flags =
5603 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005604
Max Reitzf67503e2014-02-18 18:33:05 +01005605 bs = NULL;
Chunyan Liu83d05212014-06-05 17:20:51 +08005606 ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
Max Reitzcc84d902013-09-06 17:14:26 +02005607 backing_drv, &local_err);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005608 if (ret < 0) {
Max Reitzcc84d902013-09-06 17:14:26 +02005609 error_setg_errno(errp, -ret, "Could not open '%s': %s",
Chunyan Liu83d05212014-06-05 17:20:51 +08005610 backing_file,
Max Reitzcc84d902013-09-06 17:14:26 +02005611 error_get_pretty(local_err));
5612 error_free(local_err);
5613 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005614 goto out;
5615 }
5616 bdrv_get_geometry(bs, &size);
5617 size *= 512;
5618
5619 snprintf(buf, sizeof(buf), "%" PRId64, size);
Chunyan Liu83d05212014-06-05 17:20:51 +08005620 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
Max Reitz66f6b812013-12-03 14:57:52 +01005621
5622 bdrv_unref(bs);
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005623 } else {
Luiz Capitulino71c79812012-11-30 10:52:04 -02005624 error_setg(errp, "Image creation needs a size parameter");
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005625 goto out;
5626 }
5627 }
5628
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005629 if (!quiet) {
5630 printf("Formatting '%s', fmt=%s ", filename, fmt);
Chunyan Liu83d05212014-06-05 17:20:51 +08005631 qemu_opts_print(opts);
Miroslav Rezaninaf382d432013-02-13 09:09:40 +01005632 puts("");
5633 }
Chunyan Liu83d05212014-06-05 17:20:51 +08005634
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005635 ret = bdrv_create(drv, filename, opts, &local_err);
Chunyan Liu83d05212014-06-05 17:20:51 +08005636
Max Reitzcc84d902013-09-06 17:14:26 +02005637 if (ret == -EFBIG) {
5638 /* This is generally a better message than whatever the driver would
5639 * deliver (especially because of the cluster_size_hint), since that
5640 * is most probably not much different from "image too large". */
5641 const char *cluster_size_hint = "";
Chunyan Liu83d05212014-06-05 17:20:51 +08005642 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
Max Reitzcc84d902013-09-06 17:14:26 +02005643 cluster_size_hint = " (try using a larger cluster size)";
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005644 }
Max Reitzcc84d902013-09-06 17:14:26 +02005645 error_setg(errp, "The image size is too large for file format '%s'"
5646 "%s", fmt, cluster_size_hint);
5647 error_free(local_err);
5648 local_err = NULL;
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005649 }
5650
5651out:
Chunyan Liu83d05212014-06-05 17:20:51 +08005652 qemu_opts_del(opts);
5653 qemu_opts_free(create_opts);
Markus Armbruster84d18f02014-01-30 15:07:28 +01005654 if (local_err) {
Max Reitzcc84d902013-09-06 17:14:26 +02005655 error_propagate(errp, local_err);
5656 }
Jes Sorensenf88e1a42010-12-16 13:52:15 +01005657}
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01005658
5659AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5660{
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02005661 return bs->aio_context;
5662}
5663
5664void bdrv_detach_aio_context(BlockDriverState *bs)
5665{
5666 if (!bs->drv) {
5667 return;
5668 }
5669
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02005670 if (bs->io_limits_enabled) {
5671 throttle_detach_aio_context(&bs->throttle_state);
5672 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02005673 if (bs->drv->bdrv_detach_aio_context) {
5674 bs->drv->bdrv_detach_aio_context(bs);
5675 }
5676 if (bs->file) {
5677 bdrv_detach_aio_context(bs->file);
5678 }
5679 if (bs->backing_hd) {
5680 bdrv_detach_aio_context(bs->backing_hd);
5681 }
5682
5683 bs->aio_context = NULL;
5684}
5685
5686void bdrv_attach_aio_context(BlockDriverState *bs,
5687 AioContext *new_context)
5688{
5689 if (!bs->drv) {
5690 return;
5691 }
5692
5693 bs->aio_context = new_context;
5694
5695 if (bs->backing_hd) {
5696 bdrv_attach_aio_context(bs->backing_hd, new_context);
5697 }
5698 if (bs->file) {
5699 bdrv_attach_aio_context(bs->file, new_context);
5700 }
5701 if (bs->drv->bdrv_attach_aio_context) {
5702 bs->drv->bdrv_attach_aio_context(bs, new_context);
5703 }
Stefan Hajnoczi13af91e2014-05-14 16:22:45 +02005704 if (bs->io_limits_enabled) {
5705 throttle_attach_aio_context(&bs->throttle_state, new_context);
5706 }
Stefan Hajnoczidcd04222014-05-08 16:34:37 +02005707}
5708
5709void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5710{
5711 bdrv_drain_all(); /* ensure there are no in-flight requests */
5712
5713 bdrv_detach_aio_context(bs);
5714
5715 /* This function executes in the old AioContext so acquire the new one in
5716 * case it runs in a different thread.
5717 */
5718 aio_context_acquire(new_context);
5719 bdrv_attach_aio_context(bs, new_context);
5720 aio_context_release(new_context);
Stefan Hajnoczi85d126f2013-03-07 13:41:48 +01005721}
Stefan Hajnoczid616b222013-06-24 17:13:10 +02005722
5723void bdrv_add_before_write_notifier(BlockDriverState *bs,
5724 NotifierWithReturn *notifier)
5725{
5726 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5727}
Max Reitz6f176b42013-09-03 10:09:50 +02005728
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005729int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
Max Reitz6f176b42013-09-03 10:09:50 +02005730{
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005731 if (!bs->drv->bdrv_amend_options) {
Max Reitz6f176b42013-09-03 10:09:50 +02005732 return -ENOTSUP;
5733 }
Chunyan Liuc282e1f2014-06-05 17:21:11 +08005734 return bs->drv->bdrv_amend_options(bs, opts);
Max Reitz6f176b42013-09-03 10:09:50 +02005735}
Benoît Canetf6186f42013-10-02 14:33:48 +02005736
Benoît Canetb5042a32014-03-03 19:11:34 +01005737/* This function will be called by the bdrv_recurse_is_first_non_filter method
5738 * of block filter and by bdrv_is_first_non_filter.
5739 * It is used to test if the given bs is the candidate or recurse more in the
5740 * node graph.
Benoît Canet212a5a82014-01-23 21:31:36 +01005741 */
Benoît Canet212a5a82014-01-23 21:31:36 +01005742bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5743 BlockDriverState *candidate)
Benoît Canetf6186f42013-10-02 14:33:48 +02005744{
Benoît Canetb5042a32014-03-03 19:11:34 +01005745 /* return false if basic checks fails */
5746 if (!bs || !bs->drv) {
5747 return false;
5748 }
5749
5750 /* the code reached a non block filter driver -> check if the bs is
5751 * the same as the candidate. It's the recursion termination condition.
5752 */
5753 if (!bs->drv->is_filter) {
5754 return bs == candidate;
5755 }
5756 /* Down this path the driver is a block filter driver */
5757
5758 /* If the block filter recursion method is defined use it to recurse down
5759 * the node graph.
5760 */
5761 if (bs->drv->bdrv_recurse_is_first_non_filter) {
Benoît Canet212a5a82014-01-23 21:31:36 +01005762 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5763 }
5764
Benoît Canetb5042a32014-03-03 19:11:34 +01005765 /* the driver is a block filter but don't allow to recurse -> return false
5766 */
5767 return false;
Benoît Canet212a5a82014-01-23 21:31:36 +01005768}
5769
5770/* This function checks if the candidate is the first non filter bs down it's
5771 * bs chain. Since we don't have pointers to parents it explore all bs chains
5772 * from the top. Some filters can choose not to pass down the recursion.
5773 */
5774bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5775{
5776 BlockDriverState *bs;
5777
5778 /* walk down the bs forest recursively */
5779 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5780 bool perm;
5781
Benoît Canetb5042a32014-03-03 19:11:34 +01005782 /* try to recurse in this top level bs */
Kevin Wolfe6dc8a12014-02-04 11:45:31 +01005783 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
Benoît Canet212a5a82014-01-23 21:31:36 +01005784
5785 /* candidate is the first non filter */
5786 if (perm) {
5787 return true;
5788 }
5789 }
5790
5791 return false;
Benoît Canetf6186f42013-10-02 14:33:48 +02005792}